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 {
fPseudoDestructorExprTester46 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
PseudoDestructorExprCheck(PseudoDestructorExprTester<HasInnerTemplate,float> tester)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 {
fDependentScopedDeclRefExpr67 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
DependentScopedDeclRefExprCheck(DependentScopedDeclRefExpr<int> t)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 }
foo(std::vector<T * > & V)155 template<typename T> static void foo(std::vector<T*> &V) {
156 __PRETTY_FUNCTION__; // expected-warning{{expression result unused}}
157 }
bar(std::vector<int * > & Blocks)158 void bar(std::vector<int*> &Blocks) {
159 foo(Blocks); // expected-note{{in instantiation of}}
160 }
161
162 }
163