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