[clangd] Highlighting dependent types in more contexts

[ilya-biryukov]

clang-tools-extra/clangd/SemanticHighlighting.cpp

259

Instead of calling visitDependentTypesInQualifier, implement TraverseNestedNameSpecifierLoc to catch all their occurrences.

No need to redo the traversal, it should be handled by RecursiveASTVisitor.

263

NIT: remove the comment, it is redundant. One can always navigate to the definition of DependentTemplateSpecializationTypeLoc if they need to understand what it is.

[nridge]

Address review comments

[ilya-biryukov]

Thanks! LGTM

clang-tools-extra/clangd/SemanticHighlighting.cpp

286

NIT: remove braces from the inner if. They look totally ok in the outer if, though

[nridge]

Address nit

clang-tools-extra/clangd/SemanticHighlighting.cpp

public:
   bool VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) {
     H.addToken(E->getMemberNameInfo().getLoc(),
                HighlightingKind::DependentName);
     return true;
   }
 
   bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
     H.addToken(E->getNameInfo().getLoc(), HighlightingKind::DependentName);
+    visitDependentTypesInQualifier(E->getQualifierLoc());
     return true;
   }
 
   bool VisitDependentNameTypeLoc(DependentNameTypeLoc L) {
     H.addToken(L.getNameLoc(), HighlightingKind::DependentType);
+    visitDependentTypesInQualifier(L.getQualifierLoc());
+    return true;
+  }
+
+  // This is similar to DependentNameTypeLoc, but used for
+  // template-ids where the template-name itself is dependent.
+  bool VisitDependentTemplateSpecializationTypeLoc(
+      DependentTemplateSpecializationTypeLoc L) {
+    H.addToken(L.getTemplateNameLoc(), HighlightingKind::DependentType);
+    visitDependentTypesInQualifier(L.getQualifierLoc());
     return true;
   }
 
 private:
   HighlightingsBuilder &H;
+
+  // findExplicitReferences will walk nested-name-specifiers and
+  // find anything that can be resolved to a Decl. However, non-leaf
+  // components of nested-name-specifiers which are dependent names
+  // (kind "Identifier") cannot be resolved to a decl and also do
+  // not have a Visit() method called on them directly, so we
+  // walk the nested-name-specifiers of relevant node types
+  // (e.g. DependentScopeDeclRefExpr) here to catch them.
+  void visitDependentTypesInQualifier(NestedNameSpecifierLoc Q) {
+    NestedNameSpecifier *NNS = Q.getNestedNameSpecifier();
+    if (!NNS)
+      return;
+    if (NNS->getKind() == NestedNameSpecifier::Identifier) {
+      H.addToken(Q.getLocalBeginLoc(), HighlightingKind::DependentType);
+    }
+    visitDependentTypesInQualifier(Q.getPrefix());
+  }
 };
 
 // Encode binary data into base64.
 // This was copied from compiler-rt/lib/fuzzer/FuzzerUtil.cpp.
 // FIXME: Factor this out into llvm/Support?
 std::string encodeBase64(const llvm::SmallVectorImpl<char> &Bytes) {
   static const char Table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                               "abcdefghijklmnopqrstuvwxyz"

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

 $InactiveCode[[]]      #else
       int $Variable[[Active2]];
       #endif
     )cpp",
       // Argument to 'sizeof...'
       R"cpp(
       template <typename... $TemplateParameter[[Elements]]>
       struct $Class[[TupleSize]] {
-        static const int $StaticField[[size]] = sizeof...($TemplateParameter[[Elements]]);
+        static const int $StaticField[[size]] =
+sizeof...($TemplateParameter[[Elements]]);
+      };
+    )cpp",
+      // More dependent types
+      R"cpp(
+      template <typename $TemplateParameter[[T]]>
+      struct $Class[[Waldo]] {
+        using $Typedef[[Location1]] = typename $TemplateParameter[[T]]
+            ::$DependentType[[Resolver]]::$DependentType[[Location]];
+        using $Typedef[[Location2]] = typename $TemplateParameter[[T]]
+            ::template $DependentType[[Resolver]]<$TemplateParameter[[T]]>
+            ::$DependentType[[Location]];
+        using $Typedef[[Location3]] = typename $TemplateParameter[[T]]
+            ::$DependentType[[Resolver]]
+            ::template $DependentType[[Location]]<$TemplateParameter[[T]]>;
+        static const int $StaticField[[Value]] = $TemplateParameter[[T]]
+            ::$DependentType[[Resolver]]::$DependentName[[Value]];
       };
     )cpp"};
   for (const auto &TestCase : TestCases) {
     checkHighlightings(TestCase);
   }
 
   checkHighlightings(R"cpp(
     class $Class[[A]] {