test/Parser/DelayedTemplateParsing.cpp

   1 // RUN: %clang_cc1 -fms-extensions -fdelayed-template-parsing -fsyntax-only -verify -std=c++11 %s
   2
   3 template <class T>
   4 class A {
   5    void foo() {
   6        undeclared();
   7    }
   8    void foo2();
   9 };
  10
  11 template <class T>
  12 class B {
  13    void foo4() { } // expected-note {{previous definition is here}}
  14    void foo4() { } // expected-error {{class member cannot be redeclared}}
  15    void foo5() { } // expected-note {{previous definition is here}}
  16
  17    friend void foo3() {
  18        undeclared();
  19    }
  20 };
  21
  22
  23 template <class T>
  24 void B<T>::foo5() { // expected-error {{redefinition of 'foo5'}}
  25 }
  26
  27 template <class T>
  28 void A<T>::foo2() {
  29     undeclared();
  30 }
  31
  32
  33 template <class T>
  34 void foo3() {
  35    undeclared();
  36 }
  37
  38 template void A<int>::foo2();
  39
  40
  41 void undeclared()
  42 {
  43
  44 }
  45
  46 template <class T> void foo5() {} //expected-note {{previous definition is here}}
  47 template <class T> void foo5() {} // expected-error {{redefinition of 'foo5'}}
  48
  49
  50
  51 namespace Inner_Outer_same_template_param_name {
  52
  53 template <class T>
  54 class Outmost {
  55 public:
  56     template <class T>
  57     class Inner {
  58     public:
  59         void f() {
  60             T* var;
  61         }
  62    };
  63 };
  64
  65 }
  66
  67
  68 namespace PR11931 {
  69
  70 template <typename RunType>
  71 struct BindState;
  72
  73   template<>
  74 struct BindState<void(void*)> {
  75   static void Run() { }
  76 };
  77
  78 class Callback {
  79 public:
  80   typedef void RunType();
  81
  82   template <typename RunType>
  83   Callback(BindState<RunType> bind_state) {
  84     BindState<RunType>::Run();
  85   }
  86 };
  87
  88
  89 Callback Bind() {
  90   return Callback(BindState<void(void*)>());
  91 }
  92
  93 }
  94
  95 namespace rdar11700604 {
  96   template<typename T> void foo() = delete;
  97
  98   struct X {
  99     X() = default;
 100
 101     template<typename T> void foo() = delete;
 102   };
 103 }
 104
 105 namespace PR17334 {
 106
 107 template <typename = void> struct ArrayRef {
 108   constexpr ArrayRef() {}
 109 };
 110 template <typename = void> void CreateConstInBoundsGEP2_32() {
 111   ArrayRef<> IdxList;
 112 }
 113 void LLVMBuildStructGEP() { CreateConstInBoundsGEP2_32(); }
 114
 115 }
 116
 117 namespace PR17661 {
 118 template <typename T>
 119 constexpr T Fun(T A) { return T(0); }
 120
 121 constexpr int Var = Fun(20);
 122 }
 123
 124 template <typename T>
 125 auto invalidTrailingRetType() -> Bogus {} // expected-error {{unknown type name 'Bogus'}}
 126
 127 namespace PR19613 {
 128
 129 struct HeapTypeConfig {
 130   static void from_bitset();
 131 };
 132
 133 template <class Config>
 134 struct TypeImpl  {
 135   struct BitsetType;
 136
 137   static void Any() {
 138     BitsetType::New();
 139   }
 140 };
 141
 142 template<class Config>
 143 struct TypeImpl<Config>::BitsetType {
 144   static void New() {
 145     Config::from_bitset();
 146   }
 147 };
 148
 149 static void f() {
 150   TypeImpl<HeapTypeConfig>::Any();
 151 }
 152
 153 template<typename A> struct S {
 154   template<typename B> struct T;
 155 };
 156 template<typename A> template<typename B> struct S<A>::T {
 157   template<typename C, typename D> struct U;
 158   template<typename C> struct U<C, C> {
 159     template<typename E> static int f() {
 160       return sizeof(A) + sizeof(B) + sizeof(C) + sizeof(E);
 161     }
 162   };
 163 };
 164
 165 static void g() {
 166   S<int>::T<int>::U<int,int>::f<int>();
 167 }
 168
 169 template<typename T> struct SS {
 170   template<typename U> struct X;
 171   template<typename U> struct X<U*>;
 172 };
 173 template<typename T> template<typename U> struct SS<T>::X<U*> {
 174   static int f() {
 175     return sizeof(T) + sizeof(U);
 176   }
 177 };
 178
 179 static void h() {
 180   SS<int>::X<int*>::f();
 181 }
 182
 183 }