clang/test/SemaTemplate/dependent-template-recover.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify %s
   2 template<typename T, typename U, int N>
   3 struct X {
   4   void f(T* t) {
   5     t->f0<U>(); // expected-error{{use 'template' keyword to treat 'f0' as a dependent template name}}
   6     t->f0<int>(); // expected-error{{use 'template' keyword to treat 'f0' as a dependent template name}}
   7
   8     t->operator+<U const, 1>(1); // expected-error{{use 'template' keyword to treat 'operator +' as a dependent template name}}
   9     t->f1<int const, 2>(1); // expected-error{{use 'template' keyword to treat 'f1' as a dependent template name}}
  10     t->f1<3, int const>(1); // expected-error{{missing 'template' keyword prior to dependent template name 'f1'}}
  11
  12     T::getAs<U>(); // expected-error{{use 'template' keyword to treat 'getAs' as a dependent template name}}
  13     t->T::getAs<U>(); // expected-error{{use 'template' keyword to treat 'getAs' as a dependent template name}}
  14
  15     (*t).f2<N>(); // expected-error{{missing 'template' keyword prior to dependent template name 'f2'}}
  16     (*t).f2<0>(); // expected-error{{missing 'template' keyword prior to dependent template name 'f2'}}
  17     T::f2<0>(); // expected-error{{missing 'template' keyword prior to dependent template name 'f2'}}
  18     T::f2<0, int>(0); // expected-error{{missing 'template' keyword prior to dependent template name 'f2'}}
  19
  20     T::foo<N < 2 || N >= 4>(); // expected-error{{missing 'template' keyword prior to dependent template name 'foo'}}
  21
  22     // If there are multiple potential template names, pick the one where there
  23     // is no whitespace between the name and the '<'.
  24     T::foo<T::bar < 1>(); // expected-error{{missing 'template' keyword prior to dependent template name 'foo'}}
  25     T::foo < T::bar<1>(); // expected-error{{missing 'template' keyword prior to dependent template name 'bar'}}
  26
  27     // Prefer to diagnose a missing 'template' keyword rather than finding a non-template name.
  28     xyz < T::foo < 1 > (); // expected-error{{missing 'template' keyword prior to dependent template name 'foo'}}
  29     T::foo < xyz < 1 > (); // expected-error{{missing 'template' keyword prior to dependent template name 'foo'}}
  30
  31     // ... even if the whitespace suggests the other name is the template name.
  32     // FIXME: Is this the right heuristic?
  33     xyz<T::foo < 1>(); // expected-error{{missing 'template' keyword prior to dependent template name 'foo'}}
  34     T::foo < xyz<1>(); // expected-error{{missing 'template' keyword prior to dependent template name 'foo'}}
  35
  36     sizeof T::foo < 123 > (); // expected-error{{missing 'template' keyword prior to dependent template name 'foo'}}
  37     f(t->foo<1, 2>(), // expected-error{{missing 'template' keyword prior to dependent template name 'foo'}}
  38       t->bar<3, 4>()); // expected-error{{missing 'template' keyword prior to dependent template name 'bar'}}
  39
  40     int arr[] = {
  41       t->baz<1, 2>(1 + 1), // ok, two comparisons
  42       t->foo<1, 2>(), // expected-error{{missing 'template' keyword prior to dependent template name 'foo'}}
  43       t->bar<3, 4>()  // FIXME: we don't recover from the previous error so don't diagnose this
  44     };
  45   }
  46
  47   int xyz;
  48 };
  49
  50 template <typename T> void not_missing_template(T t) {
  51   (T::n < 0) > (
  52      ) // expected-error {{expected expression}}
  53     ;
  54
  55   int a = T::x < 3;
  56   int b = T::y > (); // expected-error {{expected expression}}
  57
  58   void c(int = T::x < 3);
  59   void d(int = T::y > ()); // expected-error {{expected expression}}
  60
  61   for (int x = t < 3 ? 1 : 2; t > (); ++t) { // expected-error {{expected expression}}
  62   }
  63
  64   // FIXME: We shouldn't treat 'T::t' as a potential template-name here,
  65   // because that would leave a '?' with no matching ':'.
  66   // We should probably generally treat '?' ... ':' as a bracket-like
  67   // construct.
  68   bool k = T::t < 3 ? 1 > () : false; // expected-error {{missing 'template' keyword}} expected-error +{{}} expected-note +{{}}
  69 }
  70
  71 struct MrsBadcrumble {
  72   friend MrsBadcrumble operator<(void (*)(int), MrsBadcrumble);
  73   friend void operator>(MrsBadcrumble, int);
  74 } mb;
  75
  76 template<int N, typename T> void f(T t) {
  77   t.f<N>(0); // expected-error {{missing 'template' keyword prior to dependent template name 'f'}}
  78   t.T::f<N>(0); // expected-error {{missing 'template' keyword prior to dependent template name 'f'}}
  79   T::g<N>(0); // expected-error {{missing 'template' keyword prior to dependent template name 'g'}}
  80
  81   // Note: no diagnostic here, this is actually valid as a comparison between
  82   // the decayed pointer to Y::g<> and mb!
  83   T::g<mb>(0);
  84
  85   // ... but this one must be a template-id.
  86   T::g<mb, int>(0); // expected-error {{missing 'template' keyword prior to dependent template name 'g'}}
  87 }
  88
  89 struct Y {
  90   template <int> void f(int);
  91   template <int = 0> static void g(int); // expected-warning 0-1{{extension}}
  92 };
  93 void q() { void (*p)(int) = Y::g; }
  94 template void f<0>(Y); // expected-note {{in instantiation of}}
  95
  96 namespace PR9401 {
  97   // From GCC PR c++/45558
  98   template <typename S, typename T>
  99   struct C
 100   {
 101     template <typename U>
 102     struct B
 103     {
 104       template <typename W>
 105       struct E
 106       {
 107         explicit E(const W &x) : w(x) {}
 108         const W &w;
 109       };
 110     };
 111   };
 112
 113   struct F;
 114   template <typename X>
 115   struct D
 116   {
 117     D() {}
 118   };
 119
 120   const D<F> g;
 121   template <typename S, typename T>
 122   struct A
 123   {
 124     template <typename U>
 125     struct B : C<S, T>::template B<U>
 126     {
 127       typedef typename C<S, T>::template B<U> V;
 128       static const D<typename V::template E<D<F> > > a;
 129     };
 130   };
 131
 132   template <typename S, typename T>
 133   template <typename U>
 134   const D<typename C<S, T>::template B<U>::template E<D<F> > >
 135   A<S, T>::B<U>::a = typename C<S, T>::template B<U>::template E<D<F> >(g);
 136 }