[clangd][WIP] Remove the earlySourceRange hack in SelectionTree.

[hokein]

Summary

This is an attempt to remove the existing earlySourceRange hack in favor
of the claimed range concept.

Not sure it is worth doing it, existing tests are passed except there is
one small regression about ConstructExpr.

clang-tools-extra/clangd/Selection.cpp

#endif
   bool shouldSkipChildren(const Stmt *X) const {
     // UserDefinedLiteral (e.g. 12_i) has two children (12 and _i).
     // Unfortunately TokenBuffer sees 12_i as one token and can't split it.
     // So we treat UserDefinedLiteral as a leaf node, owning the token.
     return llvm::isa<UserDefinedLiteral>(X);
   }
 
   // Pushes a node onto the ancestor stack. Pairs with pop().
-  // Performs early hit detection for some nodes (on the earlySourceRange).
   void push(DynTypedNode Node) {
-    SourceRange Early = earlySourceRange(Node);
     dlog("{1}push: {0}", printNodeToString(Node, PrintPolicy), indent());
     Nodes.emplace_back();
     Nodes.back().ASTNode = std::move(Node);
     Nodes.back().Parent = Stack.top();
     Nodes.back().Selected = NoTokens;
     Stack.push(&Nodes.back());
-    claimRange(Early, Nodes.back().Selected);
   }
 
   // Pops a node off the ancestor stack, and finalizes it. Pairs with push().
   // Performs primary hit detection.
   void pop() {
     Node &N = *Stack.top();
     dlog("{1}pop: {0}", printNodeToString(N.ASTNode, PrintPolicy), indent(-1));
     claimTokensFor(N.ASTNode, N.Selected);
     if (N.Selected == NoTokens)
       N.Selected = SelectionTree::Unselected;
     if (N.Selected || !N.Children.empty()) {
       // Attach to the tree.
       N.Parent->Children.push_back(&N);
     } else {
       // Neither N any children are selected, it doesn't belong in the tree.
       assert(&N == &Nodes.back());
       Nodes.pop_back();
     }
     Stack.pop();
   }
 
-  // Returns the range of tokens that this node will claim directly, and
-  // is not available to the node's children.
-  // Usually empty, but sometimes children cover tokens but shouldn't own them.
-  SourceRange earlySourceRange(const DynTypedNode &N) {
-    if (const Decl *D = N.get<Decl>()) {
-      // We want constructor name to be claimed by TypeLoc not the constructor
-      // itself. Similar for deduction guides, we rather want to select the
-      // underlying TypeLoc.
-      // FIXME: Unfortunately this doesn't work, even though RecursiveASTVisitor
-      // traverses the underlying TypeLoc inside DeclarationName, it is null for
-      // constructors.
-      if (isa<CXXConstructorDecl>(D) || isa<CXXDeductionGuideDecl>(D))
-        return SourceRange();
-      // This will capture Field, Function, MSProperty, NonTypeTemplateParm and
-      // VarDecls. We want the name in the declarator to be claimed by the decl
-      // and not by any children. For example:
-      // void [[foo]]();
-      // int (*[[s]])();
-      // struct X { int [[hash]] [32]; [[operator]] int();}
-      if (const auto *DD = llvm::dyn_cast<DeclaratorDecl>(D))
-        return DD->getLocation();
-    } else if (const auto *CCI = N.get<CXXCtorInitializer>()) {
-      // : [[b_]](42)
-      return CCI->getMemberLocation();
-    }
-    return SourceRange();
-  }
-
   // Claim tokens for N, after processing its children.
   // By default this claims all unclaimed tokens in getSourceRange().
   // We override this if we want to claim fewer tokens (e.g. there are gaps).
   void claimTokensFor(const DynTypedNode &N, SelectionTree::Selection &Result) {
     if (const auto *TL = N.get<TypeLoc>()) {
       // We need the DecltypeTypeLoc hack in getSourceRange.
       if (TL->getAs<DecltypeTypeLoc>())
         return claimRange(getSourceRange(N), Result);
if (const auto *TL = N.get<TypeLoc>()) {
         PTL.getLocalSourceRange().dump(SM);
         // Only claim the parentheses tokens, other tokens are handled by its
         // children or are expected unclaimed.
         claimRange(PTL.getLParenLoc(), Result);
         claimRange(PTL.getRParenLoc(), Result);
         return;
       }
 
+      // getLocalSourceRange is the parens range for most FunctionProtoTypeLocs,
+      // but not true for a trailing-return-type function.
+      //
+      // auto foo() -> int {}
+      //         XX   <- range we want to claim
+      // XXXXXXXXXXX  <- getLocalSourceRange
+      if (auto A = TL->getAs<FunctionProtoTypeLoc>())
+        return claimRange(A.getParensRange(), Result);
+
       // We use LocalSourceRange as a default claimed range for TypeLocs -- it
       // is better than getSourceRange (which returns a range covering itself
       // and its children), because we want to claim fewer tokens (multiple
       // discontiguous ranges) for some TypeLocs.
       // E.g. EltType Foo[OuterSize][InnerSize];
       //      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ArrayTypeLoc (Outer)
       //      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |-ArrayTypeLoc (Inner)
       //      ~~~~~~~                           | |-RecordType
       //                             ~~~~~~~~~  | `-Expr (InnerSize)
       //                  ~~~~~~~~~             `-Expr (OuterSize)
       // Inner ATL must not claim its whole SourceRange, or it clobbers Outer.
       return claimRange(TL->getLocalSourceRange(), Result);
     }
+    if (const auto *CCE = N.get<CXXConstructExpr>())
+      return claimRange(CCE->getParenOrBraceRange(), Result);
+    // Don't claim any tokens for ExprWithCleanups.
+    if (const auto *CCE = N.get<ExprWithCleanups>())
+      return;
     claimRange(getSourceRange(N), Result);
   }
 
   // Perform hit-testing of a complete Node against the selection.
   // This runs for every node in the AST, and must be fast in common cases.
   // This is usually called from pop(), so we can take children into account.
   // The existing state of Result is relevant (early/late claims can interact).
   void claimRange(SourceRange S, SelectionTree::Selection &Result) {

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

Case Cases[] = {
             #endif
             }
           )cpp",
           nullptr,
       },
       {
           R"cpp(
             struct S { S(const char*); };
-            S [[s ^= "foo"]];
+            [[S s ^= "foo"]];
           )cpp",
-          "CXXConstructExpr",
+          "VarDecl",
       },
       {
           R"cpp(
             struct S { S(const char*); };
             [[S ^s = "foo"]];
           )cpp",
           "VarDecl",
       },