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