[clangd] findExplicitReferences supports goto labels

[sammccall]

Summary

This means they're renamable and textDocument/highlight works

This fell out of D78454

clang-tools-extra/clangd/FindTarget.cpp

struct Visitor : ConstDeclVisitor<Visitor> {
     }
   };
 
   Visitor V;
   V.Visit(D);
   return V.Refs;
 }
 
-llvm::SmallVector<ReferenceLoc, 2> refInExpr(const Expr *E) {
+llvm::SmallVector<ReferenceLoc, 2> refInStmt(const Stmt *S) {
   struct Visitor : ConstStmtVisitor<Visitor> {
     // FIXME: handle more complicated cases: more ObjC, designated initializers.
     llvm::SmallVector<ReferenceLoc, 2> Refs;
 
     void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E) {
       Refs.push_back(ReferenceLoc{E->getNestedNameSpecifierLoc(),
                                   E->getConceptNameLoc(),
                                   /*IsDecl=*/false,
void VisitDesignatedInitExpr(const DesignatedInitExpr *DIE) {
 
         llvm::SmallVector<const NamedDecl *, 1> Targets;
         if (D.getField())
           Targets.push_back(D.getField());
         Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(), D.getFieldLoc(),
                                     /*IsDecl=*/false, std::move(Targets)});
       }
     }
+
+    void VisitGotoStmt(const GotoStmt *GS) {
+      llvm::SmallVector<const NamedDecl *, 1> Targets;
+      if (const auto *L = GS->getLabel())
+        Targets.push_back(L);
+      Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(), GS->getLabelLoc(),
+                                  /*IsDecl=*/false, std::move(Targets)});
+    }
+
+    void VisitLabelStmt(const LabelStmt *LS) {
+      Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
+                                  LS->getIdentLoc(),
+                                  /*IsDecl=*/true,
+                                  {LS->getDecl()}});
+    }
   };
 
   Visitor V;
-  V.Visit(E);
+  V.Visit(S);
   return V.Refs;
 }
 
 llvm::SmallVector<ReferenceLoc, 2> refInTypeLoc(TypeLoc L) {
   struct Visitor : TypeLocVisitor<Visitor> {
     llvm::Optional<ReferenceLoc> Ref;
 
     void VisitElaboratedTypeLoc(ElaboratedTypeLoc L) {
public:
   bool TraverseElaboratedTypeLoc(ElaboratedTypeLoc L) {
     // ElaboratedTypeLoc will reports information for its inner type loc.
     // Otherwise we loose information about inner types loc's qualifier.
     TypeLoc Inner = L.getNamedTypeLoc().getUnqualifiedLoc();
     TypeLocsToSkip.insert(Inner.getBeginLoc().getRawEncoding());
     return RecursiveASTVisitor::TraverseElaboratedTypeLoc(L);
   }
 
-  bool VisitExpr(Expr *E) {
-    visitNode(DynTypedNode::create(*E));
+  bool VisitStmt(Stmt *S) {
+    visitNode(DynTypedNode::create(*S));
     return true;
   }
 
   bool TraverseOpaqueValueExpr(OpaqueValueExpr *OVE) {
     visitNode(DynTypedNode::create(*OVE));
     // Not clear why the source expression is skipped by default...
     // FIXME: can we just make RecursiveASTVisitor do this?
     return RecursiveASTVisitor::TraverseStmt(OVE->getSourceExpr());
private:
   ///
   /// (!) For the purposes of this function declarations are not considered to
   ///     be references. However, declarations can have references inside them,
   ///     e.g. 'namespace foo = std' references namespace 'std' and this
   ///     function will return the corresponding reference.
   llvm::SmallVector<ReferenceLoc, 2> explicitReference(DynTypedNode N) {
     if (auto *D = N.get<Decl>())
       return refInDecl(D);
-    if (auto *E = N.get<Expr>())
-      return refInExpr(E);
+    if (auto *S = N.get<Stmt>())
+      return refInStmt(S);
     if (auto *NNSL = N.get<NestedNameSpecifierLoc>()) {
       // (!) 'DeclRelation::Alias' ensures we do not loose namespace aliases.
       return {ReferenceLoc{
           NNSL->getPrefix(), NNSL->getLocalBeginLoc(), false,
           explicitReferenceTargets(
               DynTypedNode::create(*NNSL->getNestedNameSpecifier()),
               DeclRelation::Alias)}};
     }

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

std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
         "1: targets = {a::b}, qualifier = 'a::'\n"
         "2: targets = {a::b::S}, qualifier = 'a::b::'\n"
         "3: targets = {x}, decl\n"
         "4: targets = {a}\n"
         "5: targets = {a::b}, qualifier = 'a::'\n"
         "6: targets = {a::b::S}\n"
         "7: targets = {a::b::S::type}, qualifier = 'struct S::'\n"
         "8: targets = {y}, decl\n"},
+       {R"cpp(
+         void foo() {
+           $0^ten: // PRINT "HELLO WORLD!"
+           goto $1^ten;
+         }
+       )cpp",
+       "0: targets = {ten}, decl\n"
+       "1: targets = {ten}\n"},
        // Simple templates.
        {R"cpp(
           template <class T> struct vector { using value_type = T; };
           template <> struct vector<bool> { using value_type = bool; };
           void foo() {
             $0^vector<int> $1^vi;
             $2^vector<bool> $3^vb;
           }