[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

 //===-- FindTargetTests.cpp --------------------------*- C++ -*------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "FindTarget.h"
 
for (unsigned I = 0; I < Refs.size(); ++I)
       DumpedReferences += std::string(llvm::formatv("{0}: {1}\n", I, Refs[I]));
 
     return AllRefs{std::move(AnnotatedCode), std::move(DumpedReferences)};
   }
 };
 
 TEST_F(FindExplicitReferencesTest, All) {
   std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
       {// Simple expressions.
        {R"cpp(
         int global;
         int func();
         void foo(int param) {
           $0^global = $1^param + $2^func();
         }
         )cpp",
         "0: targets = {global}\n"
         "1: targets = {param}\n"
         "2: targets = {func}\n"},
        {R"cpp(
         struct X { int a; };
         void foo(X x) {
           $0^x.$1^a = 10;
         }
         )cpp",
         "0: targets = {x}\n"
         "1: targets = {X::a}\n"},
        {R"cpp(
         // error-ok: testing with broken code
         int bar();
         int foo() {
           return $0^bar() + $1^bar(42);
         }
         )cpp",
         "0: targets = {bar}\n"
         "1: targets = {bar}\n"},
        // Namespaces and aliases.
        {R"cpp(
           namespace ns {}
           namespace alias = ns;
           void foo() {
             using namespace $0^ns;
             using namespace $1^alias;
           }
         )cpp",
         "0: targets = {ns}\n"
         "1: targets = {alias}\n"},
        // Using declarations.
        {R"cpp(
           namespace ns { int global; }
           void foo() {
             using $0^ns::$1^global;
           }
         )cpp",
         "0: targets = {ns}\n"
         "1: targets = {ns::global}, qualifier = 'ns::'\n"},
        // Simple types.
        {R"cpp(
          struct Struct { int a; };
          using Typedef = int;
          void foo() {
            $0^Struct $1^x;
            $2^Typedef $3^y;
            static_cast<$4^Struct*>(0);
          }
        )cpp",
         "0: targets = {Struct}\n"
         "1: targets = {x}, decl\n"
         "2: targets = {Typedef}\n"
         "3: targets = {y}, decl\n"
         "4: targets = {Struct}\n"},
        // Name qualifiers.
        {R"cpp(
          namespace a { namespace b { struct S { typedef int type; }; } }
          void foo() {
            $0^a::$1^b::$2^S $3^x;
            using namespace $4^a::$5^b;
            $6^S::$7^type $8^y;
          }
         )cpp",
         "0: targets = {a}\n"
         "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;
           }
         )cpp",
         "0: targets = {vector<int>}\n"
         "1: targets = {vi}, decl\n"
         "2: targets = {vector<bool>}\n"
         "3: targets = {vb}, decl\n"},
        // Template type aliases.
        {R"cpp(
             template <class T> struct vector { using value_type = T; };
             template <> struct vector<bool> { using value_type = bool; };
             template <class T> using valias = vector<T>;
             void foo() {
               $0^valias<int> $1^vi;
               $2^valias<bool> $3^vb;
             }
           )cpp",
         "0: targets = {valias}\n"
         "1: targets = {vi}, decl\n"
         "2: targets = {valias}\n"
         "3: targets = {vb}, decl\n"},
        // Injected class name.
        {R"cpp(
             namespace foo {
               template <typename $0^T>
               class $1^Bar {
                 ~$2^Bar();
                 void $3^f($4^Bar);
               };
             }
           )cpp",
         "0: targets = {foo::Bar::T}, decl\n"
         "1: targets = {foo::Bar}, decl\n"
         "2: targets = {foo::Bar}\n"
         "3: targets = {foo::Bar::f}, decl\n"
         "4: targets = {foo::Bar}\n"},
        // MemberExpr should know their using declaration.
        {R"cpp(
             struct X { void func(int); };
             struct Y : X {
               using X::func;
             };
             void foo(Y y) {
               $0^y.$1^func(1);
             }
         )cpp",
         "0: targets = {y}\n"
         "1: targets = {Y::func}\n"},
        // DeclRefExpr should know their using declaration.
        {R"cpp(
             namespace ns { void bar(int); }
             using ns::bar;
 
             void foo() {
               $0^bar(10);
             }
         )cpp",
         "0: targets = {bar}\n"},
        // References from a macro.
        {R"cpp(
             #define FOO a
             #define BAR b
 
             void foo(int a, int b) {
               $0^FOO+$1^BAR;
             }
         )cpp",
         "0: targets = {a}\n"
         "1: targets = {b}\n"},
        // No references from implicit nodes.
        {R"cpp(
             struct vector {
               int *begin();
               int *end();
             };
 
             void foo() {
               for (int $0^x : $1^vector()) {
                 $2^x = 10;
               }
             }
         )cpp",
         "0: targets = {x}, decl\n"
         "1: targets = {vector}\n"
         "2: targets = {x}\n"},
 // Handle UnresolvedLookupExpr.
 // FIXME
 // This case fails when expensive checks are enabled.
 // Seems like the order of ns1::func and ns2::func isn't defined.
 #ifndef EXPENSIVE_CHECKS
        {R"cpp(
             namespace ns1 { void func(char*); }
             namespace ns2 { void func(int*); }
             using namespace ns1;
             using namespace ns2;
 
             template <class T>
             void foo(T t) {
               $0^func($1^t);
             }
         )cpp",
         "0: targets = {ns1::func, ns2::func}\n"
         "1: targets = {t}\n"},
 #endif
        // Handle UnresolvedMemberExpr.
        {R"cpp(
             struct X {
               void func(char*);
               void func(int*);
             };
 
             template <class T>
             void foo(X x, T t) {
               $0^x.$1^func($2^t);
             }
         )cpp",
         "0: targets = {x}\n"
         "1: targets = {X::func, X::func}\n"
         "2: targets = {t}\n"},
        // Handle DependentScopeDeclRefExpr.
        {R"cpp(
             template <class T>
             struct S {
               static int value;
             };
 
             template <class T>
             void foo() {
               $0^S<$1^T>::$2^value;
             }
        )cpp",
         "0: targets = {S}\n"
         "1: targets = {T}\n"
         "2: targets = {S::value}, qualifier = 'S<T>::'\n"},
        // Handle CXXDependentScopeMemberExpr.
        {R"cpp(
             template <class T>
             struct S {
               int value;
             };
 
             template <class T>
             void foo(S<T> t) {
               $0^t.$1^value;
             }
        )cpp",
         "0: targets = {t}\n"
         "1: targets = {S::value}\n"},
        // Type template parameters.
        {R"cpp(
             template <class T>
             void foo() {
               static_cast<$0^T>(0);
               $1^T();
               $2^T $3^t;
             }
         )cpp",
         "0: targets = {T}\n"
         "1: targets = {T}\n"
         "2: targets = {T}\n"
         "3: targets = {t}, decl\n"},
        // Non-type template parameters.
        {R"cpp(
             template <int I>
             void foo() {
               int $0^x = $1^I;
             }
         )cpp",
         "0: targets = {x}, decl\n"
         "1: targets = {I}\n"},
        // Template template parameters.
        {R"cpp(
             template <class T> struct vector {};
 
             template <template<class> class TT, template<class> class ...TP>
             void foo() {
               $0^TT<int> $1^x;
               $2^foo<$3^TT>();
               $4^foo<$5^vector>();
               $6^foo<$7^TP...>();
             }
         )cpp",
         "0: targets = {TT}\n"
         "1: targets = {x}, decl\n"
         "2: targets = {foo}\n"
         "3: targets = {TT}\n"
         "4: targets = {foo}\n"
         "5: targets = {vector}\n"
         "6: targets = {foo}\n"
         "7: targets = {TP}\n"},
        // Non-type template parameters with declarations.
        {R"cpp(
             int func();
             template <int(*)()> struct wrapper {};
 
             template <int(*FuncParam)()>
             void foo() {
               $0^wrapper<$1^func> $2^w;
               $3^FuncParam();
             }
         )cpp",
         "0: targets = {wrapper<&func>}\n"
         "1: targets = {func}\n"
         "2: targets = {w}, decl\n"
         "3: targets = {FuncParam}\n"},
        // declaration references.
        {R"cpp(
              namespace ns {}
              class S {};
              void foo() {
                class $0^Foo { $1^Foo(); ~$2^Foo(); int $3^field; };
                int $4^Var;
                enum $5^E { $6^ABC };
                typedef int $7^INT;
                using $8^INT2 = int;
                namespace $9^NS = $10^ns;
              }
            )cpp",
         "0: targets = {Foo}, decl\n"
         "1: targets = {foo()::Foo::Foo}, decl\n"
         "2: targets = {Foo}\n"
         "3: targets = {foo()::Foo::field}, decl\n"
         "4: targets = {Var}, decl\n"
         "5: targets = {E}, decl\n"
         "6: targets = {foo()::ABC}, decl\n"
         "7: targets = {INT}, decl\n"
         "8: targets = {INT2}, decl\n"
         "9: targets = {NS}, decl\n"
         "10: targets = {ns}\n"},
        // User-defined conversion operator.
        {R"cpp(
             void foo() {
                class $0^Bar {};
                class $1^Foo {
                public:
                  // FIXME: This should have only one reference to Bar.
                  $2^operator $3^$4^Bar();
                };
 
                $5^Foo $6^f;
                $7^f.$8^operator $9^Bar();
             }
         )cpp",
         "0: targets = {Bar}, decl\n"
         "1: targets = {Foo}, decl\n"
         "2: targets = {foo()::Foo::operator Bar}, decl\n"
         "3: targets = {Bar}\n"
         "4: targets = {Bar}\n"
         "5: targets = {Foo}\n"
         "6: targets = {f}, decl\n"
         "7: targets = {f}\n"
         "8: targets = {foo()::Foo::operator Bar}\n"
