Home | History | Annotate | Download | only in Parser 
      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}}  expected-note {{previous definition is here}}
     14    void foo4() { } // expected-error {{class member cannot be redeclared}} expected-error {{redefinition of 'foo4'}}
     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 }
    184