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