xref: /llvm-project/clang/unittests/AST/SourceLocationTest.cpp (revision 57c09c8e23ec30c61d31fbb89f97c27413c3e8fe) 
1 //===- unittest/AST/SourceLocationTest.cpp - AST source loc unit tests ----===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains tests for SourceLocation and SourceRange fields
11 // in AST nodes.
12 //
13 // FIXME: In the long-term, when we test more than source locations, we may
14 // want to have a unit test file for an AST node (or group of related nodes),
15 // rather than a unit test file for source locations for all AST nodes.
16 //
17 //===----------------------------------------------------------------------===//
18 
19 #include "clang/AST/ASTContext.h"
20 #include "MatchVerifier.h"
21 #include "clang/ASTMatchers/ASTMatchFinder.h"
22 #include "clang/ASTMatchers/ASTMatchers.h"
23 #include "clang/Tooling/Tooling.h"
24 #include "gtest/gtest.h"
25 
26 namespace clang {
27 namespace ast_matchers {
28 
29 // FIXME: Pull the *Verifier tests into their own test file.
30 
31 TEST(MatchVerifier, ParseError) {
32   LocationVerifier<VarDecl> Verifier;
33   Verifier.expectLocation(1, 1);
34   EXPECT_FALSE(Verifier.match("int i", varDecl()));
35 }
36 
37 TEST(MatchVerifier, NoMatch) {
38   LocationVerifier<VarDecl> Verifier;
39   Verifier.expectLocation(1, 1);
40   EXPECT_FALSE(Verifier.match("int i;", recordDecl()));
41 }
42 
43 TEST(MatchVerifier, WrongType) {
44   LocationVerifier<RecordDecl> Verifier;
45   Verifier.expectLocation(1, 1);
46   EXPECT_FALSE(Verifier.match("int i;", varDecl()));
47 }
48 
49 TEST(LocationVerifier, WrongLocation) {
50   LocationVerifier<VarDecl> Verifier;
51   Verifier.expectLocation(1, 1);
52   EXPECT_FALSE(Verifier.match("int i;", varDecl()));
53 }
54 
55 TEST(RangeVerifier, WrongRange) {
56   RangeVerifier<VarDecl> Verifier;
57   Verifier.expectRange(1, 1, 1, 1);
58   EXPECT_FALSE(Verifier.match("int i;", varDecl()));
59 }
60 
61 class LabelDeclRangeVerifier : public RangeVerifier<LabelStmt> {
62 protected:
63   SourceRange getRange(const LabelStmt &Node) override {
64     return Node.getDecl()->getSourceRange();
65   }
66 };
67 
68 TEST(LabelDecl, Range) {
69   LabelDeclRangeVerifier Verifier;
70   Verifier.expectRange(1, 12, 1, 12);
71   EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
72 }
73 
74 TEST(LabelStmt, Range) {
75   RangeVerifier<LabelStmt> Verifier;
76   Verifier.expectRange(1, 12, 1, 15);
77   EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
78 }
79 
80 TEST(ParmVarDecl, KNRLocation) {
81   LocationVerifier<ParmVarDecl> Verifier;
82   Verifier.expectLocation(1, 8);
83   EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C));
84 }
85 
86 TEST(ParmVarDecl, KNRRange) {
87   RangeVerifier<ParmVarDecl> Verifier;
88   Verifier.expectRange(1, 8, 1, 8);
89   EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C));
90 }
91 
92 TEST(CXXNewExpr, ArrayRange) {
93   RangeVerifier<CXXNewExpr> Verifier;
94   Verifier.expectRange(1, 12, 1, 22);
95   EXPECT_TRUE(Verifier.match("void f() { new int[10]; }", cxxNewExpr()));
96 }
97 
98 TEST(CXXNewExpr, ParenRange) {
99   RangeVerifier<CXXNewExpr> Verifier;
100   Verifier.expectRange(1, 12, 1, 20);
101   EXPECT_TRUE(Verifier.match("void f() { new int(); }", cxxNewExpr()));
102 }
103 
104 TEST(MemberExpr, ImplicitMemberRange) {
105   RangeVerifier<MemberExpr> Verifier;
106   Verifier.expectRange(2, 30, 2, 30);
107   EXPECT_TRUE(Verifier.match("struct S { operator int() const; };\n"
108                              "int foo(const S& s) { return s; }",
109                              memberExpr()));
110 }
111 
112 class MemberExprArrowLocVerifier : public RangeVerifier<MemberExpr> {
113 protected:
114   SourceRange getRange(const MemberExpr &Node) override {
115      return Node.getOperatorLoc();
116   }
117 };
118 
119 TEST(MemberExpr, ArrowRange) {
120   MemberExprArrowLocVerifier Verifier;
121   Verifier.expectRange(2, 19, 2, 19);
122   EXPECT_TRUE(Verifier.match("struct S { int x; };\n"
123                              "void foo(S *s) { s->x = 0; }",
124                              memberExpr()));
125 }
126 
127 TEST(MemberExpr, MacroArrowRange) {
128   MemberExprArrowLocVerifier Verifier;
129   Verifier.expectRange(1, 24, 1, 24);
130   EXPECT_TRUE(Verifier.match("#define MEMBER(a, b) (a->b)\n"
131                              "struct S { int x; };\n"
132                              "void foo(S *s) { MEMBER(s, x) = 0; }",
133                              memberExpr()));
134 }
135 
136 TEST(MemberExpr, ImplicitArrowRange) {
137   MemberExprArrowLocVerifier Verifier;
138   Verifier.expectRange(0, 0, 0, 0);
139   EXPECT_TRUE(Verifier.match("struct S { int x; void Test(); };\n"
140                              "void S::Test() { x = 1; }",
141                              memberExpr()));
142 }
143 
144 TEST(VarDecl, VMTypeFixedVarDeclRange) {
145   RangeVerifier<VarDecl> Verifier;
146   Verifier.expectRange(1, 1, 1, 23);
147   EXPECT_TRUE(Verifier.match("int a[(int)(void*)1234];",
148                              varDecl(), Lang_C89));
149 }
150 
151 TEST(TypeLoc, IntRange) {
152   RangeVerifier<TypeLoc> Verifier;
153   Verifier.expectRange(1, 1, 1, 1);
154   EXPECT_TRUE(Verifier.match("int a;", typeLoc()));
155 }
156 
157 TEST(TypeLoc, LongRange) {
158   RangeVerifier<TypeLoc> Verifier;
159   Verifier.expectRange(1, 1, 1, 1);
160   EXPECT_TRUE(Verifier.match("long a;", typeLoc()));
161 }
162 
163 TEST(TypeLoc, LongDoubleRange) {
164   RangeVerifier<TypeLoc> Verifier;
165   Verifier.expectRange(1, 1, 1, 6);
166   EXPECT_TRUE(Verifier.match("long double a;", typeLoc()));
167 }
168 
169 TEST(TypeLoc, DoubleLongRange) {
170   RangeVerifier<TypeLoc> Verifier;
171   Verifier.expectRange(1, 1, 1, 8);
172   EXPECT_TRUE(Verifier.match("double long a;", typeLoc()));
173 }
174 
175 TEST(TypeLoc, LongIntRange) {
176   RangeVerifier<TypeLoc> Verifier;
177   Verifier.expectRange(1, 1, 1, 6);
178   EXPECT_TRUE(Verifier.match("long int a;", typeLoc()));
179 }
180 
181 TEST(TypeLoc, IntLongRange) {
182   RangeVerifier<TypeLoc> Verifier;
183   Verifier.expectRange(1, 1, 1, 5);
184   EXPECT_TRUE(Verifier.match("int long a;", typeLoc()));
185 }
186 
187 TEST(TypeLoc, UnsignedIntRange) {
188   RangeVerifier<TypeLoc> Verifier;
189   Verifier.expectRange(1, 1, 1, 10);
190   EXPECT_TRUE(Verifier.match("unsigned int a;", typeLoc()));
191 }
192 
193 TEST(TypeLoc, IntUnsignedRange) {
194   RangeVerifier<TypeLoc> Verifier;
195   Verifier.expectRange(1, 1, 1, 5);
196   EXPECT_TRUE(Verifier.match("int unsigned a;", typeLoc()));
197 }
198 
199 TEST(TypeLoc, LongLongRange) {
200   RangeVerifier<TypeLoc> Verifier;
201   Verifier.expectRange(1, 1, 1, 6);
202   EXPECT_TRUE(Verifier.match("long long a;", typeLoc()));
203 }
204 
205 TEST(TypeLoc, UnsignedLongLongRange) {
206   RangeVerifier<TypeLoc> Verifier;
207   Verifier.expectRange(1, 1, 1, 15);
208   EXPECT_TRUE(Verifier.match("unsigned long long a;", typeLoc()));
209 }
210 
211 TEST(TypeLoc, LongUnsignedLongRange) {
212   RangeVerifier<TypeLoc> Verifier;
213   Verifier.expectRange(1, 1, 1, 15);
214   EXPECT_TRUE(Verifier.match("long unsigned long a;", typeLoc()));
215 }
216 
217 TEST(TypeLoc, LongLongUnsignedRange) {
218   RangeVerifier<TypeLoc> Verifier;
219   Verifier.expectRange(1, 1, 1, 11);
220   EXPECT_TRUE(Verifier.match("long long unsigned a;", typeLoc()));
221 }
222 
223 TEST(TypeLoc, ConstLongLongRange) {
224   RangeVerifier<TypeLoc> Verifier;
225   Verifier.expectRange(1, 7, 1, 12);
226   EXPECT_TRUE(Verifier.match("const long long a = 0;", typeLoc()));
227 }
228 
229 TEST(TypeLoc, LongConstLongRange) {
230   RangeVerifier<TypeLoc> Verifier;
231   Verifier.expectRange(1, 1, 1, 12);
232   EXPECT_TRUE(Verifier.match("long const long a = 0;", typeLoc()));
233 }
234 
235 TEST(TypeLoc, LongLongConstRange) {
236   RangeVerifier<TypeLoc> Verifier;
237   Verifier.expectRange(1, 1, 1, 6);
238   EXPECT_TRUE(Verifier.match("long long const a = 0;", typeLoc()));
239 }
240 
241 TEST(CXXConstructorDecl, NoRetFunTypeLocRange) {
242   RangeVerifier<CXXConstructorDecl> Verifier;
243   Verifier.expectRange(1, 11, 1, 13);
244   EXPECT_TRUE(Verifier.match("class C { C(); };", functionDecl()));
245 }
246 
247 TEST(CXXConstructorDecl, DefaultedCtorLocRange) {
248   RangeVerifier<CXXConstructorDecl> Verifier;
249   Verifier.expectRange(1, 11, 1, 23);
250   EXPECT_TRUE(Verifier.match("class C { C() = default; };", functionDecl()));
251 }
252 
253 TEST(CXXConstructorDecl, DeletedCtorLocRange) {
254   RangeVerifier<CXXConstructorDecl> Verifier;
255   Verifier.expectRange(1, 11, 1, 22);
256   EXPECT_TRUE(Verifier.match("class C { C() = delete; };", functionDecl()));
257 }
258 
259 TEST(CompoundLiteralExpr, CompoundVectorLiteralRange) {
260   RangeVerifier<CompoundLiteralExpr> Verifier;
261   Verifier.expectRange(2, 11, 2, 22);
262   EXPECT_TRUE(Verifier.match(
263                   "typedef int int2 __attribute__((ext_vector_type(2)));\n"
264                   "int2 i2 = (int2){1, 2};", compoundLiteralExpr()));
265 }
266 
267 TEST(CompoundLiteralExpr, ParensCompoundVectorLiteralRange) {
268   RangeVerifier<CompoundLiteralExpr> Verifier;
269   Verifier.expectRange(2, 20, 2, 31);
270   EXPECT_TRUE(Verifier.match(
271                   "typedef int int2 __attribute__((ext_vector_type(2)));\n"
272                   "constant int2 i2 = (int2)(1, 2);",
273                   compoundLiteralExpr(), Lang_OpenCL));
274 }
275 
276 TEST(InitListExpr, VectorLiteralListBraceRange) {
277   RangeVerifier<InitListExpr> Verifier;
278   Verifier.expectRange(2, 17, 2, 22);
279   EXPECT_TRUE(Verifier.match(
280                   "typedef int int2 __attribute__((ext_vector_type(2)));\n"
281                   "int2 i2 = (int2){1, 2};", initListExpr()));
282 }
283 
284 TEST(InitListExpr, VectorLiteralInitListParens) {
285   RangeVerifier<InitListExpr> Verifier;
286   Verifier.expectRange(2, 26, 2, 31);
287   EXPECT_TRUE(Verifier.match(
288                   "typedef int int2 __attribute__((ext_vector_type(2)));\n"
289                   "constant int2 i2 = (int2)(1, 2);", initListExpr(), Lang_OpenCL));
290 }
291 
292 class TemplateAngleBracketLocRangeVerifier : public RangeVerifier<TypeLoc> {
293 protected:
294   SourceRange getRange(const TypeLoc &Node) override {
295     TemplateSpecializationTypeLoc T =
296         Node.getUnqualifiedLoc().castAs<TemplateSpecializationTypeLoc>();
297     assert(!T.isNull());
298     return SourceRange(T.getLAngleLoc(), T.getRAngleLoc());
299   }
300 };
301 
302 TEST(TemplateSpecializationTypeLoc, AngleBracketLocations) {
303   TemplateAngleBracketLocRangeVerifier Verifier;
304   Verifier.expectRange(2, 8, 2, 10);
305   EXPECT_TRUE(Verifier.match(
306       "template<typename T> struct A {}; struct B{}; void f(\n"
307       "const A<B>&);",
308       loc(templateSpecializationType())));
309 }
310 
311 TEST(CXXNewExpr, TypeParenRange) {
312   RangeVerifier<CXXNewExpr> Verifier;
313   Verifier.expectRange(1, 10, 1, 18);
314   EXPECT_TRUE(Verifier.match("int* a = new (int);", cxxNewExpr()));
315 }
316 
317 class UnaryTransformTypeLocParensRangeVerifier : public RangeVerifier<TypeLoc> {
318 protected:
319   SourceRange getRange(const TypeLoc &Node) override {
320     UnaryTransformTypeLoc T =
321         Node.getUnqualifiedLoc().castAs<UnaryTransformTypeLoc>();
322     assert(!T.isNull());
323     return SourceRange(T.getLParenLoc(), T.getRParenLoc());
324   }
325 };
326 
327 TEST(UnaryTransformTypeLoc, ParensRange) {
328   UnaryTransformTypeLocParensRangeVerifier Verifier;
329   Verifier.expectRange(3, 26, 3, 28);
330   EXPECT_TRUE(Verifier.match(
331       "template <typename T>\n"
332       "struct S {\n"
333       "typedef __underlying_type(T) type;\n"
334       "};",
335       loc(unaryTransformType())));
336 }
337 
338 TEST(CXXFunctionalCastExpr, SourceRange) {
339   RangeVerifier<CXXFunctionalCastExpr> Verifier;
340   Verifier.expectRange(2, 10, 2, 14);
341   EXPECT_TRUE(Verifier.match(
342       "int foo() {\n"
343       "  return int{};\n"
344       "}",
345       cxxFunctionalCastExpr(), Lang_CXX11));
346 }
347 
348 TEST(CXXConstructExpr, SourceRange) {
349   RangeVerifier<CXXConstructExpr> Verifier;
350   Verifier.expectRange(3, 14, 3, 19);
351   EXPECT_TRUE(Verifier.match(
352       "struct A { A(int, int); };\n"
353       "void f(A a);\n"
354       "void g() { f({0, 0}); }",
355       cxxConstructExpr(), Lang_CXX11));
356 }
357 
358 TEST(CXXTemporaryObjectExpr, SourceRange) {
359   RangeVerifier<CXXTemporaryObjectExpr> Verifier;
360   Verifier.expectRange(2, 6, 2, 12);
361   EXPECT_TRUE(Verifier.match(
362       "struct A { A(int, int); };\n"
363       "A a( A{0, 0} );",
364       cxxTemporaryObjectExpr(), Lang_CXX11));
365 }
366 
367 TEST(CXXUnresolvedConstructExpr, SourceRange) {
368   RangeVerifier<CXXUnresolvedConstructExpr> Verifier;
369   Verifier.expectRange(3, 10, 3, 12);
370   std::vector<std::string> Args;
371   Args.push_back("-fno-delayed-template-parsing");
372   EXPECT_TRUE(Verifier.match(
373       "template <typename U>\n"
374       "U foo() {\n"
375       "  return U{};\n"
376       "}",
377       cxxUnresolvedConstructExpr(), Args, Lang_CXX11));
378 }
379 
380 TEST(UsingDecl, SourceRange) {
381   RangeVerifier<UsingDecl> Verifier;
382   Verifier.expectRange(2, 22, 2, 25);
383   EXPECT_TRUE(Verifier.match(
384       "class B { protected: int i; };\n"
385       "class D : public B { B::i; };",
386       usingDecl()));
387 }
388 
389 TEST(UnresolvedUsingValueDecl, SourceRange) {
390   RangeVerifier<UnresolvedUsingValueDecl> Verifier;
391   Verifier.expectRange(3, 3, 3, 6);
392   EXPECT_TRUE(Verifier.match(
393       "template <typename B>\n"
394       "class D : public B {\n"
395       "  B::i;\n"
396       "};",
397       unresolvedUsingValueDecl()));
398 }
399 
400 TEST(FriendDecl, FriendNonMemberFunctionLocation) {
401   LocationVerifier<FriendDecl> Verifier;
402   Verifier.expectLocation(2, 13);
403   EXPECT_TRUE(Verifier.match("struct A {\n"
404                              "friend void f();\n"
405                              "};\n",
406                              friendDecl()));
407 }
408 
409 TEST(FriendDecl, FriendNonMemberFunctionRange) {
410   RangeVerifier<FriendDecl> Verifier;
411   Verifier.expectRange(2, 1, 2, 15);
412   EXPECT_TRUE(Verifier.match("struct A {\n"
413                              "friend void f();\n"
414                              "};\n",
415                              friendDecl()));
416 }
417 
418 TEST(FriendDecl, FriendNonMemberFunctionDefinitionLocation) {
419   LocationVerifier<FriendDecl> Verifier;
420   Verifier.expectLocation(2, 12);
421   EXPECT_TRUE(Verifier.match("struct A {\n"
422                              "friend int f() { return 0; }\n"
423                              "};\n",
424                              friendDecl()));
425 }
426 
427 TEST(FriendDecl, FriendNonMemberFunctionDefinitionRange) {
428   RangeVerifier<FriendDecl> Verifier;
429   Verifier.expectRange(2, 1, 2, 28);
430   EXPECT_TRUE(Verifier.match("struct A {\n"
431                              "friend int f() { return 0; }\n"
432                              "};\n",
433                              friendDecl()));
434 }
435 
436 TEST(FriendDecl, FriendElaboratedTypeLocation) {
437   LocationVerifier<FriendDecl> Verifier;
438   Verifier.expectLocation(2, 8);
439   EXPECT_TRUE(Verifier.match("struct A {\n"
440                              "friend class B;\n"
441                              "};\n",
442                              friendDecl()));
443 }
444 
445 TEST(FriendDecl, FriendElaboratedTypeRange) {
446   RangeVerifier<FriendDecl> Verifier;
447   Verifier.expectRange(2, 1, 2, 14);
448   EXPECT_TRUE(Verifier.match("struct A {\n"
449                              "friend class B;\n"
450                              "};\n",
451                              friendDecl()));
452 }
453 
454 TEST(FriendDecl, FriendSimpleTypeLocation) {
455   LocationVerifier<FriendDecl> Verifier;
456   Verifier.expectLocation(3, 8);
457   EXPECT_TRUE(Verifier.match("class B;\n"
458                              "struct A {\n"
459                              "friend B;\n"
460                              "};\n",
461                              friendDecl(), Lang_CXX11));
462 }
463 
464 TEST(FriendDecl, FriendSimpleTypeRange) {
465   RangeVerifier<FriendDecl> Verifier;
466   Verifier.expectRange(3, 1, 3, 8);
467   EXPECT_TRUE(Verifier.match("class B;\n"
468                              "struct A {\n"
469                              "friend B;\n"
470                              "};\n",
471                              friendDecl(), Lang_CXX11));
472 }
473 
474 TEST(FriendDecl, FriendTemplateParameterLocation) {
475   LocationVerifier<FriendDecl> Verifier;
476   Verifier.expectLocation(3, 8);
477   EXPECT_TRUE(Verifier.match("template <typename T>\n"
478                              "struct A {\n"
479                              "friend T;\n"
480                              "};\n",
481                              friendDecl(), Lang_CXX11));
482 }
483 
484 TEST(FriendDecl, FriendTemplateParameterRange) {
485   RangeVerifier<FriendDecl> Verifier;
486   Verifier.expectRange(3, 1, 3, 8);
487   EXPECT_TRUE(Verifier.match("template <typename T>\n"
488                              "struct A {\n"
489                              "friend T;\n"
490                              "};\n",
491                              friendDecl(), Lang_CXX11));
492 }
493 
494 TEST(FriendDecl, FriendDecltypeLocation) {
495   LocationVerifier<FriendDecl> Verifier;
496   Verifier.expectLocation(4, 8);
497   EXPECT_TRUE(Verifier.match("struct A;\n"
498                              "A foo();\n"
499                              "struct A {\n"
500                              "friend decltype(foo());\n"
501                              "};\n",
502                              friendDecl(), Lang_CXX11));
503 }
504 
505 TEST(FriendDecl, FriendDecltypeRange) {
506   RangeVerifier<FriendDecl> Verifier;
507   Verifier.expectRange(4, 1, 4, 8);
508   EXPECT_TRUE(Verifier.match("struct A;\n"
509                              "A foo();\n"
510                              "struct A {\n"
511                              "friend decltype(foo());\n"
512                              "};\n",
513                              friendDecl(), Lang_CXX11));
514 }
515 
516 TEST(FriendDecl, FriendConstructorDestructorLocation) {
517   const std::string Code = "struct B {\n"
518                            "B();\n"
519                            "~B();\n"
520                            "};\n"
521                            "struct A {\n"
522                            "friend B::B(), B::~B();\n"
523                            "};\n";
524   LocationVerifier<FriendDecl> ConstructorVerifier;
525   ConstructorVerifier.expectLocation(6, 11);
526   EXPECT_TRUE(ConstructorVerifier.match(
527       Code, friendDecl(has(cxxConstructorDecl(ofClass(hasName("B")))))));
528   LocationVerifier<FriendDecl> DestructorVerifier;
529   DestructorVerifier.expectLocation(6, 19);
530   EXPECT_TRUE(DestructorVerifier.match(
531       Code, friendDecl(has(cxxDestructorDecl(ofClass(hasName("B")))))));
532 }
533 
534 TEST(FriendDecl, FriendConstructorDestructorRange) {
535   const std::string Code = "struct B {\n"
536                            "B();\n"
537                            "~B();\n"
538                            "};\n"
539                            "struct A {\n"
540                            "friend B::B(), B::~B();\n"
541                            "};\n";
542   RangeVerifier<FriendDecl> ConstructorVerifier;
543   ConstructorVerifier.expectRange(6, 1, 6, 13);
544   EXPECT_TRUE(ConstructorVerifier.match(
545       Code, friendDecl(has(cxxConstructorDecl(ofClass(hasName("B")))))));
546   RangeVerifier<FriendDecl> DestructorVerifier;
547   DestructorVerifier.expectRange(6, 1, 6, 22);
548   EXPECT_TRUE(DestructorVerifier.match(
549       Code, friendDecl(has(cxxDestructorDecl(ofClass(hasName("B")))))));
550 }
551 
552 TEST(FriendDecl, FriendTemplateFunctionLocation) {
553   LocationVerifier<FriendDecl> Verifier;
554   Verifier.expectLocation(3, 13);
555   EXPECT_TRUE(Verifier.match("struct A {\n"
556                              "template <typename T>\n"
557                              "friend void f();\n"
558                              "};\n",
559                              friendDecl()));
560 }
561 
562 TEST(FriendDecl, FriendTemplateFunctionRange) {
563   RangeVerifier<FriendDecl> Verifier;
564   Verifier.expectRange(2, 1, 3, 15);
565   EXPECT_TRUE(Verifier.match("struct A {\n"
566                              "template <typename T>\n"
567                              "friend void f();\n"
568                              "};\n",
569                              friendDecl()));
570 }
571 
572 TEST(FriendDecl, FriendTemplateClassLocation) {
573   LocationVerifier<FriendDecl> Verifier;
574   Verifier.expectLocation(3, 14);
575   EXPECT_TRUE(Verifier.match("struct A {\n"
576                              "template <typename T>\n"
577                              "friend class B;\n"
578                              "};\n",
579                              friendDecl()));
580 }
581 
582 TEST(FriendDecl, FriendTemplateClassRange) {
583   RangeVerifier<FriendDecl> Verifier;
584   Verifier.expectRange(2, 1, 3, 14);
585   EXPECT_TRUE(Verifier.match("struct A {\n"
586                              "template <typename T>\n"
587                              "friend class B;\n"
588                              "};\n",
589                              friendDecl()));
590 }
591 
592 TEST(FriendDecl, FriendInlineFunctionLocation) {
593   LocationVerifier<FriendDecl> Verifier;
594   Verifier.expectLocation(2, 19);
595   EXPECT_TRUE(Verifier.match("struct A {\n"
596                              "int inline friend f() { return 0; }"
597                              "};\n",
598                              friendDecl()));
599 }
600 
601 TEST(FriendDecl, FriendInlineFunctionRange) {
602   RangeVerifier<FriendDecl> Verifier;
603   Verifier.expectRange(2, 1, 2, 35);
604   EXPECT_TRUE(Verifier.match("struct A {\n"
605                              "int inline friend f() { return 0; }"
606                              "};\n",
607                              friendDecl(), Lang_CXX11));
608 }
609 
610 TEST(FriendDecl, InstantiationSourceRange) {
611   RangeVerifier<FriendDecl> Verifier;
612   Verifier.expectRange(4, 3, 4, 35);
613   EXPECT_TRUE(Verifier.match(
614       "template <typename T> class S;\n"
615       "template<class T> void operator+(S<T> x);\n"
616       "template<class T> struct S {\n"
617       "  friend void operator+<>(S<T> src);\n"
618       "};\n"
619       "void test(S<double> s) { +s; }",
620       friendDecl(hasParent(cxxRecordDecl(isTemplateInstantiation())))));
621 }
622 
623 TEST(ObjCMessageExpr, CXXConstructExprRange) {
624   RangeVerifier<CXXConstructExpr> Verifier;
625   Verifier.expectRange(5, 25, 5, 27);
626   EXPECT_TRUE(Verifier.match(
627       "struct A { int a; };\n"
628       "@interface B {}\n"
629       "+ (void) f1: (A)arg;\n"
630       "@end\n"
631       "void f2() { A a; [B f1: (a)]; }\n",
632       cxxConstructExpr(), Lang_OBJCXX));
633 }
634 
635 TEST(FunctionDecl, FunctionDeclWithThrowSpecification) {
636   RangeVerifier<FunctionDecl> Verifier;
637   Verifier.expectRange(1, 1, 1, 16);
638   EXPECT_TRUE(Verifier.match(
639       "void f() throw();\n",
640       functionDecl()));
641 }
642 
643 TEST(FunctionDecl, FunctionDeclWithNoExceptSpecification) {
644   RangeVerifier<FunctionDecl> Verifier;
645   Verifier.expectRange(1, 1, 1, 24);
646   EXPECT_TRUE(Verifier.match(
647       "void f() noexcept(false);\n",
648       functionDecl(),
649       Language::Lang_CXX11));
650 }
651 
652 TEST(CXXMethodDecl, CXXMethodDeclWithThrowSpecification) {
653   RangeVerifier<FunctionDecl> Verifier;
654   Verifier.expectRange(2, 1, 2, 16);
655   EXPECT_TRUE(Verifier.match(
656       "class A {\n"
657       "void f() throw();\n"
658       "};\n",
659       functionDecl()));
660 }
661 
662 TEST(CXXMethodDecl, CXXMethodDeclWithNoExceptSpecification) {
663   RangeVerifier<FunctionDecl> Verifier;
664   Verifier.expectRange(2, 1, 2, 24);
665   EXPECT_TRUE(Verifier.match(
666       "class A {\n"
667       "void f() noexcept(false);\n"
668       "};\n",
669       functionDecl(),
670       Language::Lang_CXX11));
671 }
672 
673 } // end namespace ast_matchers
674 } // end namespace clang
675