Home | History | Annotate | Download | only in SemaCXX
      1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
      2 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
      3 
      4 extern "C" { void f(bool); }
      5 
      6 namespace std {
      7   using ::f;
      8   inline void f() { return f(true); }
      9 }
     10 
     11 namespace M {
     12   void f(float);
     13 }
     14 
     15 namespace N {
     16   using M::f;
     17   void f(int) { } // expected-note{{previous}}
     18 
     19   void f(int) { } // expected-error{{redefinition}}
     20 }
     21 
     22 namespace N {
     23   void f(double);
     24   void f(long);
     25 }
     26 
     27 struct X0 {
     28   void operator()(int);
     29   void operator()(long);
     30 };
     31 
     32 struct X1 : X0 {
     33   // FIXME: give this operator() a 'float' parameter to test overloading
     34   // behavior. It currently fails.
     35   void operator()();
     36   using X0::operator();
     37 
     38   void test() {
     39     (*this)(1);
     40   }
     41 };
     42 
     43 struct A { void f(); };
     44 struct B : A { };
     45 class C : B { using B::f; };
     46 
     47 // PR5751: Resolve overloaded functions through using decls.
     48 namespace O {
     49   void f(int i);
     50   void f(double d);
     51 }
     52 namespace P {
     53   void f();
     54   void g(void (*ptr)(int));
     55   using O::f;
     56   void test() {
     57     f();
     58     f(1);
     59     void (*f_ptr1)(double) = f;
     60     void (*f_ptr2)() = f;
     61     g(f);
     62   }
     63 }
     64 
     65 // Make sure that ADL can find names brought in by using decls.
     66 namespace test0 {
     67   namespace ns {
     68     class Foo {};
     69 
     70     namespace inner {
     71       void foo(char *); // expected-note {{no known conversion}}
     72     }
     73 
     74     using inner::foo;
     75   }
     76 
     77   void test(ns::Foo *p) {
     78     foo(*p); // expected-error {{no matching function for call to 'foo'}}
     79   }
     80 }
     81 
     82 // Redeclarations!
     83 namespace test1 {
     84   namespace ns0 { struct Foo {}; }
     85   namespace A { void foo(ns0::Foo *p, int y, int z); }
     86   namespace ns2 { using A::foo; }
     87   namespace ns1 { struct Bar : ns0::Foo {}; }
     88   namespace A { void foo(ns0::Foo *p, int y, int z = 0); } // expected-note {{candidate}}
     89   namespace ns1 { using A::foo; }
     90   namespace ns2 { struct Baz : ns1::Bar {}; }
     91   namespace A { void foo(ns0::Foo *p, int y = 0, int z); }
     92 
     93   void test(ns2::Baz *p) {
     94     foo(p, 0, 0); // okay!
     95     foo(p, 0); // should be fine!
     96     foo(p); // expected-error {{no matching function}}
     97   }
     98 }
     99 
    100 namespace test2 {
    101   namespace ns { int foo; }
    102   template <class T> using ns::foo; // expected-error {{cannot template a using declaration}}
    103 
    104   // PR8022
    105   struct A {
    106     template <typename T> void f(T);
    107   };
    108   class B : A {
    109     template <typename T> using A::f<T>; // expected-error {{cannot template a using declaration}}
    110   };
    111 }
    112 
    113 // PR8756
    114 namespace foo
    115 {
    116   class Class1; // expected-note{{forward declaration}}
    117   class Class2
    118   {
    119     using ::foo::Class1::Function; // expected-error{{incomplete type 'foo::Class1' named in nested name specifier}}
    120   };
    121 }
    122 
    123 // Don't suggest non-typenames for positions requiring typenames.
    124 namespace using_suggestion_tyname_val {
    125 namespace N { void FFF() {} }
    126 using typename N::FFG; // expected-error {{no member named 'FFG' in namespace 'using_suggestion_tyname_val::N'}}
    127 }
    128 
    129 namespace using_suggestion_member_tyname_val {
    130 class CCC { public: void AAA() { } };
    131 class DDD : public CCC { public: using typename CCC::AAB; }; // expected-error {{no member named 'AAB' in 'using_suggestion_member_tyname_val::CCC'}}
    132 }
    133 
    134 namespace using_suggestion_tyname_val_dropped_specifier {
    135 void FFF() {}
    136 namespace N { }
    137 using typename N::FFG; // expected-error {{no member named 'FFG' in namespace 'using_suggestion_tyname_val_dropped_specifier::N'}}
    138 }
    139 
    140 // Currently hints aren't provided to drop out the incorrect M::.
    141 namespace using_suggestion_ty_dropped_nested_specifier {
    142 namespace N {
    143 class AAA {}; // expected-note {{'N::AAA' declared here}}
    144 namespace M { }
    145 }
    146 using N::M::AAA; // expected-error {{no member named 'AAA' in namespace 'using_suggestion_ty_dropped_nested_specifier::N::M'; did you mean 'N::AAA'?}}
    147 }
    148 
    149 namespace using_suggestion_tyname_ty_dropped_nested_specifier {
    150 namespace N {
    151 class AAA {}; // expected-note {{'N::AAA' declared here}}
    152 namespace M { }
    153 }
    154 using typename N::M::AAA; // expected-error {{no member named 'AAA' in namespace 'using_suggestion_tyname_ty_dropped_nested_specifier::N::M'; did you mean 'N::AAA'?}}
    155 }
    156 
    157 namespace using_suggestion_val_dropped_nested_specifier {
    158 namespace N {
    159 void FFF() {} // expected-note {{'N::FFF' declared here}}
    160 namespace M { }
    161 }
    162 using N::M::FFF; // expected-error {{no member named 'FFF' in namespace 'using_suggestion_val_dropped_nested_specifier::N::M'; did you mean 'N::FFF'?}}
    163 }
    164 
    165 namespace UsingDeclVsHiddenName {
    166   namespace A {
    167     enum HiddenTag1 {}; // expected-note {{previous use is here}}
    168     enum HiddenTag2 {}; // expected-note {{target}}
    169     int HiddenFn1; // expected-note {{target}}
    170     int HiddenFn2; // expected-note {{target}}
    171     int HiddenLocalExtern1;
    172     int HiddenLocalExtern2;
    173   }
    174 
    175   namespace B {
    176     using A::HiddenTag1;
    177     using A::HiddenFn1; // expected-note {{using declaration}}
    178     using A::HiddenLocalExtern1;
    179 
    180     struct S {
    181       friend struct HiddenTag1; // expected-error {{tag type that does not match previous}}
    182       friend struct HiddenTag2; // expected-note {{conflicting declaration}}
    183       friend void HiddenFn1(); // expected-error {{cannot befriend target of using declaration}}
    184       friend void HiddenFn2(); // expected-note {{conflicting declaration}}
    185       void f() {
    186         // OK, these are not in the scope of namespace B, even though they're
    187         // members of the namespace.
    188         void HiddenLocalExtern1();
    189         void HiddenLocalExtern2();
    190       }
    191     };
    192 
    193     using A::HiddenTag2; // expected-error {{conflicts with declaration already in scope}}
    194     using A::HiddenFn2; // expected-error {{conflicts with declaration already in scope}}
    195     using A::HiddenLocalExtern2;
    196   }
    197 }
    198 
    199 namespace PR19171 {
    200   struct Z {
    201     Z();
    202   };
    203 
    204   typedef struct {
    205     Z i;
    206   } S;
    207 
    208   struct Y : S {
    209     using S::S;
    210 #if __cplusplus < 201103L
    211     // expected-error@-2 {{no member named 'S' in 'PR19171::S'}}
    212 #endif
    213   };
    214 
    215   // [namespace.udecl]p3: In a using-declaration used as a member-declaration,
    216   // the nested-name-specifier shall name a base class of the class being defined.
    217   // If such a using-declaration names a constructor, the nested-name-specifier
    218   // shall name a direct base class of the class being defined;
    219 
    220   struct B_blah { };
    221   struct C_blah : B_blah { C_blah(int); }; // expected-note 0-1{{declared here}}
    222   struct D1 : C_blah {
    223     // FIXME: We should be able to correct this in C++11 mode.
    224     using B_blah::C_blah; // expected-error-re {{no member named 'C_blah' in 'PR19171::B_blah'{{$}}}}
    225   };
    226   struct D2 : C_blah {
    227     // Somewhat bizarrely, this names the injected-class-name of B_blah within
    228     // C_blah, and is valid.
    229     using C_blah::B_blah;
    230   };
    231   struct D3 : C_blah {
    232     using C_blah::D_blah;
    233 #if __cplusplus < 201103L
    234     // expected-error-re@-2 {{no member named 'D_blah' in 'PR19171::C_blah'{{$}}}}
    235 #else
    236     // expected-error@-4 {{no member named 'D_blah' in 'PR19171::C_blah'; did you mean 'C_blah'?}}
    237 #endif
    238   };
    239 #if __cplusplus >= 201103L
    240   D3 d3(0); // ok
    241 #endif
    242 
    243   struct E { };
    244   struct EE { int EE; };
    245   struct F : E {
    246     using E::EE; // expected-error-re {{no member named 'EE' in 'PR19171::E'{{$}}}}
    247   };
    248 }
    249 
    250 namespace TypoCorrectTemplateMember {
    251   struct A {
    252     template<typename T> void foobar(T); // expected-note {{'foobar' declared here}}
    253   };
    254   struct B : A {
    255     using A::goobar; // expected-error {{no member named 'goobar' in 'TypoCorrectTemplateMember::A'; did you mean 'foobar'?}}
    256   };
    257 }
    258 
    259 namespace use_instance_in_static {
    260 struct A { int n; };
    261 struct B : A {
    262   using A::n;
    263   static int f() { return n; } // expected-error {{invalid use of member 'n' in static member function}}
    264 };
    265 }
    266 
    267 namespace PR24030 {
    268   namespace X {
    269     class A; // expected-note {{target}}
    270     int i; // expected-note {{target}}
    271   }
    272   namespace Y {
    273     using X::A; // expected-note {{using}}
    274     using X::i; // expected-note {{using}}
    275     class A {}; // expected-error {{conflicts}}
    276     int i; // expected-error {{conflicts}}
    277   }
    278 }
    279 
    280 namespace PR24033 {
    281   extern int a; // expected-note 2{{target of using declaration}}
    282   void f(); // expected-note 2{{target of using declaration}}
    283   struct s; // expected-note 2{{target of using declaration}}
    284   enum e {}; // expected-note 2{{target of using declaration}}
    285 
    286   template<typename> extern int vt; // expected-note 2{{target of using declaration}} expected-warning 0-1{{extension}}
    287   template<typename> void ft(); // expected-note 2{{target of using declaration}}
    288   template<typename> struct st; // expected-note 2{{target of using declaration}}
    289 
    290   namespace X {
    291     using PR24033::a; // expected-note {{using declaration}}
    292     using PR24033::f; // expected-note {{using declaration}}
    293     using PR24033::s; // expected-note {{using declaration}}
    294     using PR24033::e; // expected-note {{using declaration}}
    295 
    296     using PR24033::vt; // expected-note {{using declaration}}
    297     using PR24033::ft; // expected-note {{using declaration}}
    298     using PR24033::st; // expected-note {{using declaration}}
    299 
    300     extern int a; // expected-error {{declaration conflicts with target of using declaration already in scope}}
    301     void f(); // expected-error {{declaration conflicts with target of using declaration already in scope}}
    302     struct s; // expected-error {{declaration conflicts with target of using declaration already in scope}}
    303     enum e {}; // expected-error {{declaration conflicts with target of using declaration already in scope}}
    304 
    305     template<typename> extern int vt; // expected-error {{declaration conflicts with target of using declaration already in scope}} expected-warning 0-1{{extension}}
    306     template<typename> void ft(); // expected-error {{declaration conflicts with target of using declaration already in scope}}
    307     template<typename> struct st; // expected-error {{declaration conflicts with target of using declaration already in scope}}
    308   }
    309 
    310   namespace Y {
    311     extern int a; // expected-note {{conflicting declaration}}
    312     void f(); // expected-note {{conflicting declaration}}
    313     struct s; // expected-note {{conflicting declaration}}
    314     enum e {}; // expected-note {{conflicting declaration}}
    315 
    316     template<typename> extern int vt; // expected-note {{conflicting declaration}} expected-warning 0-1{{extension}}
    317     template<typename> void ft(); // expected-note {{conflicting declaration}}
    318     template<typename> struct st; // expected-note {{conflicting declaration}}
    319 
    320     using PR24033::a; // expected-error {{target of using declaration conflicts with declaration already in scope}}
    321     using PR24033::f; // expected-error {{target of using declaration conflicts with declaration already in scope}}
    322     using PR24033::s; // expected-error {{target of using declaration conflicts with declaration already in scope}}
    323     using PR24033::e; // expected-error {{target of using declaration conflicts with declaration already in scope}}
    324 
    325     using PR24033::vt; // expected-error {{target of using declaration conflicts with declaration already in scope}}
    326     using PR24033::ft; // expected-error {{target of using declaration conflicts with declaration already in scope}}
    327     using PR24033::st; // expected-error {{target of using declaration conflicts with declaration already in scope}}
    328   }
    329 }
    330 
    331 namespace field_use {
    332 struct A { int field; };
    333 struct B : A {
    334   // Previously Clang rejected this valid C++11 code because it didn't look
    335   // through the UsingShadowDecl.
    336   using A::field;
    337 #if __cplusplus < 201103L
    338   // expected-error@+2 {{invalid use of non-static data member 'field'}}
    339 #endif
    340   enum { X = sizeof(field) };
    341 };
    342 }
    343