[clangd] Highlight "miscellaneous" types as `type` as a fallback.

[sammccall]

Summary

This allows them to carry modifiers like deduced.

clang-tools-extra/clangd/SemanticHighlighting.cpp

kindForDecl(const NamedDecl *D, const HeuristicResolver *Resolver) {
   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(), Resolver))
+      if (*K != HighlightingKind::Type)
         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.

 }
 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(), Resolver);
+    if (auto Kind = kindForDecl(TD->getDecl(), Resolver))
+      return Kind;
   if (isa<ObjCObjectPointerType>(TP))
     return HighlightingKind::Class;
   if (auto *TD = TP->getAsTagDecl())
-    return kindForDecl(TD, Resolver);
-  return llvm::None;
+    if (auto K = kindForDecl(TD, Resolver))
+      return K;
+  return HighlightingKind::Type;
 }
 
 // Whether T is const in a loose sense - is a variable with this type readonly?
 bool isConst(QualType T) {
   if (T.isNull())
     return false;
   T = T.getNonReferenceType();
   if (T.isConstQualified())

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

const char *TestCases[] = {
         double $Field_decl[[SomeMember]];
       };
       struct {
       } $Variable_def[[S]];
       void $Function_def[[foo]](int $Parameter_def[[A]], $Class[[AS]] $Parameter_def[[As]]) {
         $Primitive_deduced_defaultLibrary[[auto]] $LocalVariable_def[[VeryLongVariableName]] = 12312;
         $Class[[AS]]     $LocalVariable_def[[AA]];
         $Primitive_deduced_defaultLibrary[[auto]] $LocalVariable_def[[L]] = $LocalVariable[[AA]].$Field[[SomeMember]] + $Parameter[[A]];
-        auto $LocalVariable_def[[FN]] = [ $LocalVariable[[AA]]](int $Parameter_def[[A]]) -> void {};
+        $Type_deduced[[auto]] $LocalVariable_def[[FN]] = [ $LocalVariable[[AA]]](int $Parameter_def[[A]]) -> void {};
         $LocalVariable[[FN]](12312);
       }
     )cpp",
       R"cpp(
       void $Function_decl[[foo]](int);
       void $Function_decl[[Gah]]();
       void $Function_def[[foo]]() {
-        auto $LocalVariable_def[[Bou]] = $Function[[Gah]];
+        $Type_deduced[[auto]] $LocalVariable_def[[Bou]] = $Function[[Gah]];
       }
       struct $Class_def[[A]] {
         void $Method_decl[[abc]]();
       };
     )cpp",
       R"cpp(
       namespace $Namespace_decl[[abc]] {
         template<typename $TemplateParameter_def[[T]]>
)cpp",
       class $Class_def[[Foo]] {};
       $Enum_deduced[[auto]] $Variable_def[[AE]] = $Enum[[E]]::$EnumConstant_readonly[[E]];
       $Class_deduced[[auto]] $Variable_def[[AF]] = $Class[[Foo]]();
       $Class_deduced[[decltype]](auto) $Variable_def[[AF2]] = $Class[[Foo]]();
       $Class_deduced[[auto]] *$Variable_def[[AFP]] = &$Variable[[AF]];
       $Enum_deduced[[auto]] &$Variable_def[[AER]] = $Variable[[AE]];
       $Primitive_deduced_defaultLibrary[[auto]] $Variable_def[[Form]] = 10.2 + 2 * 4;
       $Primitive_deduced_defaultLibrary[[decltype]]($Variable[[Form]]) $Variable_def[[F]] = 10;
-      auto $Variable_def[[Fun]] = []()->void{};
+      $Type_deduced[[auto]] $Variable_def[[Fun]] = []()->void{};
     )cpp",
       R"cpp(
       class $Class_def[[G]] {};
       template<$Class[[G]] *$TemplateParameter_def_readonly[[U]]>
       class $Class_def[[GP]] {};
       template<$Class[[G]] &$TemplateParameter_def_readonly[[U]]>
       class $Class_def[[GR]] {};
       template<int *$TemplateParameter_def_readonly[[U]]>
)cpp",
       )cpp",
       // no crash
       R"cpp(
         struct $Class_def[[Foo]] {
           void $Method_decl[[foo]]();
         };
 
         void $Function_def[[s]]($Class[[Foo]] $Parameter_def[[f]]) {
-          auto $LocalVariable_def[[k]] = &$Class[[Foo]]::$Method[[foo]];
+          $Type_deduced[[auto]] $LocalVariable_def[[k]] = &$Class[[Foo]]::$Method[[foo]];
           ($Parameter[[f]].*$LocalVariable[[k]])(); // no crash on VisitCXXMemberCallExpr
         }
       )cpp"};
   for (const auto &TestCase : TestCases)
     // Mask off scope modifiers to keep the tests manageable.
     // They're tested separately.
     checkHighlightings(TestCase, {}, ~ScopeModifierMask);
 
const char *TestCases[] = {
       )cpp",
       R"cpp(
         void $Function_globalScope[[foo]](int $Parameter_functionScope[[y]]) {
           int $LocalVariable_functionScope[[z]];
         }
       )cpp",
       R"cpp(
         // Lambdas are considered functions, not classes.
-        auto $Variable_fileScope[[x]] = [$LocalVariable_functionScope[[m]](42)] {
+        $Type_fileScope[[auto]] $Variable_fileScope[[x]] = [$LocalVariable_functionScope[[m]](42)] {
           return $LocalVariable_functionScope[[m]];
         };
       )cpp",
       R"cpp(
         // Classes in functions are classes.
         void $Function_globalScope[[foo]]() {
           class $Class_functionScope[[X]] {
             int $Field_classScope[[x]];