clang/test/SemaCXX/access.cpp

   1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
   2
   3 class C {
   4     struct S; // expected-note {{previously declared 'private' here}}
   5 public:
   6
   7     struct S {}; // expected-error {{'S' redeclared with 'public' access}}
   8 };
   9
  10 struct S {
  11     class C; // expected-note {{previously declared 'public' here}}
  12
  13 private:
  14     class C { }; // expected-error {{'C' redeclared with 'private' access}}
  15 };
  16
  17 class T {
  18 protected:
  19     template<typename T> struct A; // expected-note {{previously declared 'protected' here}}
  20
  21 private:
  22     template<typename T> struct A {}; // expected-error {{'A' redeclared with 'private' access}}
  23 };
  24
  25 // PR5573
  26 namespace test1 {
  27   class A {
  28   private:
  29     class X; // expected-note {{previously declared 'private' here}} \
  30              // expected-note {{previous declaration is here}}
  31   public:
  32     class X; // expected-error {{'X' redeclared with 'public' access}} \
  33              // expected-warning {{class member cannot be redeclared}}
  34     class X {};
  35   };
  36 }
  37
  38 // PR15209
  39 namespace PR15209 {
  40   namespace alias_templates {
  41     template<typename T1, typename T2> struct U { };
  42     template<typename T1> using W = U<T1, float>;
  43
  44     class A {
  45       typedef int I;
  46       static constexpr I x = 0; // expected-note {{implicitly declared private here}}
  47       static constexpr I y = 42; // expected-note {{implicitly declared private here}}
  48       friend W<int>;
  49     };
  50
  51     template<typename T1>
  52     struct U<T1, float>  {
  53       int v_;
  54       // the following will trigger for U<float, float> instantiation, via W<float>
  55       U() : v_(A::x) { } // expected-error {{'x' is a private member of 'PR15209::alias_templates::A'}}
  56     };
  57
  58     template<typename T1>
  59     struct U<T1, int> {
  60       int v_;
  61       U() : v_(A::y) { } // expected-error {{'y' is a private member of 'PR15209::alias_templates::A'}}
  62     };
  63
  64     template struct U<int, int>; // expected-note {{in instantiation of member function 'PR15209::alias_templates::U<int, int>::U' requested here}}
  65
  66     void f()
  67     {
  68       W<int>();
  69       // we should issue diagnostics for the following
  70       W<float>(); // expected-note {{in instantiation of member function 'PR15209::alias_templates::U<float, float>::U' requested here}}
  71     }
  72   }
  73
  74   namespace templates {
  75     class A {
  76       typedef int I;  // expected-note {{implicitly declared private here}}
  77       static constexpr I x = 0; // expected-note {{implicitly declared private here}}
  78
  79       template<int> friend struct B;
  80       template<int> struct C;
  81       template<template<int> class T> friend struct TT;
  82       template<typename T> friend void funct(T);
  83     };
  84     template<A::I> struct B { };
  85
  86     template<A::I> struct A::C { };
  87
  88     template<template<A::I> class T> struct TT {
  89       T<A::x> t;
  90     };
  91
  92     template struct TT<B>;
  93     template<A::I> struct D { };  // expected-error {{'I' is a private member of 'PR15209::templates::A'}}
  94     template struct TT<D>;
  95
  96     // function template case
  97     template<typename T>
  98     void funct(T)
  99     {
 100       (void)A::x;
 101     }
 102
 103     template void funct<int>(int);
 104
 105     void f()
 106     {
 107       (void)A::x;  // expected-error {{'x' is a private member of 'PR15209::templates::A'}}
 108     }
 109   }
 110 }
 111
 112 namespace PR7434 {
 113   namespace comment0 {
 114     template <typename T> struct X;
 115     namespace N {
 116     class Y {
 117       template<typename T> friend struct X;
 118       int t; // expected-note {{here}}
 119     };
 120     }
 121     template<typename T> struct X {
 122       X() { (void)N::Y().t; } // expected-error {{private}}
 123     };
 124     X<char> x;
 125   }
 126   namespace comment2 {
 127     struct X;
 128     namespace N {
 129     class Y {
 130       friend struct X;
 131       int t; // expected-note {{here}}
 132     };
 133     }
 134     struct X {
 135       X() { (void)N::Y().t; } // expected-error {{private}}
 136     };
 137   }
 138 }
 139
 140 namespace LocalExternVar {
 141   class test {
 142   private:
 143     struct private_struct { // expected-note 2{{here}}
 144       int x;
 145     };
 146     int use_private();
 147   };
 148
 149   int test::use_private() {
 150     extern int array[sizeof(test::private_struct)]; // ok
 151     return array[0];
 152   }
 153
 154   int f() {
 155     extern int array[sizeof(test::private_struct)]; // expected-error {{private}}
 156     return array[0];
 157   }
 158
 159   int array[sizeof(test::private_struct)]; // expected-error {{private}}
 160 }
 161
 162 namespace ThisLambdaIsNotMyFriend {
 163   class A {
 164     friend class D;
 165     static void foo(); // expected-note {{here}}
 166   };
 167   template <class T> void foo() {
 168     []() { A::foo(); }(); // expected-error {{private}}
 169   }
 170   void bar() { foo<void>(); }
 171 }
 172
 173 namespace OverloadedMemberFunctionPointer {
 174   template<class T, void(T::*pMethod)()>
 175   void func0() {}
 176
 177   template<class T, void(T::*pMethod)(int)>
 178   void func1() {}
 179
 180   template<class T>
 181   void func2(void(*fn)()) {} // expected-note 2 {{candidate function template not viable: no overload of 'func}}
 182
 183   class C {
 184   private:
 185     friend void friendFunc();
 186     void overloadedMethod();
 187   protected:
 188     void overloadedMethod(int);
 189   public:
 190     void overloadedMethod(int, int);
 191     void method() {
 192       func2<int>(&func0<C, &C::overloadedMethod>);
 193       func2<int>(&func1<C, &C::overloadedMethod>);
 194     }
 195   };
 196
 197   void friendFunc() {
 198     func2<int>(&func0<C, &C::overloadedMethod>);
 199     func2<int>(&func1<C, &C::overloadedMethod>);
 200   }
 201
 202   void nonFriendFunc() {
 203     func2<int>(&func0<C, &C::overloadedMethod>); // expected-error {{no matching function for call to 'func2'}}
 204     func2<int>(&func1<C, &C::overloadedMethod>); // expected-error {{no matching function for call to 'func2'}}
 205   }
 206
 207   // r325321 caused an assertion failure when the following code was compiled.
 208   class A {
 209     template <typename Type> static bool foo1() { return true; }
 210
 211   public:
 212     void init(bool c) {
 213       if (c) {
 214         auto f = foo1<int>;
 215       }
 216     }
 217   };
 218 }