1 //===- unittest/AST/SourceLocationTest.cpp - AST source loc unit tests ----===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains tests for SourceLocation and SourceRange fields
10 // in AST nodes.
11 //
12 // FIXME: In the long-term, when we test more than source locations, we may
13 // want to have a unit test file for an AST node (or group of related nodes),
14 // rather than a unit test file for source locations for all AST nodes.
15 //
16 //===----------------------------------------------------------------------===//
17 
18 #include "MatchVerifier.h"
19 #include "clang/AST/ASTContext.h"
20 #include "clang/ASTMatchers/ASTMatchFinder.h"
21 #include "clang/ASTMatchers/ASTMatchers.h"
22 #include "clang/Tooling/Tooling.h"
23 #include "llvm/Testing/Support/Annotations.h"
24 #include "gtest/gtest.h"
25 
26 using namespace clang;
27 using namespace clang::ast_matchers;
28 
29 namespace {
30 
31 // FIXME: Pull the *Verifier tests into their own test file.
32 
33 TEST(MatchVerifier, ParseError) {
34   LocationVerifier<VarDecl> Verifier;
35   Verifier.expectLocation(1, 1);
36   EXPECT_FALSE(Verifier.match("int i", varDecl()));
37 }
38 
39 TEST(MatchVerifier, NoMatch) {
40   LocationVerifier<VarDecl> Verifier;
41   Verifier.expectLocation(1, 1);
42   EXPECT_FALSE(Verifier.match("int i;", recordDecl()));
43 }
44 
45 TEST(MatchVerifier, WrongType) {
46   LocationVerifier<RecordDecl> Verifier;
47   Verifier.expectLocation(1, 1);
48   EXPECT_FALSE(Verifier.match("int i;", varDecl()));
49 }
50 
51 TEST(LocationVerifier, WrongLocation) {
52   LocationVerifier<VarDecl> Verifier;
53   Verifier.expectLocation(1, 1);
54   EXPECT_FALSE(Verifier.match("int i;", varDecl()));
55 }
56 
57 TEST(RangeVerifier, WrongRange) {
58   RangeVerifier<VarDecl> Verifier;
59   Verifier.expectRange(1, 1, 1, 1);
60   EXPECT_FALSE(Verifier.match("int i;", varDecl()));
61 }
62 
63 class LabelDeclRangeVerifier : public RangeVerifier<LabelStmt> {
64 protected:
65   SourceRange getRange(const LabelStmt &Node) override {
66     return Node.getDecl()->getSourceRange();
67   }
68 };
69 
70 TEST(LabelDecl, Range) {
71   LabelDeclRangeVerifier Verifier;
72   Verifier.expectRange(1, 12, 1, 12);
73   EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
74 }
75 
76 TEST(LabelStmt, Range) {
77   RangeVerifier<LabelStmt> Verifier;
78   Verifier.expectRange(1, 12, 1, 15);
79   EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
80 }
81 
82 TEST(ParmVarDecl, KNRLocation) {
83   LocationVerifier<ParmVarDecl> Verifier;
84   Verifier.expectLocation(1, 8);
85   EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C));
86 }
87 
88 TEST(ParmVarDecl, KNRRange) {
89   RangeVerifier<ParmVarDecl> Verifier;
90   Verifier.expectRange(1, 8, 1, 8);
91   EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C));
92 }
93 
94 TEST(CXXNewExpr, ArrayRange) {
95   RangeVerifier<CXXNewExpr> Verifier;
96   Verifier.expectRange(1, 12, 1, 22);
97   EXPECT_TRUE(Verifier.match("void f() { new int[10]; }", cxxNewExpr()));
98 }
99 
100 TEST(CXXNewExpr, ParenRange) {
101   RangeVerifier<CXXNewExpr> Verifier;
102   Verifier.expectRange(1, 12, 1, 20);
103   EXPECT_TRUE(Verifier.match("void f() { new int(); }", cxxNewExpr()));
104 }
105 
106 TEST(MemberExpr, ImplicitMemberRange) {
107   RangeVerifier<MemberExpr> Verifier;
108   Verifier.expectRange(2, 30, 2, 30);
109   EXPECT_TRUE(Verifier.match("struct S { operator int() const; };\n"
110                              "int foo(const S& s) { return s; }",
111                              memberExpr()));
112 }
113 
114 class MemberExprArrowLocVerifier : public RangeVerifier<MemberExpr> {
115 protected:
116   SourceRange getRange(const MemberExpr &Node) override {
117      return Node.getOperatorLoc();
118   }
119 };
120 
121 TEST(MemberExpr, ArrowRange) {
122   MemberExprArrowLocVerifier Verifier;
123   Verifier.expectRange(2, 19, 2, 19);
124   EXPECT_TRUE(Verifier.match("struct S { int x; };\n"
125                              "void foo(S *s) { s->x = 0; }",
126                              memberExpr()));
127 }
128 
129 TEST(MemberExpr, MacroArrowRange) {
130   MemberExprArrowLocVerifier Verifier;
131   Verifier.expectRange(1, 24, 1, 24);
132   EXPECT_TRUE(Verifier.match("#define MEMBER(a, b) (a->b)\n"
133                              "struct S { int x; };\n"
134                              "void foo(S *s) { MEMBER(s, x) = 0; }",
135                              memberExpr()));
136 }
137 
138 TEST(MemberExpr, ImplicitArrowRange) {
139   MemberExprArrowLocVerifier Verifier;
140   Verifier.expectRange(0, 0, 0, 0);
141   EXPECT_TRUE(Verifier.match("struct S { int x; void Test(); };\n"
142                              "void S::Test() { x = 1; }",
143                              memberExpr()));
144 }
145 
146 TEST(VarDecl, VMTypeFixedVarDeclRange) {
147   RangeVerifier<VarDecl> Verifier;
148   Verifier.expectRange(1, 1, 1, 23);
149   EXPECT_TRUE(Verifier.match("int a[(int)(void*)1234];",
150                              varDecl(), Lang_C89));
151 }
152 
153 TEST(TypeLoc, IntRange) {
154   RangeVerifier<TypeLoc> Verifier;
155   Verifier.expectRange(1, 1, 1, 1);
156   EXPECT_TRUE(Verifier.match("int a;", typeLoc()));
157 }
158 
159 TEST(TypeLoc, LongRange) {
160   RangeVerifier<TypeLoc> Verifier;
161   Verifier.expectRange(1, 1, 1, 1);
162   EXPECT_TRUE(Verifier.match("long a;", typeLoc()));
163 }
164 
165 TEST(TypeLoc, LongDoubleRange) {
166   RangeVerifier<TypeLoc> Verifier;
167   Verifier.expectRange(1, 1, 1, 6);
168   EXPECT_TRUE(Verifier.match("long double a;", typeLoc()));
169 }
170 
171 TEST(TypeLoc, DoubleLongRange) {
172   RangeVerifier<TypeLoc> Verifier;
173   Verifier.expectRange(1, 1, 1, 8);
174   EXPECT_TRUE(Verifier.match("double long a;", typeLoc()));
175 }
176 
177 TEST(TypeLoc, LongIntRange) {
178   RangeVerifier<TypeLoc> Verifier;
179   Verifier.expectRange(1, 1, 1, 6);
180   EXPECT_TRUE(Verifier.match("long int a;", typeLoc()));
181 }
182 
183 TEST(TypeLoc, IntLongRange) {
184   RangeVerifier<TypeLoc> Verifier;
185   Verifier.expectRange(1, 1, 1, 5);
186   EXPECT_TRUE(Verifier.match("int long a;", typeLoc()));
187 }
188 
189 TEST(TypeLoc, UnsignedIntRange) {
190   RangeVerifier<TypeLoc> Verifier;
191   Verifier.expectRange(1, 1, 1, 10);
192   EXPECT_TRUE(Verifier.match("unsigned int a;", typeLoc()));
193 }
194 
195 TEST(TypeLoc, IntUnsignedRange) {
196   RangeVerifier<TypeLoc> Verifier;
197   Verifier.expectRange(1, 1, 1, 5);
198   EXPECT_TRUE(Verifier.match("int unsigned a;", typeLoc()));
199 }
200 
201 TEST(TypeLoc, LongLongRange) {
202   RangeVerifier<TypeLoc> Verifier;
203   Verifier.expectRange(1, 1, 1, 6);
204   EXPECT_TRUE(Verifier.match("long long a;", typeLoc()));
205 }
206 
207 TEST(TypeLoc, UnsignedLongLongRange) {
208   RangeVerifier<TypeLoc> Verifier;
209   Verifier.expectRange(1, 1, 1, 15);
210   EXPECT_TRUE(Verifier.match("unsigned long long a;", typeLoc()));
211 }
212 
213 TEST(TypeLoc, LongUnsignedLongRange) {
214   RangeVerifier<TypeLoc> Verifier;
215   Verifier.expectRange(1, 1, 1, 15);
216   EXPECT_TRUE(Verifier.match("long unsigned long a;", typeLoc()));
217 }
218 
219 TEST(TypeLoc, LongLongUnsignedRange) {
220   RangeVerifier<TypeLoc> Verifier;
221   Verifier.expectRange(1, 1, 1, 11);
222   EXPECT_TRUE(Verifier.match("long long unsigned a;", typeLoc()));
223 }
224 
225 TEST(TypeLoc, ConstLongLongRange) {
226   RangeVerifier<TypeLoc> Verifier;
227   Verifier.expectRange(1, 7, 1, 12);
228   EXPECT_TRUE(Verifier.match("const long long a = 0;", typeLoc()));
229 }
230 
231 TEST(TypeLoc, LongConstLongRange) {
232   RangeVerifier<TypeLoc> Verifier;
233   Verifier.expectRange(1, 1, 1, 12);
234   EXPECT_TRUE(Verifier.match("long const long a = 0;", typeLoc()));
235 }
236 
237 TEST(TypeLoc, LongLongConstRange) {
238   RangeVerifier<TypeLoc> Verifier;
239   Verifier.expectRange(1, 1, 1, 6);
240   EXPECT_TRUE(Verifier.match("long long const a = 0;", typeLoc()));
241 }
242 
243 TEST(CXXConstructorDecl, NoRetFunTypeLocRange) {
244   RangeVerifier<CXXConstructorDecl> Verifier;
245   Verifier.expectRange(1, 11, 1, 13);
246   EXPECT_TRUE(Verifier.match("class C { C(); };", functionDecl()));
247 }
248 
249 TEST(CXXConstructorDecl, DefaultedCtorLocRange) {
250   RangeVerifier<CXXConstructorDecl> Verifier;
251   Verifier.expectRange(1, 11, 1, 23);
252   EXPECT_TRUE(Verifier.match("class C { C() = default; };", functionDecl()));
253 }
254 
255 TEST(CXXConstructorDecl, DeletedCtorLocRange) {
256   RangeVerifier<CXXConstructorDecl> Verifier;
257   Verifier.expectRange(1, 11, 1, 22);
258   EXPECT_TRUE(Verifier.match("class C { C() = delete; };", functionDecl()));
259 }
260 
261 TEST(CompoundLiteralExpr, CompoundVectorLiteralRange) {
262   RangeVerifier<CompoundLiteralExpr> Verifier;
263   Verifier.expectRange(2, 11, 2, 22);
264   EXPECT_TRUE(Verifier.match(
265                   "typedef int int2 __attribute__((ext_vector_type(2)));\n"
266                   "int2 i2 = (int2){1, 2};", compoundLiteralExpr()));
267 }
268 
269 TEST(CompoundLiteralExpr, ParensCompoundVectorLiteralRange) {
270   RangeVerifier<CompoundLiteralExpr> Verifier;
271   Verifier.expectRange(2, 20, 2, 31);
272   EXPECT_TRUE(Verifier.match(
273                   "typedef int int2 __attribute__((ext_vector_type(2)));\n"
274                   "constant int2 i2 = (int2)(1, 2);",
275                   compoundLiteralExpr(), Lang_OpenCL));
276 }
277 
278 TEST(InitListExpr, VectorLiteralListBraceRange) {
279   RangeVerifier<InitListExpr> Verifier;
280   Verifier.expectRange(2, 17, 2, 22);
281   EXPECT_TRUE(Verifier.match(
282                   "typedef int int2 __attribute__((ext_vector_type(2)));\n"
283                   "int2 i2 = (int2){1, 2};", initListExpr()));
284 }
285 
286 TEST(InitListExpr, VectorLiteralInitListParens) {
287   RangeVerifier<InitListExpr> Verifier;
288   Verifier.expectRange(2, 26, 2, 31);
289   EXPECT_TRUE(Verifier.match(
290                   "typedef int int2 __attribute__((ext_vector_type(2)));\n"
291                   "constant int2 i2 = (int2)(1, 2);", initListExpr(), Lang_OpenCL));
292 }
293 
294 class TemplateAngleBracketLocRangeVerifier : public RangeVerifier<TypeLoc> {
295 protected:
296   SourceRange getRange(const TypeLoc &Node) override {
297     TemplateSpecializationTypeLoc T =
298         Node.getUnqualifiedLoc().castAs<TemplateSpecializationTypeLoc>();
299     assert(!T.isNull());
300     return SourceRange(T.getLAngleLoc(), T.getRAngleLoc());
301   }
302 };
303 
304 TEST(TemplateSpecializationTypeLoc, AngleBracketLocations) {
305   TemplateAngleBracketLocRangeVerifier Verifier;
306   Verifier.expectRange(2, 8, 2, 10);
307   EXPECT_TRUE(Verifier.match(
308       "template<typename T> struct A {}; struct B{}; void f(\n"
309       "const A<B>&);",
310       loc(templateSpecializationType())));
311 }
312 
313 TEST(CXXNewExpr, TypeParenRange) {
314   RangeVerifier<CXXNewExpr> Verifier;
315   Verifier.expectRange(1, 10, 1, 18);
316   EXPECT_TRUE(Verifier.match("int* a = new (int);", cxxNewExpr()));
317 }
318 
319 class UnaryTransformTypeLocParensRangeVerifier : public RangeVerifier<TypeLoc> {
320 protected:
321   SourceRange getRange(const TypeLoc &Node) override {
322     UnaryTransformTypeLoc T =
323         Node.getUnqualifiedLoc().castAs<UnaryTransformTypeLoc>();
324     assert(!T.isNull());
325     return SourceRange(T.getLParenLoc(), T.getRParenLoc());
326   }
327 };
328 
329 TEST(UnaryTransformTypeLoc, ParensRange) {
330   UnaryTransformTypeLocParensRangeVerifier Verifier;
331   Verifier.expectRange(3, 26, 3, 28);
332   EXPECT_TRUE(Verifier.match(
333       "template <typename T>\n"
334       "struct S {\n"
335       "typedef __underlying_type(T) type;\n"
336       "};",
337       loc(unaryTransformType())));
338 }
339 
340 TEST(CXXFunctionalCastExpr, SourceRange) {
341   RangeVerifier<CXXFunctionalCastExpr> Verifier;
342   Verifier.expectRange(2, 10, 2, 14);
343   EXPECT_TRUE(Verifier.match(
344       "int foo() {\n"
345       "  return int{};\n"
346       "}",
347       cxxFunctionalCastExpr(), Lang_CXX11));
348 }
349 
350 TEST(CXXConstructExpr, SourceRange) {
351   RangeVerifier<CXXConstructExpr> Verifier;
352   Verifier.expectRange(3, 14, 3, 19);
353   EXPECT_TRUE(Verifier.match(
354       "struct A { A(int, int); };\n"
355       "void f(A a);\n"
356       "void g() { f({0, 0}); }",
357       cxxConstructExpr(), Lang_CXX11));
358 }
359 
360 TEST(CXXTemporaryObjectExpr, SourceRange) {
361   RangeVerifier<CXXTemporaryObjectExpr> Verifier;
362   Verifier.expectRange(2, 6, 2, 12);
363   EXPECT_TRUE(Verifier.match(
364       "struct A { A(int, int); };\n"
365       "A a( A{0, 0} );",
366       cxxTemporaryObjectExpr(), Lang_CXX11));
367 }
368 
369 TEST(CXXUnresolvedConstructExpr, SourceRange) {
370   RangeVerifier<CXXUnresolvedConstructExpr> Verifier;
371   Verifier.expectRange(3, 10, 3, 12);
372   std::vector<std::string> Args;
373   Args.push_back("-fno-delayed-template-parsing");
374   EXPECT_TRUE(Verifier.match(
375       "template <typename U>\n"
376       "U foo() {\n"
377       "  return U{};\n"
378       "}",
379       cxxUnresolvedConstructExpr(), Args, Lang_CXX11));
380 }
381 
382 TEST(UsingDecl, SourceRange) {
383   RangeVerifier<UsingDecl> Verifier;
384   Verifier.expectRange(2, 22, 2, 25);
385   EXPECT_TRUE(Verifier.match(
386       "class B { protected: int i; };\n"
387       "class D : public B { B::i; };",
388       usingDecl()));
389 }
390 
391 TEST(UnresolvedUsingValueDecl, SourceRange) {
392   RangeVerifier<UnresolvedUsingValueDecl> Verifier;
393   Verifier.expectRange(3, 3, 3, 6);
394   EXPECT_TRUE(Verifier.match(
395       "template <typename B>\n"
396       "class D : public B {\n"
397       "  B::i;\n"
398       "};",
399       unresolvedUsingValueDecl()));
400 }
401 
402 TEST(FriendDecl, FriendNonMemberFunctionLocation) {
403   LocationVerifier<FriendDecl> Verifier;
404   Verifier.expectLocation(2, 13);
405   EXPECT_TRUE(Verifier.match("struct A {\n"
406                              "friend void f();\n"
407                              "};\n",
408                              friendDecl()));
409 }
410 
411 TEST(FriendDecl, FriendNonMemberFunctionRange) {
412   RangeVerifier<FriendDecl> Verifier;
413   Verifier.expectRange(2, 1, 2, 15);
414   EXPECT_TRUE(Verifier.match("struct A {\n"
415                              "friend void f();\n"
416                              "};\n",
417                              friendDecl()));
418 }
419 
420 TEST(FriendDecl, FriendNonMemberFunctionDefinitionLocation) {
421   LocationVerifier<FriendDecl> Verifier;
422   Verifier.expectLocation(2, 12);
423   EXPECT_TRUE(Verifier.match("struct A {\n"
424                              "friend int f() { return 0; }\n"
425                              "};\n",
426                              friendDecl()));
427 }
428 
429 TEST(FriendDecl, FriendNonMemberFunctionDefinitionRange) {
430   RangeVerifier<FriendDecl> Verifier;
431   Verifier.expectRange(2, 1, 2, 28);
432   EXPECT_TRUE(Verifier.match("struct A {\n"
433                              "friend int f() { return 0; }\n"
434                              "};\n",
435                              friendDecl()));
436 }
437 
438 TEST(FriendDecl, FriendElaboratedTypeLocation) {
439   LocationVerifier<FriendDecl> Verifier;
440   Verifier.expectLocation(2, 8);
441   EXPECT_TRUE(Verifier.match("struct A {\n"
442                              "friend class B;\n"
443                              "};\n",
444                              friendDecl()));
445 }
446 
447 TEST(FriendDecl, FriendElaboratedTypeRange) {
448   RangeVerifier<FriendDecl> Verifier;
449   Verifier.expectRange(2, 1, 2, 14);
450   EXPECT_TRUE(Verifier.match("struct A {\n"
451                              "friend class B;\n"
452                              "};\n",
453                              friendDecl()));
454 }
455 
456 TEST(FriendDecl, FriendSimpleTypeLocation) {
457   LocationVerifier<FriendDecl> Verifier;
458   Verifier.expectLocation(3, 8);
459   EXPECT_TRUE(Verifier.match("class B;\n"
460                              "struct A {\n"
461                              "friend B;\n"
462                              "};\n",
463                              friendDecl(), Lang_CXX11));
464 }
465 
466 TEST(FriendDecl, FriendSimpleTypeRange) {
467   RangeVerifier<FriendDecl> Verifier;
468   Verifier.expectRange(3, 1, 3, 8);
469   EXPECT_TRUE(Verifier.match("class B;\n"
470                              "struct A {\n"
471                              "friend B;\n"
472                              "};\n",
473                              friendDecl(), Lang_CXX11));
474 }
475 
476 TEST(FriendDecl, FriendTemplateParameterLocation) {
477   LocationVerifier<FriendDecl> Verifier;
478   Verifier.expectLocation(3, 8);
479   EXPECT_TRUE(Verifier.match("template <typename T>\n"
480                              "struct A {\n"
481                              "friend T;\n"
482                              "};\n",
483                              friendDecl(), Lang_CXX11));
484 }
485 
486 TEST(FriendDecl, FriendTemplateParameterRange) {
487   RangeVerifier<FriendDecl> Verifier;
488   Verifier.expectRange(3, 1, 3, 8);
489   EXPECT_TRUE(Verifier.match("template <typename T>\n"
490                              "struct A {\n"
491                              "friend T;\n"
492                              "};\n",
493                              friendDecl(), Lang_CXX11));
494 }
495 
496 TEST(FriendDecl, FriendDecltypeLocation) {
497   LocationVerifier<FriendDecl> Verifier;
498   Verifier.expectLocation(4, 8);
499   EXPECT_TRUE(Verifier.match("struct A;\n"
500                              "A foo();\n"
501                              "struct A {\n"
502                              "friend decltype(foo());\n"
503                              "};\n",
504                              friendDecl(), Lang_CXX11));
505 }
506 
507 TEST(FriendDecl, FriendDecltypeRange) {
508   RangeVerifier<FriendDecl> Verifier;
509   Verifier.expectRange(4, 1, 4, 8);
510   EXPECT_TRUE(Verifier.match("struct A;\n"
511                              "A foo();\n"
512                              "struct A {\n"
513                              "friend decltype(foo());\n"
514                              "};\n",
515                              friendDecl(), Lang_CXX11));
516 }
517 
518 TEST(FriendDecl, FriendConstructorDestructorLocation) {
519   const std::string Code = "struct B {\n"
520                            "B();\n"
521                            "~B();\n"
522                            "};\n"
523                            "struct A {\n"
524                            "friend B::B(), B::~B();\n"
525                            "};\n";
526   LocationVerifier<FriendDecl> ConstructorVerifier;
527   ConstructorVerifier.expectLocation(6, 11);
528   EXPECT_TRUE(ConstructorVerifier.match(
529       Code, friendDecl(has(cxxConstructorDecl(ofClass(hasName("B")))))));
530   LocationVerifier<FriendDecl> DestructorVerifier;
531   DestructorVerifier.expectLocation(6, 19);
532   EXPECT_TRUE(DestructorVerifier.match(
533       Code, friendDecl(has(cxxDestructorDecl(ofClass(hasName("B")))))));
534 }
535 
536 TEST(FriendDecl, FriendConstructorDestructorRange) {
537   const std::string Code = "struct B {\n"
538                            "B();\n"
539                            "~B();\n"
540                            "};\n"
541                            "struct A {\n"
542                            "friend B::B(), B::~B();\n"
543                            "};\n";
544   RangeVerifier<FriendDecl> ConstructorVerifier;
545   ConstructorVerifier.expectRange(6, 1, 6, 13);
546   EXPECT_TRUE(ConstructorVerifier.match(
547       Code, friendDecl(has(cxxConstructorDecl(ofClass(hasName("B")))))));
548   RangeVerifier<FriendDecl> DestructorVerifier;
549   DestructorVerifier.expectRange(6, 1, 6, 22);
550   EXPECT_TRUE(DestructorVerifier.match(
551       Code, friendDecl(has(cxxDestructorDecl(ofClass(hasName("B")))))));
552 }
553 
554 TEST(FriendDecl, FriendTemplateFunctionLocation) {
555   LocationVerifier<FriendDecl> Verifier;
556   Verifier.expectLocation(3, 13);
557   EXPECT_TRUE(Verifier.match("struct A {\n"
558                              "template <typename T>\n"
559                              "friend void f();\n"
560                              "};\n",
561                              friendDecl()));
562 }
563 
564 TEST(FriendDecl, FriendTemplateFunctionRange) {
565   RangeVerifier<FriendDecl> Verifier;
566   Verifier.expectRange(2, 1, 3, 15);
567   EXPECT_TRUE(Verifier.match("struct A {\n"
568                              "template <typename T>\n"
569                              "friend void f();\n"
570                              "};\n",
571                              friendDecl()));
572 }
573 
574 TEST(FriendDecl, FriendTemplateClassLocation) {
575   LocationVerifier<FriendDecl> Verifier;
576   Verifier.expectLocation(3, 14);
577   EXPECT_TRUE(Verifier.match("struct A {\n"
578                              "template <typename T>\n"
579                              "friend class B;\n"
580                              "};\n",
581                              friendDecl()));
582 }
583 
584 TEST(FriendDecl, FriendTemplateClassRange) {
585   RangeVerifier<FriendDecl> Verifier;
586   Verifier.expectRange(2, 1, 3, 14);
587   EXPECT_TRUE(Verifier.match("struct A {\n"
588                              "template <typename T>\n"
589                              "friend class B;\n"
590                              "};\n",
591                              friendDecl()));
592 }
593 
594 TEST(FriendDecl, FriendInlineFunctionLocation) {
595   LocationVerifier<FriendDecl> Verifier;
596   Verifier.expectLocation(2, 19);
597   EXPECT_TRUE(Verifier.match("struct A {\n"
598                              "int inline friend f() { return 0; }"
599                              "};\n",
600                              friendDecl()));
601 }
602 
603 TEST(FriendDecl, FriendInlineFunctionRange) {
604   RangeVerifier<FriendDecl> Verifier;
605   Verifier.expectRange(2, 1, 2, 35);
606   EXPECT_TRUE(Verifier.match("struct A {\n"
607                              "int inline friend f() { return 0; }"
608                              "};\n",
609                              friendDecl(), Lang_CXX11));
610 }
611 
612 TEST(FriendDecl, InstantiationSourceRange) {
613   RangeVerifier<FriendDecl> Verifier;
614   Verifier.expectRange(4, 3, 4, 35);
615   EXPECT_TRUE(Verifier.match(
616       "template <typename T> class S;\n"
617       "template<class T> void operator+(S<T> x);\n"
618       "template<class T> struct S {\n"
619       "  friend void operator+<>(S<T> src);\n"
620       "};\n"
621       "void test(S<double> s) { +s; }",
622       friendDecl(hasParent(cxxRecordDecl(isTemplateInstantiation())))));
623 }
624 
625 TEST(ObjCMessageExpr, CXXConstructExprRange) {
626   RangeVerifier<CXXConstructExpr> Verifier;
627   Verifier.expectRange(5, 25, 5, 27);
628   EXPECT_TRUE(Verifier.match(
629       "struct A { int a; };\n"
630       "@interface B {}\n"
631       "+ (void) f1: (A)arg;\n"
632       "@end\n"
633       "void f2() { A a; [B f1: (a)]; }\n",
634       cxxConstructExpr(), Lang_OBJCXX));
635 }
636 
637 TEST(FunctionDecl, FunctionDeclWithThrowSpecification) {
638   RangeVerifier<FunctionDecl> Verifier;
639   Verifier.expectRange(1, 1, 1, 16);
640   EXPECT_TRUE(Verifier.match(
641       "void f() throw();\n",
642       functionDecl()));
643 }
644 
645 TEST(FunctionDecl, FunctionDeclWithNoExceptSpecification) {
646   RangeVerifier<FunctionDecl> Verifier;
647   Verifier.expectRange(1, 1, 1, 24);
648   EXPECT_TRUE(Verifier.match("void f() noexcept(false);\n", functionDecl(),
649                              Lang_CXX11));
650 }
651 
652 class FunctionDeclParametersRangeVerifier : public RangeVerifier<FunctionDecl> {
653 protected:
654   SourceRange getRange(const FunctionDecl &Function) override {
655     return Function.getParametersSourceRange();
656   }
657 };
658 
659 TEST(FunctionDeclParameters, FunctionDeclOnlyVariadic) {
660   FunctionDeclParametersRangeVerifier Verifier;
661   Verifier.expectRange(1, 8, 1, 8);
662   EXPECT_TRUE(Verifier.match("void f(...);\n", functionDecl()));
663 }
664 
665 TEST(FunctionDeclParameters, FunctionDeclVariadic) {
666   FunctionDeclParametersRangeVerifier Verifier;
667   Verifier.expectRange(1, 8, 1, 15);
668   EXPECT_TRUE(Verifier.match("void f(int a, ...);\n", functionDecl()));
669 }
670 
671 TEST(FunctionDeclParameters, FunctionDeclMacroVariadic) {
672   FunctionDeclParametersRangeVerifier Verifier;
673   Verifier.expectRange(2, 8, 1, 18);
674   EXPECT_TRUE(Verifier.match("#define VARIADIC ...\n"
675                              "void f(int a, VARIADIC);\n",
676                              functionDecl()));
677 }
678 
679 TEST(FunctionDeclParameters, FunctionDeclMacroParams) {
680   FunctionDeclParametersRangeVerifier Verifier;
681   Verifier.expectRange(1, 16, 2, 20);
682   EXPECT_TRUE(Verifier.match("#define PARAMS int a, int b\n"
683                              "void f(PARAMS, int c);",
684                              functionDecl()));
685 }
686 
687 TEST(FunctionDeclParameters, FunctionDeclSingleParameter) {
688   FunctionDeclParametersRangeVerifier Verifier;
689   Verifier.expectRange(1, 8, 1, 12);
690   EXPECT_TRUE(Verifier.match("void f(int a);\n", functionDecl()));
691 }
692 
693 TEST(FunctionDeclParameters, MemberFunctionDecl) {
694   FunctionDeclParametersRangeVerifier Verifier;
695   Verifier.expectRange(2, 8, 2, 12);
696   EXPECT_TRUE(Verifier.match("class A{\n"
697                              "void f(int a);\n"
698                              "};",
699                              functionDecl()));
700 }
701 
702 TEST(FunctionDeclParameters, MemberFunctionDeclVariadic) {
703   FunctionDeclParametersRangeVerifier Verifier;
704   Verifier.expectRange(2, 8, 2, 15);
705   EXPECT_TRUE(Verifier.match("class A{\n"
706                              "void f(int a, ...);\n"
707                              "};",
708                              functionDecl()));
709 }
710 
711 TEST(FunctionDeclParameters, StaticFunctionDecl) {
712   FunctionDeclParametersRangeVerifier Verifier;
713   Verifier.expectRange(2, 15, 2, 19);
714   EXPECT_TRUE(Verifier.match("class A{\n"
715                              "static void f(int a);\n"
716                              "};",
717                              functionDecl()));
718 }
719 
720 TEST(FunctionDeclParameters, FunctionDeclMultipleParameters) {
721   FunctionDeclParametersRangeVerifier Verifier;
722   Verifier.expectRange(1, 8, 1, 28);
723   EXPECT_TRUE(
724       Verifier.match("void f(int a, int b, char *c);\n", functionDecl()));
725 }
726 
727 TEST(FunctionDeclParameters, FunctionDeclWithDefaultValue) {
728   FunctionDeclParametersRangeVerifier Verifier;
729   Verifier.expectRange(1, 8, 1, 16);
730   EXPECT_TRUE(Verifier.match("void f(int a = 5);\n", functionDecl()));
731 }
732 
733 TEST(FunctionDeclParameters, FunctionDeclWithVolatile) {
734   FunctionDeclParametersRangeVerifier Verifier;
735   Verifier.expectRange(1, 8, 1, 22);
736   EXPECT_TRUE(Verifier.match("void f(volatile int *i);", functionDecl()));
737 }
738 
739 TEST(FunctionDeclParameters, FunctionDeclWithConstParam) {
740   FunctionDeclParametersRangeVerifier Verifier;
741   Verifier.expectRange(1, 8, 1, 19);
742   EXPECT_TRUE(Verifier.match("void f(const int *i);", functionDecl()));
743 }
744 
745 TEST(FunctionDeclParameters, FunctionDeclWithConstVolatileParam) {
746   FunctionDeclParametersRangeVerifier Verifier;
747   Verifier.expectRange(1, 8, 1, 28);
748   EXPECT_TRUE(Verifier.match("void f(const volatile int *i);", functionDecl()));
749 }
750 
751 TEST(FunctionDeclParameters, FunctionDeclWithParamAttribute) {
752   FunctionDeclParametersRangeVerifier Verifier;
753   Verifier.expectRange(1, 8, 1, 36);
754   EXPECT_TRUE(Verifier.match("void f(__attribute__((unused)) int a) {}",
755                              functionDecl()));
756 }
757 
758 TEST(CXXMethodDecl, CXXMethodDeclWithThrowSpecification) {
759   RangeVerifier<FunctionDecl> Verifier;
760   Verifier.expectRange(2, 1, 2, 16);
761   EXPECT_TRUE(Verifier.match(
762       "class A {\n"
763       "void f() throw();\n"
764       "};\n",
765       functionDecl()));
766 }
767 
768 TEST(CXXMethodDecl, CXXMethodDeclWithNoExceptSpecification) {
769   RangeVerifier<FunctionDecl> Verifier;
770   Verifier.expectRange(2, 1, 2, 24);
771   EXPECT_TRUE(Verifier.match("class A {\n"
772                              "void f() noexcept(false);\n"
773                              "};\n",
774                              functionDecl(), Lang_CXX11));
775 }
776 
777 class ExceptionSpecRangeVerifier : public RangeVerifier<TypeLoc> {
778 protected:
779   SourceRange getRange(const TypeLoc &Node) override {
780     auto T =
781       Node.getUnqualifiedLoc().castAs<FunctionProtoTypeLoc>();
782     assert(!T.isNull());
783     return T.getExceptionSpecRange();
784   }
785 };
786 
787 class ParmVarExceptionSpecRangeVerifier : public RangeVerifier<ParmVarDecl> {
788 protected:
789   SourceRange getRange(const ParmVarDecl &Node) override {
790     if (const TypeSourceInfo *TSI = Node.getTypeSourceInfo()) {
791       TypeLoc TL = TSI->getTypeLoc();
792       if (TL.getType()->isPointerType()) {
793         TL = TL.getNextTypeLoc().IgnoreParens();
794         if (auto FPTL = TL.getAs<FunctionProtoTypeLoc>()) {
795           return FPTL.getExceptionSpecRange();
796         }
797       }
798     }
799     return SourceRange();
800   }
801 };
802 
803 TEST(FunctionDecl, ExceptionSpecifications) {
804   ExceptionSpecRangeVerifier Verifier;
805 
806   Verifier.expectRange(1, 10, 1, 16);
807   EXPECT_TRUE(Verifier.match("void f() throw();\n", loc(functionType())));
808 
809   Verifier.expectRange(1, 10, 1, 34);
810   EXPECT_TRUE(Verifier.match("void f() throw(void(void) throw());\n",
811                              loc(functionType())));
812 
813   Verifier.expectRange(1, 10, 1, 19);
814   std::vector<std::string> Args;
815   Args.push_back("-fms-extensions");
816   EXPECT_TRUE(Verifier.match("void f() throw(...);\n", loc(functionType()),
817                              Args, Lang_CXX));
818 
819   Verifier.expectRange(1, 10, 1, 10);
820   EXPECT_TRUE(
821       Verifier.match("void f() noexcept;\n", loc(functionType()), Lang_CXX11));
822 
823   Verifier.expectRange(1, 10, 1, 24);
824   EXPECT_TRUE(Verifier.match("void f() noexcept(false);\n", loc(functionType()),
825                              Lang_CXX11));
826 
827   Verifier.expectRange(1, 10, 1, 32);
828   EXPECT_TRUE(Verifier.match("void f() noexcept(noexcept(1+1));\n",
829                              loc(functionType()), Lang_CXX11));
830 
831   ParmVarExceptionSpecRangeVerifier Verifier2;
832   Verifier2.expectRange(1, 25, 1, 31);
833   EXPECT_TRUE(Verifier2.match("void g(void (*fp)(void) throw());\n",
834                               parmVarDecl(hasType(pointerType(pointee(
835                                   parenType(innerType(functionType()))))))));
836 
837   Verifier2.expectRange(1, 25, 1, 38);
838   EXPECT_TRUE(Verifier2.match("void g(void (*fp)(void) noexcept(true));\n",
839                               parmVarDecl(hasType(pointerType(pointee(
840                                   parenType(innerType(functionType())))))),
841                               Lang_CXX11));
842 }
843 
844 TEST(Decl, MemberPointerStarLoc) {
845   llvm::Annotations Example(R"cpp(
846     struct X {};
847     int X::$star^* a;
848   )cpp");
849 
850   auto AST = tooling::buildASTFromCode(Example.code());
851   SourceManager &SM = AST->getSourceManager();
852   auto &Ctx = AST->getASTContext();
853 
854   auto *VD = selectFirst<VarDecl>("vd", match(varDecl().bind("vd"), Ctx));
855   ASSERT_TRUE(VD != nullptr);
856 
857   auto TL =
858       VD->getTypeSourceInfo()->getTypeLoc().castAs<MemberPointerTypeLoc>();
859   ASSERT_EQ(SM.getFileOffset(TL.getStarLoc()), Example.point("star"));
860 }
861 
862 } // end namespace
863