Home | History | Annotate | Download | only in SemaCXX 
      1 // RUN: %clang_cc1 -fsyntax-only -verify %s
      2 
      3 // Note: the formatting in this test case is intentionally funny, with
      4 // nested-name-specifiers stretched out vertically so that we can
      5 // match up diagnostics per-line and still verify that we're getting
      6 // good source-location information.
      7 
      8 namespace outer {
      9   namespace inner {
     10     template<typename T>
     11     struct X0 {
     12     };
     13   }
     14 }
     15 
     16 template<typename T>
     17 struct add_reference {
     18   typedef T& type;
     19 };
     20 
     21 namespace outer_alias = outer;
     22 
     23 template<typename T>
     24 struct UnresolvedUsingValueDeclTester {
     25   using outer::inner::X0<
     26           typename add_reference<T>::type
     27     * // expected-error{{declared as a pointer to a reference of type}}
     28         >::value;
     29 };
     30 
     31 UnresolvedUsingValueDeclTester<int> UnresolvedUsingValueDeclCheck; // expected-note{{in instantiation of template class}}
     32 
     33 template<typename T>
     34 struct UnresolvedUsingTypenameDeclTester {
     35   using outer::inner::X0<
     36           typename add_reference<T>::type
     37     * // expected-error{{declared as a pointer to a reference of type}}
     38         >::value;
     39 };
     40 
     41 UnresolvedUsingTypenameDeclTester<int> UnresolvedUsingTypenameDeclCheck; // expected-note{{in instantiation of template class}}
     42 
     43 
     44 template<typename T, typename U>
     45 struct PseudoDestructorExprTester {
     46   void f(T *t) {
     47     t->T::template Inner<typename add_reference<U>::type
     48       * // expected-error{{as a pointer to a reference of type}}
     49       >::Blarg::~Blarg();
     50   }
     51 };
     52 
     53 struct HasInnerTemplate {
     54   template<typename T>
     55   struct Inner;
     56 
     57   typedef HasInnerTemplate T;
     58 };
     59 
     60 void PseudoDestructorExprCheck(
     61                     PseudoDestructorExprTester<HasInnerTemplate, float> tester) {
     62   tester.f(0); // expected-note{{in instantiation of member function}}
     63 }
     64 
     65 template<typename T>
     66 struct DependentScopedDeclRefExpr {
     67   void f() {
     68     outer_alias::inner::X0<typename add_reference<T>::type
     69       * // expected-error{{as a pointer to a reference of type}}
     70       >::value = 17;
     71   }
     72 };
     73 
     74 void DependentScopedDeclRefExprCheck(DependentScopedDeclRefExpr<int> t) {
     75   t.f(); // expected-note{{in instantiation of member function}}
     76 }
     77 
     78 
     79 template<typename T>
     80 struct TypenameTypeTester {
     81   typedef typename outer::inner::X0<
     82           typename add_reference<T>::type
     83     * // expected-error{{declared as a pointer to a reference of type}}
     84         >::type type;
     85 };
     86 
     87 TypenameTypeTester<int> TypenameTypeCheck; // expected-note{{in instantiation of template class}}
     88 
     89 template<typename T, typename U>
     90 struct DependentTemplateSpecializationTypeTester {
     91   typedef typename T::template apply<typename add_reference<U>::type
     92                                      * // expected-error{{declared as a pointer to a reference of type}}
     93                                      >::type type;
     94 };
     95 
     96 struct HasApply {
     97   template<typename T>
     98   struct apply {
     99     typedef T type;
    100   };
    101 };
    102 
    103 DependentTemplateSpecializationTypeTester<HasApply, int> DTSTCheck; // expected-note{{in instantiation of template class}}
    104 
    105 template<typename T, typename U>
    106 struct DependentTemplateSpecializationTypeTester2 {
    107   typedef typename T::template apply<typename add_reference<U>::type
    108                                      * // expected-error{{declared as a pointer to a reference of type}}
    109                                      > type;
    110 };
    111 
    112 DependentTemplateSpecializationTypeTester2<HasApply, int> DTSTCheck2; // expected-note{{in instantiation of template class}}
    113 
    114 template<typename T, typename U>
    115 struct DependentTemplateSpecializationTypeTester3 :
    116   T::template apply<typename add_reference<U>::type
    117                                      * // expected-error{{declared as a pointer to a reference of type}}
    118                                      >
    119 {};
    120 
    121 DependentTemplateSpecializationTypeTester3<HasApply, int> DTSTCheck3; // expected-note{{in instantiation of template class}}
    122 
    123 template<typename T, typename U>
    124 struct DependentTemplateSpecializationTypeTester4 {
    125   typedef class T::template apply<typename add_reference<U>::type
    126                                      * // expected-error{{declared as a pointer to a reference of type}}
    127                                      > type;
    128 };
    129 
    130 DependentTemplateSpecializationTypeTester4<HasApply, int> DTSTCheck4; // expected-note{{in instantiation of template class}}
    131 
    132 template<template<class T> class TTP>
    133 struct AcceptedTemplateTemplateParameter {
    134 };
    135 
    136 template<typename T, typename U>
    137 struct DependentTemplateTemplateArgumentTester {
    138   typedef AcceptedTemplateTemplateParameter<
    139             T::
    140             template apply<
    141               typename add_reference<U>::type
    142               * // expected-error{{declared as a pointer to a reference of type}}
    143             >::
    144             template X>
    145     type;
    146 };
    147 
    148 DependentTemplateTemplateArgumentTester<HasApply, int> DTTACheck; // expected-note{{in instantiation of template class}}
    149 
    150 namespace PR9388 {
    151   namespace std {
    152     template<typename T>     class vector     {
    153     };
    154   }
    155   template<typename T> static void foo(std::vector<T*> &V) {
    156     __PRETTY_FUNCTION__; // expected-warning{{expression result unused}}
    157   }
    158   void bar(std::vector<int*> &Blocks) {
    159     foo(Blocks); // expected-note{{in instantiation of}}
    160   }
    161 
    162 }
    163