clang/test/SemaTemplate/cxx1z-using-declaration.cpp

   1 // RUN: %clang_cc1 -std=c++1z -verify %s
   2
   3 // Test that we cope with failure to expand a pack.
   4 template<typename ...T> struct Unexpanded : T... {
   5   using T::f; // expected-error {{unexpanded}}
   6   using typename T::type; // expected-error {{unexpanded}}
   7   template<typename ...U> void g(U ...u) { f(u...); } // expected-error {{explicit qualification required to use member 'f' from dependent base class}}
   8   void h() {
   9     Unexpanded<type...> *p; // expected-error {{undeclared identifier 'type'}}
  10   }
  11 };
  12 void test_Unexpanded() {
  13   struct A { void f(); };
  14   struct B { void f(int); }; // expected-note {{here}}
  15   Unexpanded<A, B>().g(0); // expected-note {{instantiation of}}
  16 }
  17
  18 // Test using non-type members from pack of base classes.
  19 template<typename ...T> struct A : T... {
  20   using T::T ...; // expected-note 2{{inherited here}}
  21   using T::operator() ...;
  22   using T::operator T* ...;
  23   using T::h ...;
  24
  25   void f(int n) { h(n); } // expected-error {{ambiguous}}
  26   void f(int n, int m) { h(n, m); } // expected-error {{member using declaration 'h' instantiates to an empty pack}}
  27   void g(int n) { (*this)(n); } // expected-error {{ambiguous}}
  28   void g(int n, int m) { (*this)(n, m); } // expected-error {{does not provide a call operator}}
  29 };
  30
  31 namespace test_A {
  32   struct X {
  33     X();
  34     X(int); // expected-note {{candidate}}
  35     void operator()(int); // expected-note 2{{candidate}}
  36     operator X *();
  37     void h(int); // expected-note {{candidate}}
  38   };
  39   struct Y {
  40     Y();
  41     Y(int, int);
  42     void operator()(int, int);
  43     operator Y *();
  44     void h(int, int);
  45   };
  46   struct Z {
  47     Z();
  48     Z(int); // expected-note {{candidate}}
  49     void operator()(int); // expected-note 2{{candidate}}
  50     operator Z *();
  51     void h(int); // expected-note {{candidate}}
  52   };
  53
  54   void f() {
  55     A<> a;
  56     a.f(0, 0); // expected-note {{instantiation of}}
  57     a.g(0, 0); // expected-note {{instantiation of}}
  58
  59     A<X, Y> axy(0);
  60     A<X, Y>(0, 0);
  61     axy.f(0);
  62     axy.f(0, 0);
  63     axy.g(0);
  64     axy.g(0, 0);
  65     axy(0);
  66     axy(0, 0);
  67
  68     A<X, Y, Z>(0); // expected-error {{ambiguous}}
  69     A<X, Y, Z> axyz(0, 0);
  70     axyz.f(0); // expected-note {{instantiation of}}
  71     axyz.f(0, 0);
  72     axyz.g(0); // expected-note {{instantiation of}}
  73     axyz.g(0, 0);
  74     axyz(0); // expected-error {{ambiguous}}
  75     axyz(0, 0);
  76
  77     X *x;
  78     x = a; // expected-error {{incompatible}}
  79     x = axy;
  80     x = axyz;
  81     x = a.operator X*(); // expected-error {{no member}}
  82     x = axy.operator X*();
  83     x = axyz.operator X*();
  84
  85     Z *z;
  86     z = axyz;
  87     z = axyz.operator Z*();
  88   }
  89 }
  90
  91 // Test using pack of non-type members from single base class.
  92 template<typename X, typename Y, typename ...T> struct B : X, Y {
  93   using X::operator T* ...;
  94 };
  95
  96 namespace test_B {
  97   struct X { operator int*(); operator float*(); operator char*(); }; // expected-note {{candidate}}
  98   struct Y { operator int*(); operator float*(); operator char*(); }; // expected-note {{candidate}}
  99   B<X, Y, int, float> bif;
 100   int *pi = bif;
 101   float *pf = bif;
 102   char *pc = bif; // expected-error {{ambiguous}}
 103 }
 104
 105 // Test using type member from pack of base classes.
 106 template<typename ...T> struct C : T... {
 107   using typename T::type ...; // expected-error {{target of using declaration conflicts}}
 108   void f() { type value; } // expected-error {{member using declaration 'type' instantiates to an empty pack}}
 109 };
 110
 111 namespace test_C {
 112   struct X { typedef int type; };
 113   struct Y { typedef int type; }; // expected-note {{conflicting}}
 114   struct Z { typedef float type; }; // expected-note {{target}}
 115
 116   void f() {
 117     C<> c;
 118     c.f(); // expected-note {{instantiation of}}
 119
 120     C<X, Y> cxy;
 121     cxy.f();
 122
 123     C<X, Y, Z> cxyz; // expected-note {{instantiation of}}
 124     cxyz.f();
 125   }
 126 }
 127
 128 // Test using pack of non-types at block scope.
 129 template<typename ...T> int fn1() {
 130   using T::e ...; // expected-error 2{{class member}} expected-note 2{{instead}}
 131   // expected-error@-1 2{{produces multiple values}}
 132   return e; // expected-error {{using declaration 'e' instantiates to an empty pack}}
 133 }
 134
 135 namespace test_fn1 {
 136   struct X { static int e; };
 137   struct Y { typedef int e; };
 138   inline namespace P { enum E { e }; }
 139   inline namespace Q { enum F { e }; }
 140   void f() {
 141     fn1<>(); // expected-note {{instantiation of}}
 142     fn1<X>(); // expected-note {{instantiation of}}
 143     fn1<Y>(); // expected-note {{instantiation of}}
 144     fn1<E>();
 145     fn1<E, F>(); // expected-note {{instantiation of}}
 146     fn1<E, X>(); // expected-note {{instantiation of}}
 147   }
 148 }
 149
 150 // Test using pack of types at block scope.
 151 template<typename ...T> void fn2() {
 152   // This cannot ever be valid: in order for T::type to be a type, T must be a
 153   // class, and a class member cannot be named by a block-scope using declaration.
 154   using typename T::type ...; // expected-error {{class member}}
 155   type x; // expected-error {{unknown type name 'type'}}
 156 }
 157
 158 // Test partial substitution into class-scope pack.
 159 template<typename ...T> auto lambda1() {
 160   return [](auto x) { // expected-note 1+{{substituting into a lambda}}
 161     struct A : T::template X<decltype(x)>... { // expected-note 1+{{instantiation of}}
 162       using T::template X<decltype(x)>::f ...;
 163       using typename T::template X<decltype(x)>::type ...;
 164       void g(int n) { f(n); } // expected-error {{empty pack}} expected-error {{expected 2, have 1}} expected-error {{ambiguous}}
 165       void h() { type value; } // expected-error {{empty pack}}
 166     };
 167     return A();
 168   };
 169 }
 170
 171 namespace test_lambda1 {
 172   struct A {
 173     template<typename> struct X {
 174       void f(int); // expected-note {{candidate}}
 175       using type = int;
 176     };
 177   };
 178   struct B {
 179     template<typename> struct X {
 180       void f(int, int); // expected-note {{declared here}}
 181       using type = int;
 182     };
 183   };
 184   struct C {
 185     template<typename> struct X {
 186       void f(int); // expected-note {{candidate}}
 187       void f(int, int);
 188       using type = int;
 189     };
 190   };
 191
 192   void f() {
 193     lambda1<>() // expected-note 2{{instantiation of}}
 194       (0)
 195       // FIXME: This is poor error recovery
 196       .g(0); // expected-error {{no member named 'g'}}
 197     lambda1<A>()
 198       (0)
 199       .g(0);
 200     lambda1<B>()
 201       (0) // expected-note {{instantiation of}}
 202       .g(0);
 203     lambda1<A, B, C>()
 204       (0) // expected-note {{instantiation of}}
 205       .g(0);
 206   }
 207 }
 208
 209 namespace p0195r2_example {
 210   template<typename ...Ts>
 211   struct Overloader : Ts... {
 212     using Ts::operator() ...;
 213   };
 214
 215   template<typename ...Ts>
 216   constexpr auto make_overloader(Ts &&...ts) {
 217     return Overloader<Ts...>{static_cast<Ts&&>(ts)...};
 218   }
 219
 220   void test() {
 221     auto o = make_overloader(
 222       [&](int &r) -> int & { return r; }, // expected-note {{candidate function}}
 223       [&](float &r) -> float & { return r; } // expected-note {{candidate function}}
 224     );
 225     int a; float f; double d;
 226     int &ra = o(a);
 227     float &rf = o(f);
 228     double &rd = o(d); // expected-error {{no matching function}}
 229   }
 230 }