[clangd] Add missing highlights for using decls.

[merge_guards_bot]

Build result: pass - 59702 tests passed, 0 failed and 763 were skipped.
Log files: cmake-log.txt, ninja_check_all-log.txt, CMakeCache.txt

[ilya-biryukov]

clang-tools-extra/clangd/SemanticHighlighting.cpp

55

Could we reuse kindForCandidateDecls instead?
It's best to keep one way to highlight multiple decls.

64

Using decls never have any references and we only highlight them at their declarations locations.
Therefore kindForDecl seems like the wrong place for it. Could we add a VisitUsingDecl method to the visitor and have this logic there instead?

[hokein]

address comments.

[hokein]

clang-tools-extra/clangd/SemanticHighlighting.cpp

55

Yes, but note that we need to handle the UsingShadowDecl in this function.

64

good point. done.

[merge_guards_bot]

Build result: pass - 59702 tests passed, 0 failed and 763 were skipped.
Log files: cmake-log.txt, ninja_check_all-log.txt, CMakeCache.txt

[ilya-biryukov]

LGTM. See the NITs, though

clang-tools-extra/clangd/SemanticHighlighting.cpp

55

Maybe put this at the first line? This looks like a very good first step.

56

Maybe do D = USD->getTargetDecl() instead?
This would align with how we handle templates in this function and avoid recursive calls (which always look a bit suspicious, e.g. require more thought to ensure the function does not recurse indefinitely)

[hokein]

address remaining nits.

clang-tools-extra/clangd/SemanticHighlighting.cpp

if (Name.getNameKind() == DeclarationName::CXXConstructorName ||
       Name.getNameKind() == DeclarationName::CXXUsingDirective)
     return true;
   auto *II = Name.getAsIdentifierInfo();
   return II && !II->getName().empty();
 }
 
 llvm::Optional<HighlightingKind> kindForType(const Type *TP);
 llvm::Optional<HighlightingKind> kindForDecl(const NamedDecl *D) {
+  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()))
       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)) {
     // We don't want to highlight lambdas like classes.
     if (RD->isLambda())
       return llvm::None;
     return HighlightingKind::Class;
   }
   if (isa<ClassTemplateDecl>(D) || isa<RecordDecl>(D) ||
       isa<CXXConstructorDecl>(D))
     return HighlightingKind::Class;
   if (auto *MD = dyn_cast<CXXMethodDecl>(D))
     return MD->isStatic() ? HighlightingKind::StaticMethod
                           : HighlightingKind::Method;
   if (isa<FieldDecl>(D))
     return HighlightingKind::Field;
   if (isa<EnumDecl>(D))
llvm::Optional<HighlightingKind> kindForType(const Type *TP) {
   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());
   if (auto *TD = TP->getAsTagDecl())
     return kindForDecl(TD);
   return llvm::None;
 }
-// Given a set of candidate declarations for an unresolved name,
-// if the declarations all have the same highlighting kind, return
-// that highlighting kind, otherwise return None.
-llvm::Optional<HighlightingKind>
-kindForCandidateDecls(llvm::iterator_range<UnresolvedSetIterator> Decls) {
+// Given a set of candidate declarations, if the declarations all have the same
+// highlighting kind, return that highlighting kind, otherwise return None.
+template <typename IteratorRange>
+llvm::Optional<HighlightingKind> kindForCandidateDecls(IteratorRange Decls) {
   llvm::Optional<HighlightingKind> Result;
   for (NamedDecl *Decl : Decls) {
     auto Kind = kindForDecl(Decl);
     if (!Kind || (Result && Kind != Result))
       return llvm::None;
     Result = Kind;
   }
   return Result;
public:
   }
 
   bool VisitNamedDecl(NamedDecl *ND) {
     if (canHighlightName(ND->getDeclName()))
       addToken(ND->getLocation(), ND);
     return true;
   }
 
+  bool VisitUsingDecl(UsingDecl *UD) {
+    if (auto K = kindForCandidateDecls(UD->shadows()))
+      addToken(UD->getLocation(), *K);
+    return true;
+  }
+
   bool VisitDeclRefExpr(DeclRefExpr *Ref) {
     if (canHighlightName(Ref->getNameInfo().getName()))
       addToken(Ref->getLocation(), Ref->getDecl());
     return true;
   }
 
   bool VisitTypedefTypeLoc(TypedefTypeLoc TL) {
     addToken(TL.getBeginLoc(), TL.getTypedefNameDecl());

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

const char *TestCases[] = {
     )cpp",
       R"cpp(
       template <class $TemplateParameter[[T]]>
       class $Class[[A]] {
         int $Method[[foo]]() {
           return $TemplateParameter[[T]]::$DependentName[[Field]];
         }
       };
+    )cpp",
+      // Highlighting the using decl as the underlying using shadow decl.
+      R"cpp(
+      void $Function[[foo]]();
+      using ::$Function[[foo]];
     )cpp"};
   for (const auto &TestCase : TestCases) {
     checkHighlightings(TestCase);
   }
 
   checkHighlightings(R"cpp(
     class $Class[[A]] {
       #include "imp.h"