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