#endif
                    this->~$3^Foo();
                  }
                };
 
                $4^Foo $5^f;
                $6^f.~ /*...*/ $7^Foo();
              }
            )cpp",
         "0: targets = {Foo}, decl\n"
         // FIXME: It's better to target destructor's FunctionDecl instead of
         // the type itself (similar to constructor).
         "1: targets = {Foo}\n"
         "2: targets = {foo()::Foo::destructMe}, decl\n"
         "3: targets = {Foo}\n"
         "4: targets = {Foo}\n"
         "5: targets = {f}, decl\n"
         "6: targets = {f}\n"
#endif
                };
                // delegating initializer
                class $10^Foo {
                  $11^Foo(int);
                  $12^Foo(): $13^Foo(111) {}
                };
              }
            )cpp",
         "0: targets = {X}, decl\n"
         "1: targets = {foo()::X::abc}, decl\n"
         "2: targets = {foo()::X::X}, decl\n"
         "3: targets = {foo()::X::abc}\n"
         "4: targets = {Derived}, decl\n"
         "5: targets = {Base}\n"
         "6: targets = {Base}\n"
         "7: targets = {foo()::Derived::B}, decl\n"
         "8: targets = {foo()::Derived::Derived}, decl\n"
         "9: targets = {Base}\n"
         "10: targets = {Foo}, decl\n"
         "11: targets = {foo()::Foo::Foo}, decl\n"
         "12: targets = {foo()::Foo::Foo}, decl\n"
         "13: targets = {Foo}\n"},
        // Anonymous entities should not be reported.
        {
            R"cpp(
              void foo() {
               class {} $0^x;
               int (*$1^fptr)(int $2^a, int) = nullptr;
              }
            )cpp",
            "0: targets = {x}, decl\n"
            "1: targets = {fptr}, decl\n"
            "2: targets = {a}, decl\n"},
        // Namespace aliases should be handled properly.
        {
            R"cpp(
                 namespace ns { struct Type {}; }
                 namespace alias = ns;
                 namespace rec_alias = alias;
 
                 void foo() {
                   $0^ns::$1^Type $2^a;
                   $3^alias::$4^Type $5^b;
                   $6^rec_alias::$7^Type $8^c;
                 }
            )cpp",
            "0: targets = {ns}\n"
            "1: targets = {ns::Type}, qualifier = 'ns::'\n"
            "2: targets = {a}, decl\n"
            "3: targets = {alias}\n"
            "4: targets = {ns::Type}, qualifier = 'alias::'\n"
            "5: targets = {b}, decl\n"
            "6: targets = {rec_alias}\n"
            "7: targets = {ns::Type}, qualifier = 'rec_alias::'\n"
            "8: targets = {c}, decl\n"},
        // Handle SizeOfPackExpr.
        {
            R"cpp(
                 template <typename... E>
                 void foo() {
                   constexpr int $0^size = sizeof...($1^E);
                 };
             )cpp",
            "0: targets = {size}, decl\n"
            "1: targets = {E}\n"},
        // Class template argument deduction
        {
            R"cpp(
                 template <typename T>
                 struct Test {
                 Test(T);
               };
               void foo() {
                 $0^Test $1^a(5);
               }
             )cpp",
            "0: targets = {Test}\n"
            "1: targets = {a}, decl\n"},
        // Templates
        {R"cpp(
             namespace foo {
               template <typename $0^T>
               class $1^Bar {};
             }
           )cpp",
         "0: targets = {foo::Bar::T}, decl\n"
         "1: targets = {foo::Bar}, decl\n"},
        // Templates
        {R"cpp(
             namespace foo {
               template <typename $0^T>
               void $1^func();
             }
           )cpp",
         "0: targets = {T}, decl\n"
         "1: targets = {foo::func}, decl\n"},
        // Templates
        {R"cpp(
             namespace foo {
               template <typename $0^T>
               $1^T $2^x;
             }
           )cpp",
         "0: targets = {foo::T}, decl\n"
         "1: targets = {foo::T}\n"
         "2: targets = {foo::x}, decl\n"},
        // Templates
        {R"cpp(
             template<typename T> class vector {};
             namespace foo {
               template <typename $0^T>
               using $1^V = $2^vector<$3^T>;
             }
           )cpp",
         "0: targets = {foo::T}, decl\n"
         "1: targets = {foo::V}, decl\n"
         "2: targets = {vector}\n"
         "3: targets = {foo::T}\n"},
        // Concept
        {
            R"cpp(
               template <typename T>
               concept Drawable = requires (T t) { t.draw(); };
 
               namespace foo {
                 template <typename $0^T> requires $1^Drawable<$2^T>
                 void $3^bar($4^T $5^t) {
                   $6^t.$7^draw();
                 }
               }
           )cpp",
            "0: targets = {T}, decl\n"
            "1: targets = {Drawable}\n"
            "2: targets = {T}\n"
            "3: targets = {foo::bar}, decl\n"
            "4: targets = {T}\n"
            "5: targets = {t}, decl\n"
            "6: targets = {t}\n"
            "7: targets = {}\n"},
        // Objective-C: properties
        {
            R"cpp(
             @interface I {}
             @property(retain) I* x;
             @property(retain) I* y;
             @end
             I *f;
             void foo() {
               $0^f.$1^x.$2^y = 0;
             }
           )cpp",
            "0: targets = {f}\n"
            "1: targets = {I::x}\n"
            "2: targets = {I::y}\n"},
        // Objective-C: implicit properties
        {
            R"cpp(
             @interface I {}
             -(I*)x;
             -(void)setY:(I*)y;
             @end
             I *f;
             void foo() {
               $0^f.$1^x.$2^y = 0;
             }
           )cpp",
            "0: targets = {f}\n"
            "1: targets = {I::x}\n"
            "2: targets = {I::setY:}\n"},
        // Designated initializers.
        {R"cpp(
             void foo() {
               struct $0^Foo {
                 int $1^Bar;
               };
               $2^Foo $3^f { .$4^Bar = 42 };
             }
         )cpp",
         "0: targets = {Foo}, decl\n"
         "1: targets = {foo()::Foo::Bar}, decl\n"
         "2: targets = {Foo}\n"
         "3: targets = {f}, decl\n"
         "4: targets = {foo()::Foo::Bar}\n"},
        {R"cpp(
             void foo() {
               struct $0^Baz {
                 int $1^Field;
               };
               struct $2^Bar {
                 $3^Baz $4^Foo;
               };
               $5^Bar $6^bar { .$7^Foo.$8^Field = 42 };
             }
         )cpp",
         "0: targets = {Baz}, decl\n"
         "1: targets = {foo()::Baz::Field}, decl\n"
         "2: targets = {Bar}, decl\n"
         "3: targets = {Baz}\n"
         "4: targets = {foo()::Bar::Foo}, decl\n"
         "5: targets = {Bar}\n"
         "6: targets = {bar}, decl\n"
         "7: targets = {foo()::Bar::Foo}\n"
         "8: targets = {foo()::Baz::Field}\n"},
       {R"cpp(
            template<typename T>
            void crash(T);
            template<typename T>
            void foo() {
              $0^crash({.$1^x = $2^T()});
            }
         )cpp",
         "0: targets = {crash}\n"
         "1: targets = {}\n"
         "2: targets = {T}\n"
       },
       // unknown template name should not crash.
       {R"cpp(
         template <template <typename> typename T>
         struct Base {};
         namespace foo {
         template <typename $0^T>
         struct $1^Derive : $2^Base<$3^T::template $4^Unknown> {};
         }
       )cpp",
       "0: targets = {foo::Derive::T}, decl\n"
       "1: targets = {foo::Derive}, decl\n"
       "2: targets = {Base}\n"
       "3: targets = {foo::Derive::T}\n"
       "4: targets = {}, qualifier = 'T::'\n"},
     };
 
   for (const auto &C : Cases) {
     llvm::StringRef ExpectedCode = C.first;