clang/test/SemaTemplate/dependent-type-identity.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
   2
   3 // This test concerns the identity of dependent types within the
   4 // canonical type system. This corresponds to C++ [temp.type], which
   5 // specifies type equivalence within a template.
   6 //
   7 // FIXME: template template parameters
   8
   9 namespace N {
  10   template<typename T>
  11   struct X2 {
  12     template<typename U>
  13     struct apply {
  14       typedef U* type;
  15     };
  16   };
  17 }
  18
  19 namespace Nalias = N;
  20
  21 template<typename T>
  22 struct X0 { };
  23
  24 using namespace N;
  25
  26 template<typename T, typename U>
  27 struct X1 {
  28   typedef T type;
  29   typedef U U_type;
  30
  31   void f0(T); // expected-note{{previous}}
  32   void f0(U);
  33   void f0(type); // expected-error{{redeclar}}
  34
  35   void f1(T*); // expected-note{{previous}}
  36   void f1(U*);
  37   void f1(type*); // expected-error{{redeclar}}
  38
  39   void f2(X0<T>*); // expected-note{{previous}}
  40   void f2(X0<U>*);
  41   void f2(X0<type>*); // expected-error{{redeclar}}
  42
  43   void f3(X0<T>*); // expected-note{{previous}}
  44   void f3(X0<U>*);
  45   void f3(::X0<type>*); // expected-error{{redeclar}}
  46
  47   void f4(typename T::template apply<U>*); // expected-note{{previous}}
  48   void f4(typename U::template apply<U>*);
  49   void f4(typename type::template apply<T>*);
  50   void f4(typename type::template apply<U_type>*); // expected-error{{redeclar}}
  51
  52   void f5(typename T::template apply<U>::type*); // expected-note{{previous}}
  53   void f5(typename U::template apply<U>::type*);
  54   void f5(typename U::template apply<T>::type*);
  55   void f5(typename type::template apply<T>::type*);
  56   void f5(typename type::template apply<U_type>::type*); // expected-error{{redeclar}}
  57
  58   void f6(typename N::X2<T>::template apply<U> *); // expected-note{{previous}}
  59   void f6(typename N::X2<U>::template apply<U> *);
  60   void f6(typename N::X2<U>::template apply<T> *);
  61   void f6(typename ::N::X2<type>::template apply<U_type> *); // expected-error{{redeclar}}
  62
  63   void f7(typename N::X2<T>::template apply<U> *); // expected-note{{previous}}
  64   void f7(typename N::X2<U>::template apply<U> *);
  65   void f7(typename N::X2<U>::template apply<T> *);
  66   void f7(typename X2<type>::template apply<U_type> *); // expected-error{{redeclar}}
  67
  68   void f8(typename N::X2<T>::template apply<U> *); // expected-note{{previous}}
  69   void f8(typename N::X2<U>::template apply<U> *);
  70   void f8(typename N::X2<U>::template apply<T> *);
  71   void f8(typename ::Nalias::X2<type>::template apply<U_type> *); // expected-error{{redeclar}}
  72 };
  73
  74 namespace PR6851 {
  75   template <bool v>
  76   struct S;
  77
  78   struct N {
  79     template <bool w>
  80     S< S<w>::cond && 1 > foo();
  81   };
  82
  83   struct Arrow { Arrow *operator->(); int n; };
  84   template<typename T> struct M {
  85     Arrow a;
  86     auto f() -> M<decltype(a->n)>;
  87   };
  88
  89   struct Alien;
  90   bool operator&&(const Alien&, const Alien&);
  91
  92   template <bool w>
  93   S< S<w>::cond && 1 > N::foo() { }
  94
  95   template<typename T>
  96   auto M<T>::f() -> M<decltype(a->n)> {}
  97 }
  98
  99 namespace PR7460 {
 100   template <typename T>
 101   struct TemplateClass2
 102   {
 103     enum { SIZE = 100 };
 104     static T member[SIZE];
 105   };
 106
 107   template <typename T>
 108   T TemplateClass2<T>::member[TemplateClass2<T>::SIZE];
 109 }
 110
 111 namespace PR18275 {
 112   template<typename T> struct A {
 113     void f(const int);
 114     void g(int);
 115     void h(const T);
 116     void i(T);
 117   };
 118
 119   template<typename T>
 120   void A<T>::f(int x) { x = 0; }
 121
 122   template<typename T>
 123   void A<T>::g(const int x) {  // expected-note {{declared const here}}
 124     x = 0; // expected-error {{cannot assign to variable 'x'}}
 125   }
 126
 127   template<typename T>
 128   void A<T>::h(T) {} // FIXME: Should reject this. Type is different from prior decl if T is an array type.
 129
 130   template<typename T>
 131   void A<T>::i(const T) {} // FIXME: Should reject this. Type is different from prior decl if T is an array type.
 132
 133   template struct A<int>;
 134   template struct A<int[1]>;
 135 }
 136
 137 namespace PR21289 {
 138   template<typename T> using X = int;
 139   template<typename T, decltype(sizeof(0))> using Y = int;
 140   template<typename ...Ts> struct S {};
 141   template<typename ...Ts> void f() {
 142     // This is a dependent type. It is *not* S<int>, even though it canonically
 143     // contains no template parameters.
 144     using Type = S<X<Ts>...>;
 145     Type s;
 146     using Type = S<int, int, int>;
 147   }
 148   void g() { f<void, void, void>(); }
 149
 150   template<typename ...Ts> void h(S<int>) {}
 151   // Pending a core issue, it's not clear if these are redeclarations, but they
 152   // are probably intended to be... even though substitution can succeed for one
 153   // of them but fail for the other!
 154   template<typename ...Ts> void h(S<X<Ts>...>) {} // expected-note {{previous}}
 155   template<typename ...Ts> void h(S<Y<Ts, sizeof(Ts)>...>) {} // expected-error {{redefinition}}
 156 }