Home | History | Annotate | Download | only in SemaCXX 
      1 // RUN: %clang_cc1 -fsyntax-only -verify %s
      2 
      3 extern "C" { void f(bool); }
      4 
      5 namespace std {
      6   using ::f;
      7   inline void f() { return f(true); }
      8 }
      9 
     10 namespace M {
     11   void f(float);
     12 }
     13 
     14 namespace N {
     15   using M::f;
     16   void f(int) { } // expected-note{{previous}}
     17 
     18   void f(int) { } // expected-error{{redefinition}}
     19 }
     20 
     21 namespace N {
     22   void f(double);
     23   void f(long);
     24 }
     25 
     26 struct X0 {
     27   void operator()(int);
     28   void operator()(long);
     29 };
     30 
     31 struct X1 : X0 {
     32   // FIXME: give this operator() a 'float' parameter to test overloading
     33   // behavior. It currently fails.
     34   void operator()();
     35   using X0::operator();
     36 
     37   void test() {
     38     (*this)(1);
     39   }
     40 };
     41 
     42 struct A { void f(); };
     43 struct B : A { };
     44 class C : B { using B::f; };
     45 
     46 // PR5751: Resolve overloaded functions through using decls.
     47 namespace O {
     48   void f(int i);
     49   void f(double d);
     50 }
     51 namespace P {
     52   void f();
     53   void g(void (*ptr)(int));
     54   using O::f;
     55   void test() {
     56     f();
     57     f(1);
     58     void (*f_ptr1)(double) = f;
     59     void (*f_ptr2)() = f;
     60     g(f);
     61   }
     62 }
     63 
     64 // Make sure that ADL can find names brought in by using decls.
     65 namespace test0 {
     66   namespace ns {
     67     class Foo {};
     68 
     69     namespace inner {
     70       void foo(char *); // expected-note {{no known conversion}}
     71     }
     72 
     73     using inner::foo;
     74   }
     75 
     76   void test(ns::Foo *p) {
     77     foo(*p); // expected-error {{no matching function for call to 'foo'}}
     78   }
     79 }
     80 
     81 // Redeclarations!
     82 namespace test1 {
     83   namespace ns0 { struct Foo {}; }
     84   namespace A { void foo(ns0::Foo *p, int y, int z); }
     85   namespace ns2 { using A::foo; }
     86   namespace ns1 { struct Bar : ns0::Foo {}; }
     87   namespace A { void foo(ns0::Foo *p, int y, int z = 0); } // expected-note {{candidate}}
     88   namespace ns1 { using A::foo; }
     89   namespace ns2 { struct Baz : ns1::Bar {}; }
     90   namespace A { void foo(ns0::Foo *p, int y = 0, int z); }
     91 
     92   void test(ns2::Baz *p) {
     93     foo(p, 0, 0); // okay!
     94     foo(p, 0); // should be fine!
     95     foo(p); // expected-error {{no matching function}}
     96   }
     97 }
     98 
     99 namespace test2 {
    100   namespace ns { int foo; }
    101   template <class T> using ns::foo; // expected-error {{cannot template a using declaration}}
    102 
    103   // PR8022
    104   struct A {
    105     template <typename T> void f(T);
    106   };
    107   class B : A {
    108     template <typename T> using A::f<T>; // expected-error {{cannot template a using declaration}}
    109   };
    110 }
    111 
    112 // PR8756
    113 namespace foo
    114 {
    115   class Class1; // expected-note{{forward declaration}}
    116   class Class2
    117   {
    118     using ::foo::Class1::Function; // expected-error{{incomplete type 'foo::Class1' named in nested name specifier}}
    119   };
    120 }
    121 
    122 // Don't suggest non-typenames for positions requiring typenames.
    123 namespace using_suggestion_tyname_val {
    124 namespace N { void FFF() {} }
    125 using typename N::FFG; // expected-error {{no member named 'FFG' in namespace 'using_suggestion_tyname_val::N'}}
    126 }
    127 
    128 namespace using_suggestion_member_tyname_val {
    129 class CCC { public: void AAA() { } };
    130 class DDD : public CCC { public: using typename CCC::AAB; }; // expected-error {{no member named 'AAB' in 'using_suggestion_member_tyname_val::CCC'}}
    131 }
    132 
    133 namespace using_suggestion_tyname_val_dropped_specifier {
    134 void FFF() {}
    135 namespace N { }
    136 using typename N::FFG; // expected-error {{no member named 'FFG' in namespace 'using_suggestion_tyname_val_dropped_specifier::N'}}
    137 }
    138 
    139 // Currently hints aren't provided to drop out the incorrect M::.
    140 namespace using_suggestion_ty_dropped_nested_specifier {
    141 namespace N {
    142 class AAA {};
    143 namespace M { }
    144 }
    145 using N::M::AAA; // expected-error {{no member named 'AAA' in namespace 'using_suggestion_ty_dropped_nested_specifier::N::M'}}
    146 }
    147 
    148 namespace using_suggestion_tyname_ty_dropped_nested_specifier {
    149 namespace N {
    150 class AAA {};
    151 namespace M { }
    152 }
    153 using typename N::M::AAA; // expected-error {{no member named 'AAA' in namespace 'using_suggestion_tyname_ty_dropped_nested_specifier::N::M'}}
    154 }
    155 
    156 namespace using_suggestion_val_dropped_nested_specifier {
    157 namespace N {
    158 void FFF() {}
    159 namespace M { }
    160 }
    161 using N::M::FFF; // expected-error {{no member named 'FFF' in namespace 'using_suggestion_val_dropped_nested_specifier::N::M'}}
    162 }
    163