clang-tools-extra/clangd/unittests/SelectionTests.cpp

   1 //===-- SelectionTests.cpp - ----------------------------------------------===//
   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 #include "Annotations.h"
   9 #include "Selection.h"
  10 #include "SourceCode.h"
  11 #include "TestTU.h"
  12 #include "support/TestTracer.h"
  13 #include "clang/AST/Decl.h"
  14 #include "llvm/Support/Casting.h"
  15 #include "gmock/gmock.h"
  16 #include "gtest/gtest.h"
  17
  18 namespace clang {
  19 namespace clangd {
  20 namespace {
  21 using ::testing::ElementsAreArray;
  22 using ::testing::UnorderedElementsAreArray;
  23
  24 // Create a selection tree corresponding to a point or pair of points.
  25 // This uses the precisely-defined createRight semantics. The fuzzier
  26 // createEach is tested separately.
  27 SelectionTree makeSelectionTree(const StringRef MarkedCode, ParsedAST &AST) {
  28   Annotations Test(MarkedCode);
  29   switch (Test.points().size()) {
  30   case 1: { // Point selection.
  31     unsigned Offset = cantFail(positionToOffset(Test.code(), Test.point()));
  32     return SelectionTree::createRight(AST.getASTContext(), AST.getTokens(),
  33                                       Offset, Offset);
  34   }
  35   case 2: // Range selection.
  36     return SelectionTree::createRight(
  37         AST.getASTContext(), AST.getTokens(),
  38         cantFail(positionToOffset(Test.code(), Test.points()[0])),
  39         cantFail(positionToOffset(Test.code(), Test.points()[1])));
  40   default:
  41     ADD_FAILURE() << "Expected 1-2 points for selection.\n" << MarkedCode;
  42     return SelectionTree::createRight(AST.getASTContext(), AST.getTokens(), 0u,
  43                                       0u);
  44   }
  45 }
  46
  47 Range nodeRange(const SelectionTree::Node *N, ParsedAST &AST) {
  48   if (!N)
  49     return Range{};
  50   const SourceManager &SM = AST.getSourceManager();
  51   const LangOptions &LangOpts = AST.getLangOpts();
  52   StringRef Buffer = SM.getBufferData(SM.getMainFileID());
  53   if (llvm::isa_and_nonnull<TranslationUnitDecl>(N->ASTNode.get<Decl>()))
  54     return Range{Position{}, offsetToPosition(Buffer, Buffer.size())};
  55   auto FileRange =
  56       toHalfOpenFileRange(SM, LangOpts, N->ASTNode.getSourceRange());
  57   assert(FileRange && "We should be able to get the File Range");
  58   return Range{
  59       offsetToPosition(Buffer, SM.getFileOffset(FileRange->getBegin())),
  60       offsetToPosition(Buffer, SM.getFileOffset(FileRange->getEnd()))};
  61 }
  62
  63 std::string nodeKind(const SelectionTree::Node *N) {
  64   return N ? N->kind() : "<null>";
  65 }
  66
  67 std::vector<const SelectionTree::Node *> allNodes(const SelectionTree &T) {
  68   std::vector<const SelectionTree::Node *> Result = {&T.root()};
  69   for (unsigned I = 0; I < Result.size(); ++I) {
  70     const SelectionTree::Node *N = Result[I];
  71     Result.insert(Result.end(), N->Children.begin(), N->Children.end());
  72   }
  73   return Result;
  74 }
  75
  76 // Returns true if Common is a descendent of Root.
  77 // Verifies nothing is selected above Common.
  78 bool verifyCommonAncestor(const SelectionTree::Node &Root,
  79                           const SelectionTree::Node *Common,
  80                           StringRef MarkedCode) {
  81   if (&Root == Common)
  82     return true;
  83   if (Root.Selected)
  84     ADD_FAILURE() << "Selected nodes outside common ancestor\n" << MarkedCode;
  85   bool Seen = false;
  86   for (const SelectionTree::Node *Child : Root.Children)
  87     if (verifyCommonAncestor(*Child, Common, MarkedCode)) {
  88       if (Seen)
  89         ADD_FAILURE() << "Saw common ancestor twice\n" << MarkedCode;
  90       Seen = true;
  91     }
  92   return Seen;
  93 }
  94
  95 TEST(SelectionTest, CommonAncestor) {
  96   struct Case {
  97     // Selection is between ^marks^.
  98     // common ancestor marked with a [[range]].
  99     const char *Code;
 100     const char *CommonAncestorKind;
 101   };
 102   Case Cases[] = {
 103       {
 104           R"cpp(
 105             template <typename T>
 106             int x = [[T::^U::]]ccc();
 107           )cpp",
 108           "NestedNameSpecifierLoc",
 109       },
 110       {
 111           R"cpp(
 112             struct AAA { struct BBB { static int ccc(); };};
 113             int x = AAA::[[B^B^B]]::ccc();
 114           )cpp",
 115           "RecordTypeLoc",
 116       },
 117       {
 118           R"cpp(
 119             struct AAA { struct BBB { static int ccc(); };};
 120             int x = AAA::[[B^BB^]]::ccc();
 121           )cpp",
 122           "RecordTypeLoc",
 123       },
 124       {
 125           R"cpp(
 126             struct AAA { struct BBB { static int ccc(); };};
 127             int x = [[AAA::BBB::c^c^c]]();
 128           )cpp",
 129           "DeclRefExpr",
 130       },
 131       {
 132           R"cpp(
 133             struct AAA { struct BBB { static int ccc(); };};
 134             int x = [[AAA::BBB::cc^c(^)]];
 135           )cpp",
 136           "CallExpr",
 137       },
 138
 139       {
 140           R"cpp(
 141             void foo() { [[if (1^11) { return; } else {^ }]] }
 142           )cpp",
 143           "IfStmt",
 144       },
 145       {
 146           R"cpp(
 147             int x(int);
 148             #define M(foo) x(foo)
 149             int a = 42;
 150             int b = M([[^a]]);
 151           )cpp",
 152           "DeclRefExpr",
 153       },
 154       {
 155           R"cpp(
 156             void foo();
 157             #define CALL_FUNCTION(X) X()
 158             void bar() { CALL_FUNCTION([[f^o^o]]); }
 159           )cpp",
 160           "DeclRefExpr",
 161       },
 162       {
 163           R"cpp(
 164             void foo();
 165             #define CALL_FUNCTION(X) X()
 166             void bar() { [[CALL_FUNC^TION(fo^o)]]; }
 167           )cpp",
 168           "CallExpr",
 169       },
 170       {
 171           R"cpp(
 172             void foo();
 173             #define CALL_FUNCTION(X) X()
 174             void bar() { [[C^ALL_FUNC^TION(foo)]]; }
 175           )cpp",
 176           "CallExpr",
 177       },
 178       {
 179           R"cpp(
 180             void foo();
 181             #^define CALL_FUNCTION(X) X(^)
 182             void bar() { CALL_FUNCTION(foo); }
 183           )cpp",
 184           nullptr,
 185       },
 186       {
 187           R"cpp(
 188             void foo();
 189             #define CALL_FUNCTION(X) X()
 190             void bar() { CALL_FUNCTION(foo^)^; }
 191           )cpp",
 192           nullptr,
 193       },
 194       {
 195           R"cpp(
 196             namespace ns {
 197             #if 0
 198             void fo^o() {}
 199             #endif
 200             }
 201           )cpp",
 202           nullptr,
 203       },
 204       {
 205           R"cpp(
 206             #define TARGET void foo()
 207             [[TAR^GET{ return; }]]
 208           )cpp",
 209           "FunctionDecl",
 210       },
 211       {
 212           R"cpp(
 213             struct S { S(const char*); };
 214             [[S s ^= "foo"]];
 215           )cpp",
 216           // The AST says a CXXConstructExpr covers the = sign in C++14.
 217           // But we consider CXXConstructExpr to only own brackets.
 218           // (It's not the interesting constructor anyway, just S(&&)).
 219           "VarDecl",
 220       },
 221       {
 222           R"cpp(
 223             struct S { S(const char*); };
 224             [[S ^s = "foo"]];
 225           )cpp",
 226           "VarDecl",
 227       },
 228       {
 229           R"cpp(
 230             [[^void]] (*S)(int) = nullptr;
 231           )cpp",
 232           "BuiltinTypeLoc",
 233       },
 234       {
 235           R"cpp(
 236             [[void (*S)^(int)]] = nullptr;
 237           )cpp",
 238           "FunctionProtoTypeLoc",
 239       },
 240       {
 241           R"cpp(
 242             [[void (^*S)(int)]] = nullptr;
 243           )cpp",
 244           "PointerTypeLoc",
 245       },
 246       {
 247           R"cpp(
 248             [[void (*^S)(int) = nullptr]];
 249           )cpp",
 250           "VarDecl",
 251       },
 252       {
 253           R"cpp(
 254             [[void ^(*S)(int)]] = nullptr;
 255           )cpp",
 256           "ParenTypeLoc",
 257       },
 258       {
 259           R"cpp(
 260             struct S {
 261               int foo() const;
 262               int bar() { return [[f^oo]](); }
 263             };
 264           )cpp",
 265           "MemberExpr", // Not implicit CXXThisExpr, or its implicit cast!
 266       },
 267       {
 268           R"cpp(
 269             auto lambda = [](const char*){ return 0; };
 270             int x = lambda([["y^"]]);
 271           )cpp",
 272           "StringLiteral", // Not DeclRefExpr to operator()!
 273       },
 274       {
 275           R"cpp(
 276             struct Foo {};
 277             struct Bar : [[v^ir^tual private Foo]] {};
 278           )cpp",
 279           "CXXBaseSpecifier",
 280       },
 281       {
 282           R"cpp(
 283             struct Foo {};
 284             struct Bar : private [[Fo^o]] {};
 285           )cpp",
 286           "RecordTypeLoc",
 287       },
 288       {
 289           R"cpp(
 290             struct Foo {};
 291             struct Bar : [[Fo^o]] {};
 292           )cpp",
 293           "RecordTypeLoc",
 294       },
 295
 296       // Point selections.
 297       {"void foo() { [[^foo]](); }", "DeclRefExpr"},
 298       {"void foo() { [[f^oo]](); }", "DeclRefExpr"},
 299       {"void foo() { [[fo^o]](); }", "DeclRefExpr"},
 300       {"void foo() { [[foo^()]]; }", "CallExpr"},
 301       {"void foo() { [[foo^]] (); }", "DeclRefExpr"},
 302       {"int bar; void foo() [[{ foo (); }]]^", "CompoundStmt"},
 303       {"int x = [[42]]^;", "IntegerLiteral"},
 304
 305       // Ignores whitespace, comments, and semicolons in the selection.
 306       {"void foo() { [[foo^()]]; /*comment*/^}", "CallExpr"},
 307
 308       // Tricky case: FunctionTypeLoc in FunctionDecl has a hole in it.
 309       {"[[^void]] foo();", "BuiltinTypeLoc"},
 310       {"[[void foo^()]];", "FunctionProtoTypeLoc"},
 311       {"[[^void foo^()]];", "FunctionDecl"},
 312       {"[[void ^foo()]];", "FunctionDecl"},
 313       // Tricky case: two VarDecls share a specifier.
 314       {"[[int ^a]], b;", "VarDecl"},
 315       {"[[int a, ^b]];", "VarDecl"},
 316       // Tricky case: CXXConstructExpr wants to claim the whole init range.
 317       {
 318           R"cpp(
 319             struct X { X(int); };
 320             class Y {
 321               X x;
 322               Y() : [[^x(4)]] {}
 323             };
 324           )cpp",
 325           "CXXCtorInitializer", // Not the CXXConstructExpr!
 326       },
 327       // Tricky case: anonymous struct is a sibling of the VarDecl.
 328       {"[[st^ruct {int x;}]] y;", "CXXRecordDecl"},
 329       {"[[struct {int x;} ^y]];", "VarDecl"},
 330       {"struct {[[int ^x]];} y;", "FieldDecl"},
 331
 332       // Tricky case: nested ArrayTypeLocs have the same token range.
 333       {"const int x = 1, y = 2; int array[^[[x]]][10][y];", "DeclRefExpr"},
 334       {"const int x = 1, y = 2; int array[x][10][^[[y]]];", "DeclRefExpr"},
 335       {"const int x = 1, y = 2; int array[x][^[[10]]][y];", "IntegerLiteral"},
 336       {"const int x = 1, y = 2; [[i^nt]] array[x][10][y];", "BuiltinTypeLoc"},
 337       {"void func(int x) { int v_array[^[[x]]][10]; }", "DeclRefExpr"},
 338
 339       {"int (*getFunc([[do^uble]]))(int);", "BuiltinTypeLoc"},
 340
 341       // Member pointers and pack expansion use declarator syntax, but are
 342       // restricted so they don't need special casing.
 343       {"class X{}; [[int X::^*]]y[10];", "MemberPointerTypeLoc"},
 344       {"template<typename ...T> void foo([[T*^...]]x);",
 345        "PackExpansionTypeLoc"},
 346       {"template<typename ...T> void foo([[^T]]*...x);",
 347        "TemplateTypeParmTypeLoc"},
 348
 349       // FIXME: the AST has no location info for qualifiers.
 350       {"const [[a^uto]] x = 42;", "AutoTypeLoc"},
 351       {"co^nst auto x = 42;", nullptr},
 352
 353       {"^", nullptr},
 354       {"void foo() { [[foo^^]] (); }", "DeclRefExpr"},
 355
 356       // FIXME: Ideally we'd get a declstmt or the VarDecl itself here.
 357       // This doesn't happen now; the RAV doesn't traverse a node containing ;.
 358       {"int x = 42;^", nullptr},
 359
 360       // Common ancestor is logically TUDecl, but we never return that.
 361       {"^int x; int y;^", nullptr},
 362
 363       // Node types that have caused problems in the past.
 364       {"template <typename T> void foo() { [[^T]] t; }",
 365        "TemplateTypeParmTypeLoc"},
 366
 367       // No crash
 368       {
 369           R"cpp(
 370             template <class T> struct Foo {};
 371             template <[[template<class> class /*cursor here*/^U]]>
 372              struct Foo<U<int>*> {};
 373           )cpp",
 374           "TemplateTemplateParmDecl"},
 375
 376       // Foreach has a weird AST, ensure we can select parts of the range init.
 377       // This used to fail, because the DeclStmt for C claimed the whole range.
 378       {
 379           R"cpp(
 380             struct Str {
 381               const char *begin();
 382               const char *end();
 383             };
 384             Str makeStr(const char*);
 385             void loop() {
 386               for (const char C : [[mak^eStr("foo"^)]])
 387                 ;
 388             }
 389           )cpp",
 390           "CallExpr"},
 391
 392       // User-defined literals are tricky: is 12_i one token or two?
 393       // For now we treat it as one, and the UserDefinedLiteral as a leaf.
 394       {
 395           R"cpp(
 396             struct Foo{};
 397             Foo operator""_ud(unsigned long long);
 398             Foo x = [[^12_ud]];
 399           )cpp",
 400           "UserDefinedLiteral"},
 401
 402       {
 403           R"cpp(
 404         int a;
 405         decltype([[^a]] + a) b;
 406         )cpp",
 407           "DeclRefExpr"},
 408       {"[[decltype^(1)]] b;", "DecltypeTypeLoc"}, // Not the VarDecl.
 409       // decltype(auto) is an AutoTypeLoc!
 410       {"[[de^cltype(a^uto)]] a = 1;", "AutoTypeLoc"},
 411
 412       // Objective-C nullability attributes.
 413       {
 414           R"cpp(
 415             @interface I{}
 416             @property(nullable) [[^I]] *x;
 417             @end
 418           )cpp",
 419           "ObjCInterfaceTypeLoc"},
 420       {
 421           R"cpp(
 422             @interface I{}
 423             - (void)doSomething:(nonnull [[i^d]])argument;
 424             @end
 425           )cpp",
 426           "TypedefTypeLoc"},
 427
 428       // Objective-C OpaqueValueExpr/PseudoObjectExpr has weird ASTs.
 429       // Need to traverse the contents of the OpaqueValueExpr to the POE,
 430       // and ensure we traverse only the syntactic form of the PseudoObjectExpr.
 431       {
 432           R"cpp(
 433             @interface I{}
 434             @property(retain) I*x;
 435             @property(retain) I*y;
 436             @end
 437             void test(I *f) { [[^f]].x.y = 0; }
 438           )cpp",
 439           "DeclRefExpr"},
 440       {
 441           R"cpp(
 442             @interface I{}
 443             @property(retain) I*x;
 444             @property(retain) I*y;
 445             @end
 446             void test(I *f) { [[f.^x]].y = 0; }
 447           )cpp",
 448           "ObjCPropertyRefExpr"},
 449       // Examples with implicit properties.
 450       {
 451           R"cpp(
 452             @interface I{}
 453             -(int)foo;
 454             @end
 455             int test(I *f) { return 42 + [[^f]].foo; }
 456           )cpp",
 457           "DeclRefExpr"},
 458       {
 459           R"cpp(
 460             @interface I{}
 461             -(int)foo;
 462             @end
 463             int test(I *f) { return 42 + [[f.^foo]]; }
 464           )cpp",
 465           "ObjCPropertyRefExpr"},
 466       {"struct foo { [[int has^h<:32:>]]; };", "FieldDecl"},
 467       {"struct foo { [[op^erator int()]]; };", "CXXConversionDecl"},
 468       {"struct foo { [[^~foo()]]; };", "CXXDestructorDecl"},
 469       // FIXME: The following to should be class itself instead.
 470       {"struct foo { [[fo^o(){}]] };", "CXXConstructorDecl"},
 471
 472       {R"cpp(
 473         struct S1 { void f(); };
 474         struct S2 { S1 * operator->(); };
 475         void test(S2 s2) {
 476           s2[[-^>]]f();
 477         }
 478       )cpp",
 479        "DeclRefExpr"}, // DeclRefExpr to the "operator->" method.
 480
 481       // Template template argument.
 482       {R"cpp(
 483         template <typename> class Vector {};
 484         template <template <typename> class Container> class A {};
 485         A<[[V^ector]]> a;
 486       )cpp",
 487        "TemplateArgumentLoc"},
 488
 489       // Attributes
 490       {R"cpp(
 491         void f(int * __attribute__(([[no^nnull]])) );
 492       )cpp",
 493        "NonNullAttr"},
 494
 495       {R"cpp(
 496         // Digraph syntax for attributes to avoid accidental annotations.
 497         class <:[gsl::Owner([[in^t]])]:> X{};
 498       )cpp",
 499        "BuiltinTypeLoc"},
 500
 501       // This case used to crash - AST has a null Attr
 502       {R"cpp(
 503         @interface I
 504         [[@property(retain, nonnull) <:[My^Object2]:> *x]]; // error-ok
 505         @end
 506       )cpp",
 507        "ObjCPropertyDecl"},
 508
 509       {R"cpp(
 510         typedef int Foo;
 511         enum Bar : [[Fo^o]] {};
 512       )cpp",
 513        "TypedefTypeLoc"},
 514       {R"cpp(
 515         typedef int Foo;
 516         enum Bar : [[Fo^o]];
 517       )cpp",
 518        "TypedefTypeLoc"},
 519
 520       // lambda captured var-decl
 521       {R"cpp(
 522         void test(int bar) {
 523           auto l = [^[[foo = bar]]] { };
 524         })cpp",
 525        "VarDecl"},
 526       {R"cpp(
 527         /*error-ok*/
 528         void func() [[{^]])cpp",
 529        "CompoundStmt"},
 530       {R"cpp(
 531         void func() { [[__^func__]]; }
 532         )cpp",
 533        "PredefinedExpr"},
 534   };
 535
 536   for (const Case &C : Cases) {
 537     trace::TestTracer Tracer;
 538     Annotations Test(C.Code);
 539
 540     TestTU TU;
 541     TU.Code = std::string(Test.code());
 542
 543     TU.ExtraArgs.push_back("-xobjective-c++");
 544
 545     auto AST = TU.build();
 546     auto T = makeSelectionTree(C.Code, AST);
 547     EXPECT_EQ("TranslationUnitDecl", nodeKind(&T.root())) << C.Code;
 548
 549     if (Test.ranges().empty()) {
 550       // If no [[range]] is marked in the example, there should be no selection.
 551       EXPECT_FALSE(T.commonAncestor()) << C.Code << "\n" << T;
 552       EXPECT_THAT(Tracer.takeMetric("selection_recovery", "C++"),
 553                   testing::IsEmpty());
 554     } else {
 555       // If there is an expected selection, common ancestor should exist
 556       // with the appropriate node type.
 557       EXPECT_EQ(C.CommonAncestorKind, nodeKind(T.commonAncestor()))
 558           << C.Code << "\n"
 559           << T;
 560       // Convert the reported common ancestor to a range and verify it.
 561       EXPECT_EQ(nodeRange(T.commonAncestor(), AST), Test.range())
 562           << C.Code << "\n"
 563           << T;
 564
 565       // Check that common ancestor is reachable on exactly one path from root,
 566       // and no nodes outside it are selected.
 567       EXPECT_TRUE(verifyCommonAncestor(T.root(), T.commonAncestor(), C.Code))
 568           << C.Code;
 569       EXPECT_THAT(Tracer.takeMetric("selection_recovery", "C++"),
 570                   ElementsAreArray({0}));
 571     }
 572   }
 573 }
 574
 575 // Regression test: this used to match the injected X, not the outer X.
 576 TEST(SelectionTest, InjectedClassName) {
 577   const char *Code = "struct ^X { int x; };";
 578   auto AST = TestTU::withCode(Annotations(Code).code()).build();
 579   auto T = makeSelectionTree(Code, AST);
 580   ASSERT_EQ("CXXRecordDecl", nodeKind(T.commonAncestor())) << T;
 581   auto *D = dyn_cast<CXXRecordDecl>(T.commonAncestor()->ASTNode.get<Decl>());
 582   EXPECT_FALSE(D->isInjectedClassName());
 583 }
 584
 585 TEST(SelectionTree, Metrics) {
 586   const char *Code = R"cpp(
 587     // error-ok: testing behavior on recovery expression
 588     int foo();
 589     int foo(int, int);
 590     int x = fo^o(42);
 591   )cpp";
 592   auto AST = TestTU::withCode(Annotations(Code).code()).build();
 593   trace::TestTracer Tracer;
 594   auto T = makeSelectionTree(Code, AST);
 595   EXPECT_THAT(Tracer.takeMetric("selection_recovery", "C++"),
 596               ElementsAreArray({1}));
 597   EXPECT_THAT(Tracer.takeMetric("selection_recovery_type", "C++"),
 598               ElementsAreArray({1}));
 599 }
 600
 601 // FIXME: Doesn't select the binary operator node in
 602 //          #define FOO(X) X + 1
 603 //          int a, b = [[FOO(a)]];
 604 TEST(SelectionTest, Selected) {
 605   // Selection with ^marks^.
 606   // Partially selected nodes marked with a [[range]].
 607   // Completely selected nodes marked with a $C[[range]].
 608   const char *Cases[] = {
 609       R"cpp( int abc, xyz = [[^ab^c]]; )cpp",
 610       R"cpp( int abc, xyz = [[a^bc^]]; )cpp",
 611       R"cpp( int abc, xyz = $C[[^abc^]]; )cpp",
 612       R"cpp(
 613         void foo() {
 614           [[if ([[1^11]]) $C[[{
 615             $C[[return]];
 616           }]] else [[{^
 617           }]]]]
 618           char z;
 619         }
 620       )cpp",
 621       R"cpp(
 622           template <class T>
 623           struct unique_ptr {};
 624           void foo(^$C[[unique_ptr<$C[[unique_ptr<$C[[int]]>]]>]]^ a) {}
 625       )cpp",
 626       R"cpp(int a = [[5 >^> 1]];)cpp",
 627       R"cpp(
 628         #define ECHO(X) X
 629         ECHO(EC^HO($C[[int]]) EC^HO(a));
 630       )cpp",
 631       R"cpp( $C[[^$C[[int]] a^]]; )cpp",
 632       R"cpp( $C[[^$C[[int]] a = $C[[5]]^]]; )cpp",
 633   };
 634   for (const char *C : Cases) {
 635     Annotations Test(C);
 636     auto AST = TestTU::withCode(Test.code()).build();
 637     auto T = makeSelectionTree(C, AST);
 638
 639     std::vector<Range> Complete, Partial;
 640     for (const SelectionTree::Node *N : allNodes(T))
 641       if (N->Selected == SelectionTree::Complete)
 642         Complete.push_back(nodeRange(N, AST));
 643       else if (N->Selected == SelectionTree::Partial)
 644         Partial.push_back(nodeRange(N, AST));
 645     EXPECT_THAT(Complete, UnorderedElementsAreArray(Test.ranges("C"))) << C;
 646     EXPECT_THAT(Partial, UnorderedElementsAreArray(Test.ranges())) << C;
 647   }
 648 }
 649
 650 TEST(SelectionTest, PathologicalPreprocessor) {
 651   const char *Case = R"cpp(
 652 #define MACRO while(1)
 653     void test() {
 654 #include "Expand.inc"
 655         br^eak;
 656     }
 657   )cpp";
 658   Annotations Test(Case);
 659   auto TU = TestTU::withCode(Test.code());
 660   TU.AdditionalFiles["Expand.inc"] = "MACRO\n";
 661   auto AST = TU.build();
 662   EXPECT_THAT(*AST.getDiagnostics(), ::testing::IsEmpty());
 663   auto T = makeSelectionTree(Case, AST);
 664
 665   EXPECT_EQ("BreakStmt", T.commonAncestor()->kind());
 666   EXPECT_EQ("WhileStmt", T.commonAncestor()->Parent->kind());
 667 }
 668
 669 TEST(SelectionTest, IncludedFile) {
 670   const char *Case = R"cpp(
 671     void test() {
 672 #include "Exp^and.inc"
 673         break;
 674     }
 675   )cpp";
 676   Annotations Test(Case);
 677   auto TU = TestTU::withCode(Test.code());
 678   TU.AdditionalFiles["Expand.inc"] = "while(1)\n";
 679   auto AST = TU.build();
 680   auto T = makeSelectionTree(Case, AST);
 681
 682   EXPECT_EQ(nullptr, T.commonAncestor());
 683 }
 684
 685 TEST(SelectionTest, MacroArgExpansion) {
 686   // If a macro arg is expanded several times, we only consider the first one
 687   // selected.
 688   const char *Case = R"cpp(
 689     int mul(int, int);
 690     #define SQUARE(X) mul(X, X);
 691     int nine = SQUARE(^3);
 692   )cpp";
 693   Annotations Test(Case);
 694   auto AST = TestTU::withCode(Test.code()).build();
 695   auto T = makeSelectionTree(Case, AST);
 696   EXPECT_EQ("IntegerLiteral", T.commonAncestor()->kind());
 697   EXPECT_TRUE(T.commonAncestor()->Selected);
 698
 699   // Verify that the common assert() macro doesn't suffer from this.
 700   // (This is because we don't associate the stringified token with the arg).
 701   Case = R"cpp(
 702     void die(const char*);
 703     #define assert(x) (x ? (void)0 : die(#x))
 704     void foo() { assert(^42); }
 705   )cpp";
 706   Test = Annotations(Case);
 707   AST = TestTU::withCode(Test.code()).build();
 708   T = makeSelectionTree(Case, AST);
 709
 710   EXPECT_EQ("IntegerLiteral", T.commonAncestor()->kind());
 711 }
 712
 713 TEST(SelectionTest, Implicit) {
 714   const char *Test = R"cpp(
 715     struct S { S(const char*); };
 716     int f(S);
 717     int x = f("^");
 718   )cpp";
 719   auto AST = TestTU::withCode(Annotations(Test).code()).build();
 720   auto T = makeSelectionTree(Test, AST);
 721
 722   const SelectionTree::Node *Str = T.commonAncestor();
 723   EXPECT_EQ("StringLiteral", nodeKind(Str)) << "Implicit selected?";
 724   EXPECT_EQ("ImplicitCastExpr", nodeKind(Str->Parent));
 725   EXPECT_EQ("CXXConstructExpr", nodeKind(Str->Parent->Parent));
 726   EXPECT_EQ(Str, &Str->Parent->Parent->ignoreImplicit())
 727       << "Didn't unwrap " << nodeKind(&Str->Parent->Parent->ignoreImplicit());
 728
 729   EXPECT_EQ("CXXConstructExpr", nodeKind(&Str->outerImplicit()));
 730 }
 731
 732 TEST(SelectionTest, CreateAll) {
 733   llvm::Annotations Test("int$unique^ a=1$ambiguous^+1; $empty^");
 734   auto AST = TestTU::withCode(Test.code()).build();
 735   unsigned Seen = 0;
 736   SelectionTree::createEach(
 737       AST.getASTContext(), AST.getTokens(), Test.point("ambiguous"),
 738       Test.point("ambiguous"), [&](SelectionTree T) {
 739         // Expect to see the right-biased tree first.
 740         if (Seen == 0) {
 741           EXPECT_EQ("BinaryOperator", nodeKind(T.commonAncestor()));
 742         } else if (Seen == 1) {
 743           EXPECT_EQ("IntegerLiteral", nodeKind(T.commonAncestor()));
 744         }
 745         ++Seen;
 746         return false;
 747       });
 748   EXPECT_EQ(2u, Seen);
 749
 750   Seen = 0;
 751   SelectionTree::createEach(AST.getASTContext(), AST.getTokens(),
 752                             Test.point("ambiguous"), Test.point("ambiguous"),
 753                             [&](SelectionTree T) {
 754                               ++Seen;
 755                               return true;
 756                             });
 757   EXPECT_EQ(1u, Seen) << "Return true --> stop iterating";
 758
 759   Seen = 0;
 760   SelectionTree::createEach(AST.getASTContext(), AST.getTokens(),
 761                             Test.point("unique"), Test.point("unique"),
 762                             [&](SelectionTree T) {
 763                               ++Seen;
 764                               return false;
 765                             });
 766   EXPECT_EQ(1u, Seen) << "no ambiguity --> only one tree";
 767
 768   Seen = 0;
 769   SelectionTree::createEach(AST.getASTContext(), AST.getTokens(),
 770                             Test.point("empty"), Test.point("empty"),
 771                             [&](SelectionTree T) {
 772                               EXPECT_FALSE(T.commonAncestor());
 773                               ++Seen;
 774                               return false;
 775                             });
 776   EXPECT_EQ(1u, Seen) << "empty tree still created";
 777
 778   Seen = 0;
 779   SelectionTree::createEach(AST.getASTContext(), AST.getTokens(),
 780                             Test.point("unique"), Test.point("ambiguous"),
 781                             [&](SelectionTree T) {
 782                               ++Seen;
 783                               return false;
 784                             });
 785   EXPECT_EQ(1u, Seen) << "one tree for nontrivial selection";
 786 }
 787
 788 TEST(SelectionTest, DeclContextIsLexical) {
 789   llvm::Annotations Test("namespace a { void $1^foo(); } void a::$2^foo();");
 790   auto AST = TestTU::withCode(Test.code()).build();
 791   {
 792     auto ST = SelectionTree::createRight(AST.getASTContext(), AST.getTokens(),
 793                                          Test.point("1"), Test.point("1"));
 794     EXPECT_FALSE(ST.commonAncestor()->getDeclContext().isTranslationUnit());
 795   }
 796   {
 797     auto ST = SelectionTree::createRight(AST.getASTContext(), AST.getTokens(),
 798                                          Test.point("2"), Test.point("2"));
 799     EXPECT_TRUE(ST.commonAncestor()->getDeclContext().isTranslationUnit());
 800   }
 801 }
 802
 803 } // namespace
 804 } // namespace clangd
 805 } // namespace clang