[clangd] Highlighting auto variables as the deduced type.

[jvikstrom]

Summary

Done in VisitDeclaratorDecl as the AutoTypeLoc is not deduced.
Scoped to only work for variables.
auto function return values need to be handled in a special way (separate patch for that).
auto's that are in lambdas ar enot highlighted as we don't highlight their underlying type (it's a RecordDecl, but the name is not an identifier so it returns in addToken).

[jvikstrom]

Finished comment.

[hokein]

clang-tools-extra/clangd/SemanticHighlighting.cpp

153

The heuristic using here is fragile, (it doesn't handle decltype (auto) correctly).

I'm not quite sure we really want to highlight the inner auto, it may introduce inconsistent behavior (see we have $Primitive[[decltype]]($Variable[[Form]]) in the unittest). I think we could just leave it with the default behavior here...

154

nit: remove the debug log

161

assert TP cannot be null, or even move the null-ptr check into this method?

[jvikstrom]

Address comments.

[jvikstrom]

Removed ending whitespace on a line.

[hokein]

clang-tools-extra/clangd/SemanticHighlighting.cpp

167

nit: it seems clearer to me, if we write the code like:

if (!Deduced.isNull()) {
   addType(D->getTypeSpecStartLoc(), Deduced.getTypePtr());
}

clang-tools-extra/clangd/SemanticHighlighting.cpp

if (Ref->getNameInfo().getName().getNameKind() !=
       return true;
 
     addToken(Ref->getLocation(), Ref->getDecl());
     return true;
   }
 
   bool VisitTypedefNameDecl(TypedefNameDecl *TD) {
     if(const auto *TSI = TD->getTypeSourceInfo())
-      addTypeLoc(TD->getLocation(), TSI->getTypeLoc());
+      if (const Type *TP = TSI->getTypeLoc().getTypePtr())
+        addType(TD->getLocation(), TP);
     return true;
   }
 
   bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc &TL) {
     // TemplateTypeParmTypeLoc does not have a TagDecl in its type ptr.
     addToken(TL.getBeginLoc(), TL.getDecl());
     return true;
   }
 
   bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc &TL) {
     if (const TemplateDecl *TD =
             TL.getTypePtr()->getTemplateName().getAsTemplateDecl())
       addToken(TL.getBeginLoc(), TD);
     return true;
   }
 
   bool VisitTypeLoc(TypeLoc &TL) {
     // This check is for not getting two entries when there are anonymous
     // structs. It also makes us not highlight certain namespace qualifiers
     // twice. For elaborated types the actual type is highlighted as an inner
     // TypeLoc.
     if (TL.getTypeLocClass() == TypeLoc::TypeLocClass::Elaborated)
       return true;
-
-    addTypeLoc(TL.getBeginLoc(), TL);
+    if (const Type *TP = TL.getTypePtr())
+      addType(TL.getBeginLoc(), TP);
     return true;
   }
 
   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLoc) {
     if (NestedNameSpecifier *NNS = NNSLoc.getNestedNameSpecifier())
       if (NNS->getKind() == NestedNameSpecifier::Namespace ||
           NNS->getKind() == NestedNameSpecifier::NamespaceAlias)
         addToken(NNSLoc.getLocalBeginLoc(), HighlightingKind::Namespace);
 
     return RecursiveASTVisitor<
         HighlightingTokenCollector>::TraverseNestedNameSpecifierLoc(NNSLoc);
   }
 
+  bool VisitDeclaratorDecl(DeclaratorDecl *D) {
+    if ((!D->getTypeSourceInfo()))
+      return true;
+
+    if (auto *AT = D->getType()->getContainedAutoType()) {
+      const auto Deduced = AT->getDeducedType();
+      if (Deduced.isNull())
+        return true;
+      SourceLocation Loc = D->getTypeSpecStartLoc();
+      if (AT->isDecltypeAuto())
+        // If this is a decltype(auto) it's still the "auto" keyword that should
+        // get the highlightings. But there is no way to get the SLoc of the
+        // "auto" keyword other than using an offset.
+        Loc = Loc.getLocWithOffset(9);
+      Deduced.getTypePtr()->dump();
+      addType(Loc, Deduced.getTypePtr());
+    }
+    return true;
+  }
+
 private:
