clang/unittests/Tooling/ASTSelectionTest.cpp

   1 //===- unittest/Tooling/ASTSelectionTest.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
   9 #include "TestVisitor.h"
  10 #include "clang/Basic/SourceManager.h"
  11 #include "clang/Tooling/Refactoring/ASTSelection.h"
  12
  13 using namespace clang;
  14 using namespace tooling;
  15
  16 namespace {
  17
  18 struct FileLocation {
  19   unsigned Line, Column;
  20
  21   SourceLocation translate(const SourceManager &SM) {
  22     return SM.translateLineCol(SM.getMainFileID(), Line, Column);
  23   }
  24 };
  25
  26 using FileRange = std::pair<FileLocation, FileLocation>;
  27
  28 class SelectionFinderVisitor : public TestVisitor<SelectionFinderVisitor> {
  29   FileLocation Location;
  30   Optional<FileRange> SelectionRange;
  31   llvm::function_ref<void(SourceRange SelectionRange,
  32                           Optional<SelectedASTNode>)>
  33       Consumer;
  34
  35 public:
  36   SelectionFinderVisitor(FileLocation Location,
  37                          Optional<FileRange> SelectionRange,
  38                          llvm::function_ref<void(SourceRange SelectionRange,
  39                                                  Optional<SelectedASTNode>)>
  40                              Consumer)
  41       : Location(Location), SelectionRange(SelectionRange), Consumer(Consumer) {
  42   }
  43
  44   bool VisitTranslationUnitDecl(const TranslationUnitDecl *TU) {
  45     const ASTContext &Context = TU->getASTContext();
  46     const SourceManager &SM = Context.getSourceManager();
  47
  48     SourceRange SelRange;
  49     if (SelectionRange) {
  50       SelRange = SourceRange(SelectionRange->first.translate(SM),
  51                              SelectionRange->second.translate(SM));
  52     } else {
  53       SourceLocation Loc = Location.translate(SM);
  54       SelRange = SourceRange(Loc, Loc);
  55     }
  56     Consumer(SelRange, findSelectedASTNodes(Context, SelRange));
  57     return false;
  58   }
  59 };
  60
  61 /// This is a test utility function that computes the AST selection at the
  62 /// given location with an optional selection range.
  63 ///
  64 /// A location roughly corresponds to a cursor location in an editor, while
  65 /// the optional range corresponds to the selection range in an editor.
  66 void findSelectedASTNodesWithRange(
  67     StringRef Source, FileLocation Location, Optional<FileRange> SelectionRange,
  68     llvm::function_ref<void(SourceRange SelectionRange,
  69                             Optional<SelectedASTNode>)>
  70         Consumer,
  71     SelectionFinderVisitor::Language Language =
  72         SelectionFinderVisitor::Lang_CXX11) {
  73   SelectionFinderVisitor Visitor(Location, SelectionRange, Consumer);
  74   EXPECT_TRUE(Visitor.runOver(Source, Language));
  75 }
  76
  77 void findSelectedASTNodes(
  78     StringRef Source, FileLocation Location, Optional<FileRange> SelectionRange,
  79     llvm::function_ref<void(Optional<SelectedASTNode>)> Consumer,
  80     SelectionFinderVisitor::Language Language =
  81         SelectionFinderVisitor::Lang_CXX11) {
  82   findSelectedASTNodesWithRange(
  83       Source, Location, SelectionRange,
  84       [&](SourceRange, Optional<SelectedASTNode> Selection) {
  85         Consumer(std::move(Selection));
  86       },
  87       Language);
  88 }
  89
  90 void checkNodeImpl(bool IsTypeMatched, const SelectedASTNode &Node,
  91                    SourceSelectionKind SelectionKind, unsigned NumChildren) {
  92   ASSERT_TRUE(IsTypeMatched);
  93   EXPECT_EQ(Node.Children.size(), NumChildren);
  94   ASSERT_EQ(Node.SelectionKind, SelectionKind);
  95 }
  96
  97 void checkDeclName(const SelectedASTNode &Node, StringRef Name) {
  98   const auto *ND = Node.Node.get<NamedDecl>();
  99   EXPECT_TRUE(!!ND);
 100   ASSERT_EQ(ND->getName(), Name);
 101 }
 102
 103 template <typename T>
 104 const SelectedASTNode &checkNode(
 105     const SelectedASTNode &StmtNode, SourceSelectionKind SelectionKind,
 106     unsigned NumChildren = 0,
 107     std::enable_if_t<std::is_base_of<Stmt, T>::value, T> *StmtOverloadChecker =
 108         nullptr) {
 109   checkNodeImpl(isa<T>(StmtNode.Node.get<Stmt>()), StmtNode, SelectionKind,
 110                 NumChildren);
 111   return StmtNode;
 112 }
 113
 114 template <typename T>
 115 const SelectedASTNode &checkNode(
 116     const SelectedASTNode &DeclNode, SourceSelectionKind SelectionKind,
 117     unsigned NumChildren = 0, StringRef Name = "",
 118     std::enable_if_t<std::is_base_of<Decl, T>::value, T> *DeclOverloadChecker =
 119         nullptr) {
 120   checkNodeImpl(isa<T>(DeclNode.Node.get<Decl>()), DeclNode, SelectionKind,
 121                 NumChildren);
 122   if (!Name.empty())
 123     checkDeclName(DeclNode, Name);
 124   return DeclNode;
 125 }
 126
 127 struct ForAllChildrenOf {
 128   const SelectedASTNode &Node;
 129
 130   static void childKindVerifier(const SelectedASTNode &Node,
 131                                 SourceSelectionKind SelectionKind) {
 132     for (const SelectedASTNode &Child : Node.Children) {
 133       ASSERT_EQ(Node.SelectionKind, SelectionKind);
 134       childKindVerifier(Child, SelectionKind);
 135     }
 136   }
 137
 138 public:
 139   ForAllChildrenOf(const SelectedASTNode &Node) : Node(Node) {}
 140
 141   void shouldHaveSelectionKind(SourceSelectionKind Kind) {
 142     childKindVerifier(Node, Kind);
 143   }
 144 };
 145
 146 ForAllChildrenOf allChildrenOf(const SelectedASTNode &Node) {
 147   return ForAllChildrenOf(Node);
 148 }
 149
 150 TEST(ASTSelectionFinder, CursorNoSelection) {
 151   findSelectedASTNodes(
 152       " void f() { }", {1, 1}, None,
 153       [](Optional<SelectedASTNode> Node) { EXPECT_FALSE(Node); });
 154 }
 155
 156 TEST(ASTSelectionFinder, CursorAtStartOfFunction) {
 157   findSelectedASTNodes(
 158       "void f() { }", {1, 1}, None, [](Optional<SelectedASTNode> Node) {
 159         EXPECT_TRUE(Node);
 160         checkNode<TranslationUnitDecl>(*Node, SourceSelectionKind::None,
 161                                        /*NumChildren=*/1);
 162         checkNode<FunctionDecl>(Node->Children[0],
 163                                 SourceSelectionKind::ContainsSelection,
 164                                 /*NumChildren=*/0, /*Name=*/"f");
 165
 166         // Check that the dumping works.
 167         std::string DumpValue;
 168         llvm::raw_string_ostream OS(DumpValue);
 169         Node->Children[0].dump(OS);
 170         ASSERT_EQ(OS.str(), "FunctionDecl \"f\" contains-selection\n");
 171       });
 172 }
 173
 174 TEST(ASTSelectionFinder, RangeNoSelection) {
 175   findSelectedASTNodes(
 176       " void f() { }", {1, 1}, FileRange{{1, 1}, {1, 1}},
 177       [](Optional<SelectedASTNode> Node) { EXPECT_FALSE(Node); });
 178   findSelectedASTNodes(
 179       "  void f() { }", {1, 1}, FileRange{{1, 1}, {1, 2}},
 180       [](Optional<SelectedASTNode> Node) { EXPECT_FALSE(Node); });
 181 }
 182
 183 TEST(ASTSelectionFinder, EmptyRangeFallbackToCursor) {
 184   findSelectedASTNodes("void f() { }", {1, 1}, FileRange{{1, 1}, {1, 1}},
 185                        [](Optional<SelectedASTNode> Node) {
 186                          EXPECT_TRUE(Node);
 187                          checkNode<FunctionDecl>(
 188                              Node->Children[0],
 189                              SourceSelectionKind::ContainsSelection,
 190                              /*NumChildren=*/0, /*Name=*/"f");
 191                        });
 192 }
 193
 194 TEST(ASTSelectionFinder, WholeFunctionSelection) {
 195   StringRef Source = "int f(int x) { return x;\n}\nvoid f2() { }";
 196   // From 'int' until just after '}':
 197
 198   findSelectedASTNodes(
 199       Source, {1, 1}, FileRange{{1, 1}, {2, 2}},
 200       [](Optional<SelectedASTNode> Node) {
 201         EXPECT_TRUE(Node);
 202         EXPECT_EQ(Node->Children.size(), 1u);
 203         const auto &Fn = checkNode<FunctionDecl>(
 204             Node->Children[0], SourceSelectionKind::ContainsSelection,
 205             /*NumChildren=*/2, /*Name=*/"f");
 206         checkNode<ParmVarDecl>(Fn.Children[0],
 207                                SourceSelectionKind::InsideSelection);
 208         const auto &Body = checkNode<CompoundStmt>(
 209             Fn.Children[1], SourceSelectionKind::InsideSelection,
 210             /*NumChildren=*/1);
 211         const auto &Return = checkNode<ReturnStmt>(
 212             Body.Children[0], SourceSelectionKind::InsideSelection,
 213             /*NumChildren=*/1);
 214         checkNode<ImplicitCastExpr>(Return.Children[0],
 215                                     SourceSelectionKind::InsideSelection,
 216                                     /*NumChildren=*/1);
 217         checkNode<DeclRefExpr>(Return.Children[0].Children[0],
 218                                SourceSelectionKind::InsideSelection);
 219       });
 220
 221   // From 'int' until just before '}':
 222   findSelectedASTNodes(
 223       Source, {2, 1}, FileRange{{1, 1}, {2, 1}},
 224       [](Optional<SelectedASTNode> Node) {
 225         EXPECT_TRUE(Node);
 226         EXPECT_EQ(Node->Children.size(), 1u);
 227         const auto &Fn = checkNode<FunctionDecl>(
 228             Node->Children[0], SourceSelectionKind::ContainsSelection,
 229             /*NumChildren=*/2, /*Name=*/"f");
 230         const auto &Body = checkNode<CompoundStmt>(
 231             Fn.Children[1], SourceSelectionKind::ContainsSelectionEnd,
 232             /*NumChildren=*/1);
 233         checkNode<ReturnStmt>(Body.Children[0],
 234                               SourceSelectionKind::InsideSelection,
 235                               /*NumChildren=*/1);
 236       });
 237   // From '{' until just after '}':
 238   findSelectedASTNodes(
 239       Source, {1, 14}, FileRange{{1, 14}, {2, 2}},
 240       [](Optional<SelectedASTNode> Node) {
 241         EXPECT_TRUE(Node);
 242         EXPECT_EQ(Node->Children.size(), 1u);
 243         const auto &Fn = checkNode<FunctionDecl>(
 244             Node->Children[0], SourceSelectionKind::ContainsSelection,
 245             /*NumChildren=*/1, /*Name=*/"f");
 246         const auto &Body = checkNode<CompoundStmt>(
 247             Fn.Children[0], SourceSelectionKind::ContainsSelection,
 248             /*NumChildren=*/1);
 249         checkNode<ReturnStmt>(Body.Children[0],
 250                               SourceSelectionKind::InsideSelection,
 251                               /*NumChildren=*/1);
 252       });
 253   // From 'x' until just after '}':
 254   findSelectedASTNodes(
 255       Source, {2, 2}, FileRange{{1, 11}, {2, 2}},
 256       [](Optional<SelectedASTNode> Node) {
 257         EXPECT_TRUE(Node);
 258         EXPECT_EQ(Node->Children.size(), 1u);
 259         const auto &Fn = checkNode<FunctionDecl>(
 260             Node->Children[0], SourceSelectionKind::ContainsSelection,
 261             /*NumChildren=*/2, /*Name=*/"f");
 262         checkNode<ParmVarDecl>(Fn.Children[0],
 263                                SourceSelectionKind::ContainsSelectionStart);
 264         const auto &Body = checkNode<CompoundStmt>(
 265             Fn.Children[1], SourceSelectionKind::InsideSelection,
 266             /*NumChildren=*/1);
 267         checkNode<ReturnStmt>(Body.Children[0],
 268                               SourceSelectionKind::InsideSelection,
 269                               /*NumChildren=*/1);
 270       });
 271 }
 272
 273 TEST(ASTSelectionFinder, MultipleFunctionSelection) {
 274   StringRef Source = R"(void f0() {
 275 }
 276 void f1() { }
 277 void f2() { }
 278 void f3() { }
 279 )";
 280   auto SelectedF1F2 = [](Optional<SelectedASTNode> Node) {
 281     EXPECT_TRUE(Node);
 282     EXPECT_EQ(Node->Children.size(), 2u);
 283     checkNode<FunctionDecl>(Node->Children[0],
 284                             SourceSelectionKind::InsideSelection,
 285                             /*NumChildren=*/1, /*Name=*/"f1");
 286     checkNode<FunctionDecl>(Node->Children[1],
 287                             SourceSelectionKind::InsideSelection,
 288                             /*NumChildren=*/1, /*Name=*/"f2");
 289   };
 290   // Just after '}' of f0 and just before 'void' of f3:
 291   findSelectedASTNodes(Source, {2, 2}, FileRange{{2, 2}, {5, 1}}, SelectedF1F2);
 292   // Just before 'void' of f1 and just after '}' of f2:
 293   findSelectedASTNodes(Source, {3, 1}, FileRange{{3, 1}, {4, 14}},
 294                        SelectedF1F2);
 295 }
 296
 297 TEST(ASTSelectionFinder, MultipleStatementSelection) {
 298   StringRef Source = R"(void f(int x, int y) {
 299   int z = x;
 300   f(2, 3);
 301   if (x == 0) {
 302     return;
 303   }
 304   x = 1;
 305   return;
 306 })";
 307   // From 'f(2,3)' until just before 'x = 1;':
 308   findSelectedASTNodes(
 309       Source, {3, 2}, FileRange{{3, 2}, {7, 1}},
 310       [](Optional<SelectedASTNode> Node) {
 311         EXPECT_TRUE(Node);
 312         EXPECT_EQ(Node->Children.size(), 1u);
 313         const auto &Fn = checkNode<FunctionDecl>(
 314             Node->Children[0], SourceSelectionKind::ContainsSelection,
 315             /*NumChildren=*/1, /*Name=*/"f");
 316         const auto &Body = checkNode<CompoundStmt>(
 317             Fn.Children[0], SourceSelectionKind::ContainsSelection,
 318             /*NumChildren=*/2);
 319         allChildrenOf(checkNode<CallExpr>(Body.Children[0],
 320                                           SourceSelectionKind::InsideSelection,
 321                                           /*NumChildren=*/3))
 322             .shouldHaveSelectionKind(SourceSelectionKind::InsideSelection);
 323         allChildrenOf(checkNode<IfStmt>(Body.Children[1],
 324                                         SourceSelectionKind::InsideSelection,
 325                                         /*NumChildren=*/2))
 326             .shouldHaveSelectionKind(SourceSelectionKind::InsideSelection);
 327       });
 328   // From 'f(2,3)' until just before ';' in 'x = 1;':
 329   findSelectedASTNodes(
 330       Source, {3, 2}, FileRange{{3, 2}, {7, 8}},
 331       [](Optional<SelectedASTNode> Node) {
 332         EXPECT_TRUE(Node);
 333         EXPECT_EQ(Node->Children.size(), 1u);
 334         const auto &Fn = checkNode<FunctionDecl>(
 335             Node->Children[0], SourceSelectionKind::ContainsSelection,
 336             /*NumChildren=*/1, /*Name=*/"f");
 337         const auto &Body = checkNode<CompoundStmt>(
 338             Fn.Children[0], SourceSelectionKind::ContainsSelection,
 339             /*NumChildren=*/3);
 340         checkNode<CallExpr>(Body.Children[0],
 341                             SourceSelectionKind::InsideSelection,
 342                             /*NumChildren=*/3);
 343         checkNode<IfStmt>(Body.Children[1],
 344                           SourceSelectionKind::InsideSelection,
 345                           /*NumChildren=*/2);
 346         checkNode<BinaryOperator>(Body.Children[2],
 347                                   SourceSelectionKind::InsideSelection,
 348                                   /*NumChildren=*/2);
 349       });
 350   // From the middle of 'int z = 3' until the middle of 'x = 1;':
 351   findSelectedASTNodes(
 352       Source, {2, 10}, FileRange{{2, 10}, {7, 5}},
 353       [](Optional<SelectedASTNode> Node) {
 354         EXPECT_TRUE(Node);
 355         EXPECT_EQ(Node->Children.size(), 1u);
 356         const auto &Fn = checkNode<FunctionDecl>(
 357             Node->Children[0], SourceSelectionKind::ContainsSelection,
 358             /*NumChildren=*/1, /*Name=*/"f");
 359         const auto &Body = checkNode<CompoundStmt>(
 360             Fn.Children[0], SourceSelectionKind::ContainsSelection,
 361             /*NumChildren=*/4);
 362         checkNode<DeclStmt>(Body.Children[0],
 363                             SourceSelectionKind::ContainsSelectionStart,
 364                             /*NumChildren=*/1);
 365         checkNode<CallExpr>(Body.Children[1],
 366                             SourceSelectionKind::InsideSelection,
 367                             /*NumChildren=*/3);
 368         checkNode<IfStmt>(Body.Children[2],
 369                           SourceSelectionKind::InsideSelection,
 370                           /*NumChildren=*/2);
 371         checkNode<BinaryOperator>(Body.Children[3],
 372                                   SourceSelectionKind::ContainsSelectionEnd,
 373                                   /*NumChildren=*/1);
 374       });
 375 }
 376
 377 TEST(ASTSelectionFinder, SelectionInFunctionInObjCImplementation) {
 378   StringRef Source = R"(
 379 @interface I
 380 @end
 381 @implementation I
 382
 383 int notSelected() { }
 384
 385 int selected(int x) {
 386   return x;
 387 }
 388
 389 @end
 390 @implementation I(Cat)
 391
 392 void catF() { }
 393
 394 @end
 395
 396 void outerFunction() { }
 397 )";
 398   // Just the 'x' expression in 'selected':
 399   findSelectedASTNodes(
 400       Source, {9, 10}, FileRange{{9, 10}, {9, 11}},
 401       [](Optional<SelectedASTNode> Node) {
 402         EXPECT_TRUE(Node);
 403         EXPECT_EQ(Node->Children.size(), 1u);
 404         const auto &Impl = checkNode<ObjCImplementationDecl>(
 405             Node->Children[0], SourceSelectionKind::ContainsSelection,
 406             /*NumChildren=*/1, /*Name=*/"I");
 407         const auto &Fn = checkNode<FunctionDecl>(
 408             Impl.Children[0], SourceSelectionKind::ContainsSelection,
 409             /*NumChildren=*/1, /*Name=*/"selected");
 410         allChildrenOf(Fn).shouldHaveSelectionKind(
 411             SourceSelectionKind::ContainsSelection);
 412       },
 413       SelectionFinderVisitor::Lang_OBJC);
 414   // The entire 'catF':
 415   findSelectedASTNodes(
 416       Source, {15, 1}, FileRange{{15, 1}, {15, 16}},
 417       [](Optional<SelectedASTNode> Node) {
 418         EXPECT_TRUE(Node);
 419         EXPECT_EQ(Node->Children.size(), 1u);
 420         const auto &Impl = checkNode<ObjCCategoryImplDecl>(
 421             Node->Children[0], SourceSelectionKind::ContainsSelection,
 422             /*NumChildren=*/1, /*Name=*/"Cat");
 423         const auto &Fn = checkNode<FunctionDecl>(
 424             Impl.Children[0], SourceSelectionKind::ContainsSelection,
 425             /*NumChildren=*/1, /*Name=*/"catF");
 426         allChildrenOf(Fn).shouldHaveSelectionKind(
 427             SourceSelectionKind::ContainsSelection);
 428       },
 429       SelectionFinderVisitor::Lang_OBJC);
 430   // From the line before 'selected' to the line after 'catF':
 431   findSelectedASTNodes(
 432       Source, {16, 1}, FileRange{{7, 1}, {16, 1}},
 433       [](Optional<SelectedASTNode> Node) {
 434         EXPECT_TRUE(Node);
 435         EXPECT_EQ(Node->Children.size(), 2u);
 436         const auto &Impl = checkNode<ObjCImplementationDecl>(
 437             Node->Children[0], SourceSelectionKind::ContainsSelectionStart,
 438             /*NumChildren=*/1, /*Name=*/"I");
 439         const auto &Selected = checkNode<FunctionDecl>(
 440             Impl.Children[0], SourceSelectionKind::InsideSelection,
 441             /*NumChildren=*/2, /*Name=*/"selected");
 442         allChildrenOf(Selected).shouldHaveSelectionKind(
 443             SourceSelectionKind::InsideSelection);
 444         const auto &Cat = checkNode<ObjCCategoryImplDecl>(
 445             Node->Children[1], SourceSelectionKind::ContainsSelectionEnd,
 446             /*NumChildren=*/1, /*Name=*/"Cat");
 447         const auto &CatF = checkNode<FunctionDecl>(
 448             Cat.Children[0], SourceSelectionKind::InsideSelection,
 449             /*NumChildren=*/1, /*Name=*/"catF");
 450         allChildrenOf(CatF).shouldHaveSelectionKind(
 451             SourceSelectionKind::InsideSelection);
 452       },
 453       SelectionFinderVisitor::Lang_OBJC);
 454   // Just the 'outer' function:
 455   findSelectedASTNodes(Source, {19, 1}, FileRange{{19, 1}, {19, 25}},
 456                        [](Optional<SelectedASTNode> Node) {
 457                          EXPECT_TRUE(Node);
 458                          EXPECT_EQ(Node->Children.size(), 1u);
 459                          checkNode<FunctionDecl>(
 460                              Node->Children[0],
 461                              SourceSelectionKind::ContainsSelection,
 462                              /*NumChildren=*/1, /*Name=*/"outerFunction");
 463                        },
 464                        SelectionFinderVisitor::Lang_OBJC);
 465 }
 466
 467 TEST(ASTSelectionFinder, FunctionInObjCImplementationCarefulWithEarlyExit) {
 468   StringRef Source = R"(
 469 @interface I
 470 @end
 471 @implementation I
 472
 473 void selected() {
 474 }
 475
 476 - (void) method { }
 477
 478 @end
 479 )";
 480   // Just 'selected'
 481   findSelectedASTNodes(
 482       Source, {6, 1}, FileRange{{6, 1}, {7, 2}},
 483       [](Optional<SelectedASTNode> Node) {
 484         EXPECT_TRUE(Node);
 485         EXPECT_EQ(Node->Children.size(), 1u);
 486         const auto &Impl = checkNode<ObjCImplementationDecl>(
 487             Node->Children[0], SourceSelectionKind::ContainsSelection,
 488             /*NumChildren=*/1, /*Name=*/"I");
 489         checkNode<FunctionDecl>(Impl.Children[0],
 490                                 SourceSelectionKind::ContainsSelection,
 491                                 /*NumChildren=*/1, /*Name=*/"selected");
 492       },
 493       SelectionFinderVisitor::Lang_OBJC);
 494 }
 495
 496 TEST(ASTSelectionFinder, AvoidImplicitDeclarations) {
 497   StringRef Source = R"(
 498 struct Copy {
 499   int x;
 500 };
 501 void foo() {
 502   Copy x;
 503   Copy y = x;
 504 }
 505 )";
 506   // The entire struct 'Copy':
 507   findSelectedASTNodes(
 508       Source, {2, 1}, FileRange{{2, 1}, {4, 3}},
 509       [](Optional<SelectedASTNode> Node) {
 510         EXPECT_TRUE(Node);
 511         EXPECT_EQ(Node->Children.size(), 1u);
 512         const auto &Record = checkNode<CXXRecordDecl>(
 513             Node->Children[0], SourceSelectionKind::InsideSelection,
 514             /*NumChildren=*/1, /*Name=*/"Copy");
 515         checkNode<FieldDecl>(Record.Children[0],
 516                              SourceSelectionKind::InsideSelection);
 517       });
 518 }
 519
 520 TEST(ASTSelectionFinder, CorrectEndForObjectiveCImplementation) {
 521   StringRef Source = R"(
 522 @interface I
 523 @end
 524 @implementation I
 525 @ end
 526 )";
 527   // Just after '@ end'
 528   findSelectedASTNodes(Source, {5, 6}, None,
 529                        [](Optional<SelectedASTNode> Node) {
 530                          EXPECT_TRUE(Node);
 531                          EXPECT_EQ(Node->Children.size(), 1u);
 532                          checkNode<ObjCImplementationDecl>(
 533                              Node->Children[0],
 534                              SourceSelectionKind::ContainsSelection);
 535                        },
 536                        SelectionFinderVisitor::Lang_OBJC);
 537 }
 538
 539 const SelectedASTNode &checkFnBody(const Optional<SelectedASTNode> &Node,
 540                                    StringRef Name) {
 541   EXPECT_TRUE(Node);
 542   EXPECT_EQ(Node->Children.size(), 1u);
 543   const auto &Fn = checkNode<FunctionDecl>(
 544       Node->Children[0], SourceSelectionKind::ContainsSelection,
 545       /*NumChildren=*/1, Name);
 546   return checkNode<CompoundStmt>(Fn.Children[0],
 547                                  SourceSelectionKind::ContainsSelection,
 548                                  /*NumChildren=*/1);
 549 }
 550
 551 TEST(ASTSelectionFinder, SelectObjectiveCPseudoObjectExprs) {
 552   StringRef Source = R"(
 553 @interface I
 554 @property(readwrite) int prop;
 555 @end
 556 void selectProp(I *i) {
 557 (void)i.prop;
 558 i.prop = 21;
 559 }
 560
 561
 562 @interface NSMutableArray
 563 - (id)objectAtIndexedSubscript:(unsigned int)index;
 564 - (void)setObject:(id)object atIndexedSubscript:(unsigned int)index;
 565 @end
 566
 567 void selectSubscript(NSMutableArray *array, I *i) {
 568   (void)array[10];
 569   array[i.prop] = i;
 570 }
 571 )";
 572   // Just 'i.prop'.
 573   findSelectedASTNodes(
 574       Source, {6, 7}, FileRange{{6, 7}, {6, 13}},
 575       [](Optional<SelectedASTNode> Node) {
 576         const auto &CS = checkFnBody(Node, /*Name=*/"selectProp");
 577         const auto &CCast = checkNode<CStyleCastExpr>(
 578             CS.Children[0], SourceSelectionKind::ContainsSelection,
 579             /*NumChildren=*/1);
 580         const auto &POE = checkNode<PseudoObjectExpr>(
 581             CCast.Children[0], SourceSelectionKind::ContainsSelection,
 582             /*NumChildren=*/1);
 583         const auto &PRE = checkNode<ObjCPropertyRefExpr>(
 584             POE.Children[0], SourceSelectionKind::ContainsSelection,
 585             /*NumChildren=*/1);
 586         const auto &Cast = checkNode<ImplicitCastExpr>(
 587             PRE.Children[0], SourceSelectionKind::InsideSelection,
 588             /*NumChildren=*/1);
 589         checkNode<DeclRefExpr>(Cast.Children[0],
 590                                SourceSelectionKind::InsideSelection);
 591       },
 592       SelectionFinderVisitor::Lang_OBJC);
 593   // Just 'i.prop = 21'
 594   findSelectedASTNodes(
 595       Source, {7, 1}, FileRange{{7, 1}, {7, 12}},
 596       [](Optional<SelectedASTNode> Node) {
 597         const auto &CS = checkFnBody(Node, /*Name=*/"selectProp");
 598         const auto &POE = checkNode<PseudoObjectExpr>(
 599             CS.Children[0], SourceSelectionKind::ContainsSelection,
 600             /*NumChildren=*/1);
 601         const auto &BinOp = checkNode<BinaryOperator>(
 602             POE.Children[0], SourceSelectionKind::ContainsSelection,
 603             /*NumChildren=*/2);
 604         const auto &PRE = checkNode<ObjCPropertyRefExpr>(
 605             BinOp.Children[0], SourceSelectionKind::InsideSelection,
 606             /*NumChildren=*/1);
 607         const auto &Cast = checkNode<ImplicitCastExpr>(
 608             PRE.Children[0], SourceSelectionKind::InsideSelection,
 609             /*NumChildren=*/1);
 610         checkNode<DeclRefExpr>(Cast.Children[0],
 611                                SourceSelectionKind::InsideSelection);
 612         checkNode<IntegerLiteral>(BinOp.Children[1],
 613                                   SourceSelectionKind::InsideSelection);
 614       },
 615       SelectionFinderVisitor::Lang_OBJC);
 616   // Just 'array[10]'
 617   findSelectedASTNodes(
 618       Source, {17, 9}, FileRange{{17, 9}, {17, 18}},
 619       [](Optional<SelectedASTNode> Node) {
 620         const auto &CS = checkFnBody(Node, /*Name=*/"selectSubscript");
 621         const auto &CCast = checkNode<CStyleCastExpr>(
 622             CS.Children[0], SourceSelectionKind::ContainsSelection,
 623             /*NumChildren=*/1);
 624         const auto &POE = checkNode<PseudoObjectExpr>(
 625             CCast.Children[0], SourceSelectionKind::ContainsSelection,
 626             /*NumChildren=*/1);
 627         const auto &SRE = checkNode<ObjCSubscriptRefExpr>(
 628             POE.Children[0], SourceSelectionKind::ContainsSelection,
 629             /*NumChildren=*/2);
 630         const auto &Cast = checkNode<ImplicitCastExpr>(
 631             SRE.Children[0], SourceSelectionKind::InsideSelection,
 632             /*NumChildren=*/1);
 633         checkNode<DeclRefExpr>(Cast.Children[0],
 634                                SourceSelectionKind::InsideSelection);
 635         checkNode<IntegerLiteral>(SRE.Children[1],
 636                                   SourceSelectionKind::InsideSelection);
 637       },
 638       SelectionFinderVisitor::Lang_OBJC);
 639   // Just 'array[i.prop] = array'
 640   findSelectedASTNodes(
 641       Source, {18, 3}, FileRange{{18, 3}, {18, 20}},
 642       [](Optional<SelectedASTNode> Node) {
 643         const auto &CS = checkFnBody(Node, /*Name=*/"selectSubscript");
 644         const auto &POE = checkNode<PseudoObjectExpr>(
 645             CS.Children[0], SourceSelectionKind::ContainsSelection,
 646             /*NumChildren=*/1);
 647         const auto &BinOp = checkNode<BinaryOperator>(
 648             POE.Children[0], SourceSelectionKind::ContainsSelection,
 649             /*NumChildren=*/2);
 650         const auto &SRE = checkNode<ObjCSubscriptRefExpr>(
 651             BinOp.Children[0], SourceSelectionKind::InsideSelection,
 652             /*NumChildren=*/2);
 653         const auto &Cast = checkNode<ImplicitCastExpr>(
 654             SRE.Children[0], SourceSelectionKind::InsideSelection,
 655             /*NumChildren=*/1);
 656         checkNode<DeclRefExpr>(Cast.Children[0],
 657                                SourceSelectionKind::InsideSelection);
 658         const auto &POE2 = checkNode<PseudoObjectExpr>(
 659             SRE.Children[1], SourceSelectionKind::InsideSelection,
 660             /*NumChildren=*/1);
 661         const auto &PRE = checkNode<ObjCPropertyRefExpr>(
 662             POE2.Children[0], SourceSelectionKind::InsideSelection,
 663             /*NumChildren=*/1);
 664         const auto &Cast2 = checkNode<ImplicitCastExpr>(
 665             PRE.Children[0], SourceSelectionKind::InsideSelection,
 666             /*NumChildren=*/1);
 667         checkNode<DeclRefExpr>(Cast2.Children[0],
 668                                SourceSelectionKind::InsideSelection);
 669         checkNode<DeclRefExpr>(BinOp.Children[1],
 670                                SourceSelectionKind::InsideSelection);
 671       },
 672       SelectionFinderVisitor::Lang_OBJC);
 673 }
 674
 675 TEST(ASTSelectionFinder, SimpleCodeRangeASTSelection) {
 676   StringRef Source = R"(void f(int x, int y) {
 677   int z = x;
 678   f(2, 3);
 679   if (x == 0) {
 680     return;
 681   }
 682   x = 1;
 683   return;
 684 }
 685 void f2() {
 686   int m = 0;
 687 }
 688 )";
 689   // No selection range.
 690   findSelectedASTNodesWithRange(
 691       Source, {2, 2}, None,
 692       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 693         EXPECT_TRUE(Node);
 694         Optional<CodeRangeASTSelection> SelectedCode =
 695             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 696         EXPECT_FALSE(SelectedCode);
 697       });
 698   findSelectedASTNodesWithRange(
 699       Source, {2, 2}, FileRange{{2, 2}, {2, 2}},
 700       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 701         EXPECT_TRUE(Node);
 702         Optional<CodeRangeASTSelection> SelectedCode =
 703             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 704         EXPECT_FALSE(SelectedCode);
 705       });
 706   // Range that spans multiple functions is an invalid code range.
 707   findSelectedASTNodesWithRange(
 708       Source, {2, 2}, FileRange{{7, 2}, {12, 1}},
 709       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 710         EXPECT_TRUE(Node);
 711         Optional<CodeRangeASTSelection> SelectedCode =
 712             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 713         EXPECT_FALSE(SelectedCode);
 714       });
 715   // Just 'z = x;':
 716   findSelectedASTNodesWithRange(
 717       Source, {2, 2}, FileRange{{2, 2}, {2, 13}},
 718       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 719         EXPECT_TRUE(Node);
 720         Optional<CodeRangeASTSelection> SelectedCode =
 721             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 722         EXPECT_TRUE(SelectedCode);
 723         EXPECT_EQ(SelectedCode->size(), 1u);
 724         EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
 725         ArrayRef<SelectedASTNode::ReferenceType> Parents =
 726             SelectedCode->getParents();
 727         EXPECT_EQ(Parents.size(), 3u);
 728         EXPECT_TRUE(
 729             isa<TranslationUnitDecl>(Parents[0].get().Node.get<Decl>()));
 730         // Function 'f' definition.
 731         EXPECT_TRUE(isa<FunctionDecl>(Parents[1].get().Node.get<Decl>()));
 732         // Function body of function 'F'.
 733         EXPECT_TRUE(isa<CompoundStmt>(Parents[2].get().Node.get<Stmt>()));
 734       });
 735   // From 'f(2,3)' until just before 'x = 1;':
 736   findSelectedASTNodesWithRange(
 737       Source, {3, 2}, FileRange{{3, 2}, {7, 1}},
 738       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 739         EXPECT_TRUE(Node);
 740         Optional<CodeRangeASTSelection> SelectedCode =
 741             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 742         EXPECT_TRUE(SelectedCode);
 743         EXPECT_EQ(SelectedCode->size(), 2u);
 744         EXPECT_TRUE(isa<CallExpr>((*SelectedCode)[0]));
 745         EXPECT_TRUE(isa<IfStmt>((*SelectedCode)[1]));
 746         ArrayRef<SelectedASTNode::ReferenceType> Parents =
 747             SelectedCode->getParents();
 748         EXPECT_EQ(Parents.size(), 3u);
 749         EXPECT_TRUE(
 750             isa<TranslationUnitDecl>(Parents[0].get().Node.get<Decl>()));
 751         // Function 'f' definition.
 752         EXPECT_TRUE(isa<FunctionDecl>(Parents[1].get().Node.get<Decl>()));
 753         // Function body of function 'F'.
 754         EXPECT_TRUE(isa<CompoundStmt>(Parents[2].get().Node.get<Stmt>()));
 755       });
 756   // From 'f(2,3)' until just before ';' in 'x = 1;':
 757   findSelectedASTNodesWithRange(
 758       Source, {3, 2}, FileRange{{3, 2}, {7, 8}},
 759       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 760         EXPECT_TRUE(Node);
 761         Optional<CodeRangeASTSelection> SelectedCode =
 762             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 763         EXPECT_TRUE(SelectedCode);
 764         EXPECT_EQ(SelectedCode->size(), 3u);
 765         EXPECT_TRUE(isa<CallExpr>((*SelectedCode)[0]));
 766         EXPECT_TRUE(isa<IfStmt>((*SelectedCode)[1]));
 767         EXPECT_TRUE(isa<BinaryOperator>((*SelectedCode)[2]));
 768       });
 769   // From the middle of 'int z = 3' until the middle of 'x = 1;':
 770   findSelectedASTNodesWithRange(
 771       Source, {2, 10}, FileRange{{2, 10}, {7, 5}},
 772       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 773         EXPECT_TRUE(Node);
 774         EXPECT_TRUE(Node);
 775         Optional<CodeRangeASTSelection> SelectedCode =
 776             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 777         EXPECT_TRUE(SelectedCode);
 778         EXPECT_EQ(SelectedCode->size(), 4u);
 779         EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
 780         EXPECT_TRUE(isa<CallExpr>((*SelectedCode)[1]));
 781         EXPECT_TRUE(isa<IfStmt>((*SelectedCode)[2]));
 782         EXPECT_TRUE(isa<BinaryOperator>((*SelectedCode)[3]));
 783       });
 784 }
 785
 786 TEST(ASTSelectionFinder, OutOfBodyCodeRange) {
 787   StringRef Source = R"(
 788 int codeRange = 2 + 3;
 789 )";
 790   // '2+3' expression.
 791   findSelectedASTNodesWithRange(
 792       Source, {2, 17}, FileRange{{2, 17}, {2, 22}},
 793       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 794         EXPECT_TRUE(Node);
 795         Optional<CodeRangeASTSelection> SelectedCode =
 796             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 797         EXPECT_TRUE(SelectedCode);
 798         EXPECT_EQ(SelectedCode->size(), 1u);
 799         EXPECT_TRUE(isa<BinaryOperator>((*SelectedCode)[0]));
 800         ArrayRef<SelectedASTNode::ReferenceType> Parents =
 801             SelectedCode->getParents();
 802         EXPECT_EQ(Parents.size(), 2u);
 803         EXPECT_TRUE(
 804             isa<TranslationUnitDecl>(Parents[0].get().Node.get<Decl>()));
 805         // Variable 'codeRange'.
 806         EXPECT_TRUE(isa<VarDecl>(Parents[1].get().Node.get<Decl>()));
 807       });
 808 }
 809
 810 TEST(ASTSelectionFinder, SelectVarDeclStmt) {
 811   StringRef Source = R"(
 812 void f() {
 813    {
 814        int a;
 815    }
 816 }
 817 )";
 818   // 'int a'
 819   findSelectedASTNodesWithRange(
 820       Source, {4, 8}, FileRange{{4, 8}, {4, 14}},
 821       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 822         EXPECT_TRUE(Node);
 823         Optional<CodeRangeASTSelection> SelectedCode =
 824             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 825         EXPECT_TRUE(SelectedCode);
 826         EXPECT_EQ(SelectedCode->size(), 1u);
 827         EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
 828         ArrayRef<SelectedASTNode::ReferenceType> Parents =
 829             SelectedCode->getParents();
 830         EXPECT_EQ(Parents.size(), 4u);
 831         EXPECT_TRUE(
 832             isa<TranslationUnitDecl>(Parents[0].get().Node.get<Decl>()));
 833         // Function 'f' definition.
 834         EXPECT_TRUE(isa<FunctionDecl>(Parents[1].get().Node.get<Decl>()));
 835         // Function body of function 'F'.
 836         EXPECT_TRUE(isa<CompoundStmt>(Parents[2].get().Node.get<Stmt>()));
 837         // Compound statement in body of 'F'.
 838         EXPECT_TRUE(isa<CompoundStmt>(Parents[3].get().Node.get<Stmt>()));
 839       });
 840 }
 841
 842 TEST(ASTSelectionFinder, SelectEntireDeclStmtRange) {
 843   StringRef Source = R"(
 844 void f(int x, int y) {
 845    int a = x * y;
 846 }
 847 )";
 848   // 'int a = x * y'
 849   findSelectedASTNodesWithRange(
 850       Source, {3, 4}, FileRange{{3, 4}, {3, 17}},
 851       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 852         EXPECT_TRUE(Node);
 853         Optional<CodeRangeASTSelection> SelectedCode =
 854             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 855         EXPECT_TRUE(SelectedCode);
 856         EXPECT_EQ(SelectedCode->size(), 1u);
 857         EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
 858         ArrayRef<SelectedASTNode::ReferenceType> Parents =
 859             SelectedCode->getParents();
 860         EXPECT_EQ(Parents.size(), 3u);
 861         EXPECT_TRUE(
 862             isa<TranslationUnitDecl>(Parents[0].get().Node.get<Decl>()));
 863         // Function 'f' definition.
 864         EXPECT_TRUE(isa<FunctionDecl>(Parents[1].get().Node.get<Decl>()));
 865         // Function body of function 'F'.
 866         EXPECT_TRUE(isa<CompoundStmt>(Parents[2].get().Node.get<Stmt>()));
 867       });
 868 }
 869
 870 TEST(ASTSelectionFinder, SelectEntireDeclStmtRangeWithMultipleDecls) {
 871   StringRef Source = R"(
 872 void f(int x, int y) {
 873    int a = x * y, b = x - y;
 874 }
 875 )";
 876   // 'b = x - y'
 877   findSelectedASTNodesWithRange(
 878       Source, {3, 19}, FileRange{{3, 19}, {3, 28}},
 879       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 880         EXPECT_TRUE(Node);
 881         Optional<CodeRangeASTSelection> SelectedCode =
 882             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 883         EXPECT_TRUE(SelectedCode);
 884         EXPECT_EQ(SelectedCode->size(), 1u);
 885         EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
 886         ArrayRef<SelectedASTNode::ReferenceType> Parents =
 887             SelectedCode->getParents();
 888         EXPECT_EQ(Parents.size(), 3u);
 889         EXPECT_TRUE(
 890             isa<TranslationUnitDecl>(Parents[0].get().Node.get<Decl>()));
 891         // Function 'f' definition.
 892         EXPECT_TRUE(isa<FunctionDecl>(Parents[1].get().Node.get<Decl>()));
 893         // Function body of function 'F'.
 894         EXPECT_TRUE(isa<CompoundStmt>(Parents[2].get().Node.get<Stmt>()));
 895       });
 896 }
 897
 898 TEST(ASTSelectionFinder, SimpleCodeRangeASTSelectionInObjCMethod) {
 899   StringRef Source = R"(@interface I @end
 900 @implementation I
 901 - (void) f:(int)x with:(int) y {
 902   int z = x;
 903   [self f: 2 with: 3];
 904   if (x == 0) {
 905     return;
 906   }
 907   x = 1;
 908   return;
 909 }
 910 - (void)f2 {
 911   int m = 0;
 912 }
 913 @end
 914 )";
 915   // Range that spans multiple methods is an invalid code range.
 916   findSelectedASTNodesWithRange(
 917       Source, {9, 2}, FileRange{{9, 2}, {13, 1}},
 918       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 919         EXPECT_TRUE(Node);
 920         Optional<CodeRangeASTSelection> SelectedCode =
 921             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 922         EXPECT_FALSE(SelectedCode);
 923       },
 924       SelectionFinderVisitor::Lang_OBJC);
 925   // Just 'z = x;':
 926   findSelectedASTNodesWithRange(
 927       Source, {4, 2}, FileRange{{4, 2}, {4, 13}},
 928       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 929         EXPECT_TRUE(Node);
 930         Optional<CodeRangeASTSelection> SelectedCode =
 931             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 932         EXPECT_TRUE(SelectedCode);
 933         EXPECT_EQ(SelectedCode->size(), 1u);
 934         EXPECT_TRUE(isa<DeclStmt>((*SelectedCode)[0]));
 935         ArrayRef<SelectedASTNode::ReferenceType> Parents =
 936             SelectedCode->getParents();
 937         EXPECT_EQ(Parents.size(), 4u);
 938         EXPECT_TRUE(
 939             isa<TranslationUnitDecl>(Parents[0].get().Node.get<Decl>()));
 940         // 'I' @implementation.
 941         EXPECT_TRUE(isa<ObjCImplDecl>(Parents[1].get().Node.get<Decl>()));
 942         // Function 'f' definition.
 943         EXPECT_TRUE(isa<ObjCMethodDecl>(Parents[2].get().Node.get<Decl>()));
 944         // Function body of function 'F'.
 945         EXPECT_TRUE(isa<CompoundStmt>(Parents[3].get().Node.get<Stmt>()));
 946       },
 947       SelectionFinderVisitor::Lang_OBJC);
 948   // From '[self f: 2 with: 3]' until just before 'x = 1;':
 949   findSelectedASTNodesWithRange(
 950       Source, {5, 2}, FileRange{{5, 2}, {9, 1}},
 951       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 952         EXPECT_TRUE(Node);
 953         Optional<CodeRangeASTSelection> SelectedCode =
 954             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 955         EXPECT_TRUE(SelectedCode);
 956         EXPECT_EQ(SelectedCode->size(), 2u);
 957         EXPECT_TRUE(isa<ObjCMessageExpr>((*SelectedCode)[0]));
 958         EXPECT_TRUE(isa<IfStmt>((*SelectedCode)[1]));
 959         ArrayRef<SelectedASTNode::ReferenceType> Parents =
 960             SelectedCode->getParents();
 961         EXPECT_EQ(Parents.size(), 4u);
 962         EXPECT_TRUE(
 963             isa<TranslationUnitDecl>(Parents[0].get().Node.get<Decl>()));
 964         // 'I' @implementation.
 965         EXPECT_TRUE(isa<ObjCImplDecl>(Parents[1].get().Node.get<Decl>()));
 966         // Function 'f' definition.
 967         EXPECT_TRUE(isa<ObjCMethodDecl>(Parents[2].get().Node.get<Decl>()));
 968         // Function body of function 'F'.
 969         EXPECT_TRUE(isa<CompoundStmt>(Parents[3].get().Node.get<Stmt>()));
 970       },
 971       SelectionFinderVisitor::Lang_OBJC);
 972 }
 973
 974 TEST(ASTSelectionFinder, CanonicalizeObjCStringLiteral) {
 975   StringRef Source = R"(
 976 void foo() {
 977   (void)@"test";
 978 }
 979       )";
 980   // Just '"test"':
 981   findSelectedASTNodesWithRange(
 982       Source, {3, 10}, FileRange{{3, 10}, {3, 16}},
 983       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 984         EXPECT_TRUE(Node);
 985         Optional<CodeRangeASTSelection> SelectedCode =
 986             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 987         EXPECT_TRUE(SelectedCode);
 988         EXPECT_EQ(SelectedCode->size(), 1u);
 989         EXPECT_TRUE(isa<ObjCStringLiteral>((*SelectedCode)[0]));
 990       },
 991       SelectionFinderVisitor::Lang_OBJC);
 992   // Just 'test':
 993   findSelectedASTNodesWithRange(
 994       Source, {3, 11}, FileRange{{3, 11}, {3, 15}},
 995       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
 996         EXPECT_TRUE(Node);
 997         Optional<CodeRangeASTSelection> SelectedCode =
 998             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
 999         EXPECT_TRUE(SelectedCode);
1000         EXPECT_EQ(SelectedCode->size(), 1u);
1001         EXPECT_TRUE(isa<ObjCStringLiteral>((*SelectedCode)[0]));
1002       },
1003       SelectionFinderVisitor::Lang_OBJC);
1004 }
1005
1006 TEST(ASTSelectionFinder, CanonicalizeMemberCalleeToCall) {
1007   StringRef Source = R"(
1008 class AClass { public:
1009   void method();
1010   int afield;
1011   void selectWholeCallWhenJustMethodSelected(int &i) {
1012     method();
1013   }
1014 };
1015 void selectWholeCallWhenJustMethodSelected() {
1016   AClass a;
1017   a.method();
1018 }
1019 void dontSelectArgument(AClass &a) {
1020   a.selectWholeCallWhenJustMethodSelected(a.afield);
1021 }
1022      )";
1023   // Just 'method' with implicit 'this':
1024   findSelectedASTNodesWithRange(
1025       Source, {6, 5}, FileRange{{6, 5}, {6, 11}},
1026       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
1027         EXPECT_TRUE(Node);
1028         Optional<CodeRangeASTSelection> SelectedCode =
1029             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
1030         EXPECT_TRUE(SelectedCode);
1031         EXPECT_EQ(SelectedCode->size(), 1u);
1032         EXPECT_TRUE(isa<CXXMemberCallExpr>((*SelectedCode)[0]));
1033       });
1034   // Just 'method':
1035   findSelectedASTNodesWithRange(
1036       Source, {11, 5}, FileRange{{11, 5}, {11, 11}},
1037       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
1038         EXPECT_TRUE(Node);
1039         Optional<CodeRangeASTSelection> SelectedCode =
1040             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
1041         EXPECT_TRUE(SelectedCode);
1042         EXPECT_EQ(SelectedCode->size(), 1u);
1043         EXPECT_TRUE(isa<CXXMemberCallExpr>((*SelectedCode)[0]));
1044       });
1045   // Just 'afield', which should not select the call.
1046   findSelectedASTNodesWithRange(
1047       Source, {14, 5}, FileRange{{14, 45}, {14, 51}},
1048       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
1049         EXPECT_TRUE(Node);
1050         Optional<CodeRangeASTSelection> SelectedCode =
1051             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
1052         EXPECT_TRUE(SelectedCode);
1053         EXPECT_EQ(SelectedCode->size(), 1u);
1054         EXPECT_FALSE(isa<CXXMemberCallExpr>((*SelectedCode)[0]));
1055       });
1056 }
1057
1058 TEST(ASTSelectionFinder, CanonicalizeFuncCalleeToCall) {
1059   StringRef Source = R"(
1060 void function();
1061
1062 void test() {
1063   function();
1064 }
1065      )";
1066   // Just 'function':
1067   findSelectedASTNodesWithRange(
1068       Source, {5, 3}, FileRange{{5, 3}, {5, 11}},
1069       [](SourceRange SelectionRange, Optional<SelectedASTNode> Node) {
1070         EXPECT_TRUE(Node);
1071         Node->dump();
1072         Optional<CodeRangeASTSelection> SelectedCode =
1073             CodeRangeASTSelection::create(SelectionRange, std::move(*Node));
1074         EXPECT_TRUE(SelectedCode);
1075         EXPECT_EQ(SelectedCode->size(), 1u);
1076         EXPECT_TRUE(isa<CallExpr>((*SelectedCode)[0]));
1077         EXPECT_TRUE(isa<CompoundStmt>(
1078             SelectedCode->getParents()[SelectedCode->getParents().size() - 1]
1079                 .get()
1080                 .Node.get<Stmt>()));
1081       });
1082 }
1083
1084 } // end anonymous namespace