[clangd] Use HeuristicResolver to produce a better semantic token for name referring to UnresolvedUsingValueDecl

[nridge]

Summary

Fixes https://github.com/clangd/clangd/issues/686

[nridge]

Depends on D99052.

[nridge]

Adding some potential reviewers.

[sammccall]

Very nice :-D

[nridge]

Rebase

clang-tools-extra/clangd/SemanticHighlighting.cpp

bool canHighlightName(DeclarationName Name) {
   case DeclarationName::CXXDeductionGuideName:
   case DeclarationName::CXXLiteralOperatorName:
   case DeclarationName::CXXUsingDirective:
     return false;
   }
   llvm_unreachable("invalid name kind");
 }
 
-llvm::Optional<HighlightingKind> kindForType(const Type *TP);
-llvm::Optional<HighlightingKind> kindForDecl(const NamedDecl *D) {
+llvm::Optional<HighlightingKind> kindForType(const Type *TP,
+                                             const HeuristicResolver *Resolver);
+llvm::Optional<HighlightingKind>
+kindForDecl(const NamedDecl *D, const HeuristicResolver *Resolver) {
   if (auto *USD = dyn_cast<UsingShadowDecl>(D)) {
     if (auto *Target = USD->getTargetDecl())
       D = Target;
   }
   if (auto *TD = dyn_cast<TemplateDecl>(D)) {
     if (auto *Templated = TD->getTemplatedDecl())
       D = Templated;
   }
   if (auto *TD = dyn_cast<TypedefNameDecl>(D)) {
     // We try to highlight typedefs as their underlying type.
-    if (auto K = kindForType(TD->getUnderlyingType().getTypePtrOrNull()))
+    if (auto K =
+            kindForType(TD->getUnderlyingType().getTypePtrOrNull(), Resolver))
       return K;
     // And fallback to a generic kind if this fails.
     return HighlightingKind::Typedef;
   }
   // We highlight class decls, constructor decls and destructor decls as
   // `Class` type. The destructor decls are handled in `VisitTagTypeLoc` (we
   // will visit a TypeLoc where the underlying Type is a CXXRecordDecl).
   if (auto *RD = llvm::dyn_cast<RecordDecl>(D)) {
kindForDecl(const NamedDecl *D, const HeuristicResolver *Resolver) {
   if (isa<NamespaceDecl>(D) || isa<NamespaceAliasDecl>(D) ||
       isa<UsingDirectiveDecl>(D))
     return HighlightingKind::Namespace;
   if (isa<TemplateTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
       isa<NonTypeTemplateParmDecl>(D))
     return HighlightingKind::TemplateParameter;
   if (isa<ConceptDecl>(D))
     return HighlightingKind::Concept;
-  if (isa<UnresolvedUsingValueDecl>(D)) {
-    // FIXME: We may be able to do better using HeuristicResolver.
+  if (const auto *UUVD = dyn_cast<UnresolvedUsingValueDecl>(D)) {
+    auto Targets = Resolver->resolveUsingValueDecl(UUVD);
+    if (!Targets.empty()) {
+      return kindForDecl(Targets[0], Resolver);
+    }
     return HighlightingKind::Unknown;
   }
   return llvm::None;
 }
-llvm::Optional<HighlightingKind> kindForType(const Type *TP) {
+llvm::Optional<HighlightingKind>
+kindForType(const Type *TP, const HeuristicResolver *Resolver) {
   if (!TP)
     return llvm::None;
   if (TP->isBuiltinType()) // Builtins are special, they do not have decls.
     return HighlightingKind::Primitive;
   if (auto *TD = dyn_cast<TemplateTypeParmType>(TP))
-    return kindForDecl(TD->getDecl());
+    return kindForDecl(TD->getDecl(), Resolver);
   if (isa<ObjCObjectPointerType>(TP))
     return HighlightingKind::Class;
   if (auto *TD = TP->getAsTagDecl())
-    return kindForDecl(TD);
+    return kindForDecl(TD, Resolver);
   return llvm::None;
 }
 
 // Whether T is const in a loose sense - is a variable with this type readonly?
 bool isConst(QualType T) {
   if (T.isNull() || T->isDependentType())
     return false;
   T = T.getNonReferenceType();
for (const Range &R : SortedSkippedRanges) {
       }
     }
     // Copy tokens after the last inactive line
     for (; It != NonConflicting.end(); ++It)
       WithInactiveLines.push_back(std::move(*It));
     return WithInactiveLines;
   }
 
+  const HeuristicResolver *getResolver() const { return Resolver; }
+
 private:
   const syntax::TokenBuffer &TB;
   const SourceManager &SourceMgr;
   const LangOptions &LangOpts;
   std::vector<HighlightingToken> Tokens;
+  const HeuristicResolver *Resolver;
   HighlightingToken Dummy; // returned from addToken(InvalidLoc)
 };
 
 llvm::Optional<HighlightingModifier> scopeModifier(const NamedDecl *D) {
   const DeclContext *DC = D->getDeclContext();
   // Injected "Foo" within the class "Foo" has file scope, not class scope.
   if (auto *R = dyn_cast_or_null<RecordDecl>(D))
     if (R->isInjectedClassName())

 /// Produces highlightings, which are not captured by findExplicitReferences,
 /// e.g. highlights dependent names and 'auto' as the underlying type.
 class CollectExtraHighlightings
     : public RecursiveASTVisitor<CollectExtraHighlightings> {
 public:
   CollectExtraHighlightings(HighlightingsBuilder &H) : H(H) {}
 
   bool VisitDecltypeTypeLoc(DecltypeTypeLoc L) {
-    if (auto K = kindForType(L.getTypePtr())) {
+    if (auto K = kindForType(L.getTypePtr(), H.getResolver())) {
       auto &Tok = H.addToken(L.getBeginLoc(), *K)
                       .addModifier(HighlightingModifier::Deduced);
       if (auto Mod = scopeModifier(L.getTypePtr()))
         Tok.addModifier(*Mod);
     }
     return true;
   }
 
   bool VisitDeclaratorDecl(DeclaratorDecl *D) {
     auto *AT = D->getType()->getContainedAutoType();
     if (!AT)
       return true;
-    if (auto K = kindForType(AT->getDeducedType().getTypePtrOrNull())) {
+    if (auto K = kindForType(AT->getDeducedType().getTypePtrOrNull(),
+                             H.getResolver())) {
       auto &Tok = H.addToken(D->getTypeSpecStartLoc(), *K)
                       .addModifier(HighlightingModifier::Deduced);
       if (auto Mod = scopeModifier(AT->getDeducedType().getTypePtrOrNull()))
         Tok.addModifier(*Mod);
     }
     return true;
   }
 
std::vector<HighlightingToken> getSemanticHighlightings(ParsedAST &AST) {
   CollectExtraHighlightings(Builder).TraverseAST(C);
   // Highlight all decls and references coming from the AST.
   findExplicitReferences(
       C,
       [&](ReferenceLoc R) {
         for (const NamedDecl *Decl : R.Targets) {
           if (!canHighlightName(Decl->getDeclName()))
             continue;
-          auto Kind = kindForDecl(Decl);
+          auto Kind = kindForDecl(Decl, AST.getHeuristicResolver());
           if (!Kind)
             continue;
           auto &Tok = Builder.addToken(R.NameLoc, *Kind);
 
           // The attribute tests don't want to look at the template.
           if (auto *TD = dyn_cast<TemplateDecl>(Decl)) {
             if (auto *Templated = TD->getTemplatedDecl())
               Decl = Templated;

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

)cpp",
       )cpp",
       // Member imported from dependent base
       R"cpp(
         template <typename> struct $Class_decl[[Base]] {
           int $Field_decl[[member]];
         };
         template <typename $TemplateParameter_decl[[T]]>
         struct $Class_decl[[Derived]] : $Class[[Base]]<$TemplateParameter[[T]]> {
-          using $Class[[Base]]<$TemplateParameter[[T]]>::$Unknown_dependentName[[member]];
+          using $Class[[Base]]<$TemplateParameter[[T]]>::$Field_dependentName[[member]];
 
           void $Method_decl[[method]]() {
-            (void)$Unknown_dependentName[[member]];
+            (void)$Field_dependentName[[member]];
           }
         };
       )cpp",
   };
   for (const auto &TestCase : TestCases)
     // Mask off scope modifiers to keep the tests manageable.
     // They're tested separately.
     checkHighlightings(TestCase, {}, ~ScopeModifierMask);