-  void addTypeLoc(SourceLocation Loc, const TypeLoc &TL) {
-    if (const Type *TP = TL.getTypePtr()) {
-      if (const TagDecl *TD = TP->getAsTagDecl())
-        addToken(Loc, TD);
-      if (TP->isBuiltinType())
-        // Builtins must be special cased as they do not have a TagDecl.
-        addToken(Loc, HighlightingKind::Primitive);
+  void addType(SourceLocation Loc, const Type *TP) {
+    if (const TagDecl *TD = TP->getAsTagDecl()) {
+      addToken(Loc, TD);
     }
   }
 
   void addToken(SourceLocation Loc, const NamedDecl *D) {
     if (D->getDeclName().isIdentifier() && D->getName().empty())
       // Don't add symbols that don't have any length.
       return;
     // We highlight class decls, constructor decls and destructor decls as
     // `Class` type. The destructor decls are handled in `VisitTypeLoc` (we will

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

TEST(SemanticHighlighting, GetsCorrectTokens) {
   const char *TestCases[] = {
     R"cpp(
       struct $Class[[AS]] {
         $Primitive[[double]] $Field[[SomeMember]];
       };
       struct {
       } $Variable[[S]];
       $Primitive[[void]] $Function[[foo]]($Primitive[[int]] $Variable[[A]], $Class[[AS]] $Variable[[As]]) {
-        auto $Variable[[VeryLongVariableName]] = 12312;
+        $Primitive[[auto]] $Variable[[VeryLongVariableName]] = 12312;
         $Class[[AS]]     $Variable[[AA]];
-        auto $Variable[[L]] = $Variable[[AA]].$Field[[SomeMember]] + $Variable[[A]];
+        $Primitive[[auto]] $Variable[[L]] = $Variable[[AA]].$Field[[SomeMember]] + $Variable[[A]];
         auto $Variable[[FN]] = [ $Variable[[AA]]]($Primitive[[int]] $Variable[[A]]) -> $Primitive[[void]] {};
         $Variable[[FN]](12312);
       }
     )cpp",
     R"cpp(
       $Primitive[[void]] $Function[[foo]]($Primitive[[int]]);
       $Primitive[[void]] $Function[[Gah]]();
       $Primitive[[void]] $Function[[foo]]() {
R"cpp(
         operator $Class[[Foo]]();
       };
       $Primitive[[void]] $Function[[f]]() {
         $Class[[Bar]] $Variable[[B]];
         $Class[[Foo]] $Variable[[F]] = $Variable[[B]];
         $Class[[Foo]] *$Variable[[FP]] = ($Class[[Foo]]*)$Variable[[B]];
         $Primitive[[int]] $Variable[[I]] = ($Primitive[[int]])$Variable[[B]];
       }
+    )cpp",
+    R"cpp(
+      enum $Enum[[E]] {
+        $EnumConstant[[E]],
+      };
+      class $Class[[Foo]] {};
+      $Enum[[auto]] $Variable[[AE]] = $Enum[[E]]::$EnumConstant[[E]];
+      $Class[[auto]] $Variable[[AF]] = $Class[[Foo]]();
+      decltype($Class[[auto]]) $Variable[[AF2]] = $Class[[Foo]]();
+      $Class[[auto]] *$Variable[[AFP]] = &$Variable[[AF]];
+      $Enum[[auto]] &$Variable[[AER]] = $Variable[[AE]];
+      $Primitive[[auto]] $Variable[[Form]] = 10.2 + 2 * 4;
+      $Primitive[[decltype]]($Variable[[Form]]) $Variable[[F]] = 10;
+      auto $Variable[[Fun]] = []()->$Primitive[[void]]{};
     )cpp"};
   for (const auto &TestCase : TestCases) {
     checkHighlightings(TestCase);
   }
 }
 
 TEST(SemanticHighlighting, GeneratesHighlightsWhenFileChange) {
   class HighlightingsCounterDiagConsumer : public DiagnosticsConsumer {