[clangd] Fix selection on multi-dimensional array.

[sammccall]

Summary

This involves separating out the concepts of "which tokens should we
descend into this node for" vs "which tokens should this node claim".

While here, move decltype() hack into a more appropriate place.

based on D116218

[sammccall]

cleaner, comments

clang-tools-extra/clangd/Selection.cpp

SourceRange getSourceRange(const DynTypedNode &N) {
   // so we reduce its range to match the CXXConstructExpr.
   // (It's not clear that changing the clang AST would be correct in general).
   if (const auto *ME = N.get<MemberExpr>()) {
     if (!ME->getMemberDecl()->getDeclName())
       return ME->getBase()
                  ? getSourceRange(DynTypedNode::create(*ME->getBase()))
                  : SourceRange();
   }
+  if (const auto *TL = N.get<TypeLoc>()) {
+    if (const auto ATL = TL->getAs<ArrayTypeLoc>())
+      return ATL.getBracketsRange();
+  }
   return N.getSourceRange();
 }
 
 // An IntervalSet maintains a set of disjoint subranges of an array.
 //
 // Initially, it contains the entire array.
 //           [-----------------------------------------------------------]
 //
bool TraverseDecl(Decl *X) {
     // Base::TraverseDecl will suppress children, but not this node itself.
     if (X && X->isImplicit())
       return true;
     return traverseNode(X, [&] { return Base::TraverseDecl(X); });
   }
   bool TraverseTypeLoc(TypeLoc X) {
     return traverseNode(&X, [&] { return Base::TraverseTypeLoc(X); });
   }
+
   bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &X) {
     return traverseNode(&X,
                         [&] { return Base::TraverseTemplateArgumentLoc(X); });
   }
   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc X) {
     return traverseNode(
         &X, [&] { return Base::TraverseNestedNameSpecifierLoc(X); });
   }
if (auto *TL = N.get<TypeLoc>()) {
       // FIXME: Alter DecltypeTypeLoc to contain parentheses locations and get
       // rid of this patch.
       if (auto DT = TL->getAs<DecltypeTypeLoc>())
         S.setEnd(DT.getUnderlyingExpr()->getEndLoc());
       // AttributedTypeLoc may point to the attribute's range, NOT the modified
       // type's range.
       if (auto AT = TL->getAs<AttributedTypeLoc>())
         S = AT.getModifiedLoc().getSourceRange();
+
+      if (auto AT = TL->getAs<ArrayTypeLoc>())
+        S = AT.getSourceRange();
     }
     // SourceRange often doesn't manage to accurately cover attributes.
     // Fortunately, attributes are rare.
     if (llvm::any_of(getAttributes(N),
                      [](const Attr *A) { return !A->isImplicit(); }))
       return false;
     if (!SelChecker.mayHit(S)) {
       dlog("{1}skip: {0}", printNodeToString(N, PrintPolicy), indent());

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

Case Cases[] = {
             };
           )cpp",
           "CXXCtorInitializer", // Not the CXXConstructExpr!
       },
       // Tricky case: anonymous struct is a sibling of the VarDecl.
       {"[[st^ruct {int x;}]] y;", "CXXRecordDecl"},
       {"[[struct {int x;} ^y]];", "VarDecl"},
       {"struct {[[int ^x]];} y;", "FieldDecl"},
+
+      // Tricky case: nested ConstantArrayTypeLocs have the same token range.
+      {"const int x = 1, y = 2; int array[^[[x]]][10][y];", "DeclRefExpr"},
+      {"const int x = 1, y = 2; int array[x][10][^[[y]]];", "DeclRefExpr"},
+      {"const int x = 1, y = 2; int array[x][^[[10]]][y];", "IntegerLiteral"},
+      {"const int x = 1, y = 2; [[i^nt]] array[x][10][y];", "BuiltinTypeLoc"},
+
       // FIXME: the AST has no location info for qualifiers.
       {"const [[a^uto]] x = 42;", "AutoTypeLoc"},
       {"[[co^nst auto x = 42]];", "VarDecl"},
 
       {"^", nullptr},
       {"void foo() { [[foo^^]] (); }", "DeclRefExpr"},
 
       // FIXME: Ideally we'd get a declstmt or the VarDecl itself here.