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