clang/test/SemaCXX/nested-name-spec-locations.cpp

   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 }