[clangd] Produce semantic token for name referring to UnresolvedUsingValueDecl

[nridge]

Summary

For now, use the token kind Unknown. We may be able to improve on this
using HeuristicResolver.

[nridge]

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

656

Not sure how I feel about this being a _decl.

I know it is in the technical sense, but as a user I think of it more as a reference to Base::member.

[nridge]

Adding some potential reviewers.

[sammccall]

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

656

Yeah, I agree, and the combination of decl and dependentName is pretty funny.

We have non-dependent equivalent cases (using ::foo, not the renaming versions) and they don't seem to be marked as decl. (I think what's happening is that findExplicitReferences yields the *UsingShadowDecl*s rather than the *UsingDecl*, as only the former are directly bound to a specific e.g. overload being referenced)

So with that as precedent, it seems like it would be legitimate to special-case UnresolvedUsingValueDecl when adding the decl modifier.

[nridge]

Address review comment

clang-tools-extra/clangd/SemanticHighlighting.cpp

llvm::Optional<HighlightingKind> kindForDecl(const NamedDecl *D) {
   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.
+    return HighlightingKind::Unknown;
+  }
   return llvm::None;
 }
 llvm::Optional<HighlightingKind> kindForType(const Type *TP) {
   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))

 bool isAbstract(const Decl *D) {
   if (const auto *CMD = llvm::dyn_cast<CXXMethodDecl>(D))
     return CMD->isPure();
   if (const auto *CRD = llvm::dyn_cast<CXXRecordDecl>(D))
     return CRD->hasDefinition() && CRD->isAbstract();
   return false;
 }
 
+bool isDependent(const Decl *D) {
+  if (isa<UnresolvedUsingValueDecl>(D))
+    return true;
+  return false;
+}
+
 // For a macro usage `DUMP(foo)`, we want:
 //  - DUMP --> "macro"
 //  - foo --> "variable".
 SourceLocation getHighlightableSpellingToken(SourceLocation L,
                                              const SourceManager &SM) {
   if (L.isFileID())
     return SM.isWrittenInMainFile(L) ? L : SourceLocation{};
   // Tokens expanded from the macro body contribute no highlightings.
findExplicitReferences(
           if (auto Mod = scopeModifier(Decl))
             Tok.addModifier(*Mod);
           if (isConst(Decl))
             Tok.addModifier(HighlightingModifier::Readonly);
           if (isStatic(Decl))
             Tok.addModifier(HighlightingModifier::Static);
           if (isAbstract(Decl))
             Tok.addModifier(HighlightingModifier::Abstract);
+          if (isDependent(Decl))
+            Tok.addModifier(HighlightingModifier::DependentName);
           if (Decl->isDeprecated())
             Tok.addModifier(HighlightingModifier::Deprecated);
-          if (R.IsDecl)
+          // Do not treat an UnresolvedUsingValueDecl as a declaration.
+          // It's more common to think of it as a reference to the
+          // underlying declaration.
+          if (R.IsDecl && !isa<UnresolvedUsingValueDecl>(Decl))
             Tok.addModifier(HighlightingModifier::Declaration);
         }
       },
       AST.getHeuristicResolver());
   // Add highlightings for macro references.
   auto AddMacro = [&](const MacroOccurrence &M) {
     auto &T = Builder.addToken(M.Rng, HighlightingKind::Macro);
     T.addModifier(HighlightingModifier::GlobalScope);

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

)cpp",
       )cpp",
       R"cpp(
         // ObjC: Classes and methods
         @class $Class_decl[[Forward]];
 
         @interface $Class_decl[[Foo]]
         @end
         @interface $Class_decl[[Bar]] : $Class[[Foo]]
         -($Class[[id]]) $Method_decl[[x]]:(int)$Parameter_decl[[a]] $Method_decl[[y]]:(int)$Parameter_decl[[b]];
         +(void) $StaticMethod_decl_static[[explode]];
         @end
         @implementation $Class_decl[[Bar]]
         -($Class[[id]]) $Method_decl[[x]]:(int)$Parameter_decl[[a]] $Method_decl[[y]]:(int)$Parameter_decl[[b]] {
           return self;
         }
         +(void) $StaticMethod_decl_static[[explode]] {}
         @end
)cpp",
         // ObjC: Categories
         @interface $Class_decl[[Foo]]
         @end
         @interface $Class[[Foo]]($Namespace_decl[[Bar]])
         @end
         @implementation $Class[[Foo]]($Namespace_decl[[Bar]])
         @end
       )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]];
+
+          void $Method_decl[[method]]() {
+            (void)$Unknown_dependentName[[member]];
+          }
+        };
+      )cpp",
   };
   for (const auto &TestCase : TestCases)
     // Mask off scope modifiers to keep the tests manageable.
     // They're tested separately.
     checkHighlightings(TestCase, {}, ~ScopeModifierMask);
 
   checkHighlightings(R"cpp(
     class $Class_decl[[A]] {