[clangd] Expose more dependent-name detail via semanticTokens

[sammccall]

Summary

This change makes dependentName a modifier, rather than a token type.
It can be combined with:

• type (new, standard) - this combination replaces dependentType like T::typename Foo
• unknown (new, nonstandard) - for general dependent names
• Field, etc - when the name is dependent but we heuristically resolve it

While here, fix cases where template-template-parameter cases were
incorrectly flagged as type-dependent.
And the merging of modifiers when resolving conflicts accidentally
happens to work around a bug that showed up in a test.

The behavior observed through the pre-standard protocol should be mostly
unchanged (it'll see the bugfixes only). This is done in a somehat
fragile way but it's not expected to live long.

[nridge]

Looks great, thanks again for doing this!

clang-tools-extra/clangd/SemanticHighlighting.cpp

254

I like that this ends up with a concrete kind + dependent modifier, to give a hint that the concrete kind was determined heuristically :)

Maybe we could adjust the comment at the top of the function to call this behaviour out.

clang-tools-extra/clangd/SemanticHighlighting.h

78

Just Dependent might be enough

[sammccall]

clang-tools-extra/clangd/SemanticHighlighting.cpp

254

Right! I like this too but forgot do doc it. Done.

clang-tools-extra/clangd/SemanticHighlighting.h

78

AFAICS the current implementation is closer to "dependent name" than "dependent", I think.

For example, in the RHS of template <typename T> using Val = T::value_type, both "T" and "value_type" certainly refer to dependent types. But only value_type is a dependent name, and only value_type gets the old kinds/new modifier.

---

Or are you proposing we change the implementation too?

It's not intuitively which version would be more useful. FWIW I have the current DependentName kind highlighted in bold bright orange, and I find it really helpful :-) When there are errors and RecoveryExpr kicks in, it colors the resulting unresolved names, which I like surprisingly much.

[nridge]

clang-tools-extra/clangd/SemanticHighlighting.h

78

I like the current impl as well, was not proposing a change to it. I was just quibbling about the name. Please feel free to ignore, it makes sense to be consistent with clang's terminology.

clang-tools-extra/clangd/SemanticHighlighting.h

enum class HighlightingKind {
   Method,
   StaticMethod,
   Field,
   StaticField,
   Class,
   Enum,
   EnumConstant,
   Typedef,
-  DependentType,
-  DependentName,
+  Type,
+  Unknown,
   Namespace,
   TemplateParameter,
   Concept,
   Primitive,
   Macro,
 
   // This one is different from the other kinds as it's a line style
   // rather than a token style.
   InactiveCode,
 
   LastKind = InactiveCode
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingKind K);
 
 enum class HighlightingModifier {
   Declaration,
   // FIXME: Definition (needs findExplicitReferences support)
   Deprecated,
   Deduced,
   Readonly,
   Static,
   Abstract,
+  DependentName,
 
   FunctionScope,
   ClassScope,
   FileScope,
   GlobalScope,
 
   LastModifier = GlobalScope
 };

clang-tools-extra/clangd/SemanticHighlighting.cpp

if (L.isFileID())
     return SM.isWrittenInMainFile(L) ? L : SourceLocation{};
   // Tokens expanded from the macro body contribute no highlightings.
   if (!SM.isMacroArgExpansion(L))
     return {};
   // Tokens expanded from macro args are potentially highlightable.
   return getHighlightableSpellingToken(SM.getImmediateSpellingLoc(L), SM);
 }
 
-unsigned evaluateHighlightPriority(HighlightingKind Kind) {
+unsigned evaluateHighlightPriority(const HighlightingToken &Tok) {
   enum HighlightPriority { Dependent = 0, Resolved = 1 };
-  return Kind == HighlightingKind::DependentType ||
-                 Kind == HighlightingKind::DependentName
+  return (Tok.Modifiers & (1 << uint32_t(HighlightingModifier::DependentName)))
              ? Dependent
              : Resolved;
 }
 
-// Sometimes we get conflicts between findExplicitReferences() returning
-// a heuristic result for a dependent name (e.g. Method) and
-// CollectExtraHighlighting returning a fallback dependent highlighting (e.g.
-// DependentName). In such cases, resolve the conflict in favour of the
-// resolved (non-dependent) highlighting.
-// With macros we can get other conflicts (if a spelled token has multiple
-// expansions with different token types) which we can't usefully resolve.
+// Sometimes we get multiple tokens at the same location:
+//
+// - findExplicitReferences() returns a heuristic result for a dependent name
+//   (e.g. Method) and CollectExtraHighlighting returning a fallback dependent
+//   highlighting (e.g. Unknown+Dependent).
+// - macro arguments are expanded multiple times and have different roles
+// - broken code recovery produces several AST nodes at the same location
+//
+// We should either resolve these to a single token, or drop them all.
+// Our heuristics are:
+//
+// - token kinds that come with "dependent-name" modifiers are less reliable
+//   (these tend to be vague, like Type or Unknown)
+// - if we have multiple equally reliable kinds, drop token rather than guess
+// - take the union of modifiers from all tokens
+//
+// In particular, heuristically resolved dependent names get their heuristic
+// kind, plus the dependent modifier.
 llvm::Optional<HighlightingToken>
 resolveConflict(ArrayRef<HighlightingToken> Tokens) {
   if (Tokens.size() == 1)
     return Tokens[0];
 
   if (Tokens.size() != 2)
     return llvm::None;
 
-  unsigned Priority1 = evaluateHighlightPriority(Tokens[0].Kind);
-  unsigned Priority2 = evaluateHighlightPriority(Tokens[1].Kind);
-  if (Priority1 == Priority2)
+  unsigned Priority1 = evaluateHighlightPriority(Tokens[0]);
+  unsigned Priority2 = evaluateHighlightPriority(Tokens[1]);
+  if (Priority1 == Priority2 && Tokens[0].Kind != Tokens[1].Kind)
     return llvm::None;
-  return Priority1 > Priority2 ? Tokens[0] : Tokens[1];
+  auto Result = Priority1 > Priority2 ? Tokens[0] : Tokens[1];
+  Result.Modifiers = Tokens[0].Modifiers | Tokens[1].Modifiers;
+  return Result;
 }
 
 /// Consumes source locations and maps them to text ranges for highlightings.
 class HighlightingsBuilder {
 public:
   HighlightingsBuilder(const ParsedAST &AST)
       : TB(AST.getTokens()), SourceMgr(AST.getSourceManager()),
         LangOpts(AST.getLangOpts()) {}
if (auto K = kindForType(AT->getDeducedType().getTypePtrOrNull())) {
         Tok.addModifier(*Mod);
     }
     return true;
   }
 
   bool VisitOverloadExpr(OverloadExpr *E) {
     if (!E->decls().empty())
       return true; // handled by findExplicitReferences.
-    auto &Tok = H.addToken(E->getNameLoc(), HighlightingKind::DependentName);
+    auto &Tok = H.addToken(E->getNameLoc(), HighlightingKind::Unknown)
+                    .addModifier(HighlightingModifier::DependentName);
     if (llvm::isa<UnresolvedMemberExpr>(E))
       Tok.addModifier(HighlightingModifier::ClassScope);
     // other case is UnresolvedLookupExpr, scope is unknown.
     return true;
   }
 
   bool VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) {
-    H.addToken(E->getMemberNameInfo().getLoc(), HighlightingKind::DependentName)
+    H.addToken(E->getMemberNameInfo().getLoc(), HighlightingKind::Unknown)
+        .addModifier(HighlightingModifier::DependentName)
         .addModifier(HighlightingModifier::ClassScope);
     return true;
   }
 
   bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
-    H.addToken(E->getNameInfo().getLoc(), HighlightingKind::DependentName)
+    H.addToken(E->getNameInfo().getLoc(), HighlightingKind::Unknown)
+        .addModifier(HighlightingModifier::DependentName)
         .addModifier(HighlightingModifier::ClassScope);
     return true;
   }
 
   bool VisitDependentNameTypeLoc(DependentNameTypeLoc L) {
-    H.addToken(L.getNameLoc(), HighlightingKind::DependentType)
+    H.addToken(L.getNameLoc(), HighlightingKind::Type)
+        .addModifier(HighlightingModifier::DependentName)
         .addModifier(HighlightingModifier::ClassScope);
     return true;
   }
 
   bool VisitDependentTemplateSpecializationTypeLoc(
       DependentTemplateSpecializationTypeLoc L) {
-    H.addToken(L.getTemplateNameLoc(), HighlightingKind::DependentType)
+    H.addToken(L.getTemplateNameLoc(), HighlightingKind::Type)
+        .addModifier(HighlightingModifier::DependentName)
         .addModifier(HighlightingModifier::ClassScope);
     return true;
   }
 
   bool TraverseTemplateArgumentLoc(TemplateArgumentLoc L) {
-    switch (L.getArgument().getKind()) {
-    case TemplateArgument::Template:
-    case TemplateArgument::TemplateExpansion:
-      // FIXME: this isn't *always* a dependent template name.
-      H.addToken(L.getTemplateNameLoc(), HighlightingKind::DependentType);
+    // Handle template template arguments only (other arguments are handled by
+    // their Expr, TypeLoc etc values).
+    if (L.getArgument().getKind() != TemplateArgument::Template &&
+        L.getArgument().getKind() != TemplateArgument::TemplateExpansion)
+      return RecursiveASTVisitor::TraverseTemplateArgumentLoc(L);
+
+    TemplateName N = L.getArgument().getAsTemplateOrTemplatePattern();
+    switch (N.getKind()) {
+    case TemplateName::OverloadedTemplate:
+      // Template template params must always be class templates.
+      // Don't bother to try to work out the scope here.
+      H.addToken(L.getTemplateNameLoc(), HighlightingKind::Class);
       break;
-    default:
+    case TemplateName::DependentTemplate:
+    case TemplateName::AssumedTemplate:
+      H.addToken(L.getTemplateNameLoc(), HighlightingKind::Class)
+          .addModifier(HighlightingModifier::DependentName);
+      break;
+    case TemplateName::Template:
+    case TemplateName::QualifiedTemplate:
+    case TemplateName::SubstTemplateTemplateParm:
+    case TemplateName::SubstTemplateTemplateParmPack:
+      // Names that could be resolved to a TemplateDecl are handled elsewhere.
       break;
     }
     return RecursiveASTVisitor::TraverseTemplateArgumentLoc(L);
   }
 
   // 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, so we visit
   // them here.
   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc Q) {
     if (NestedNameSpecifier *NNS = Q.getNestedNameSpecifier()) {
       if (NNS->getKind() == NestedNameSpecifier::Identifier)
-        H.addToken(Q.getLocalBeginLoc(), HighlightingKind::DependentType)
+        H.addToken(Q.getLocalBeginLoc(), HighlightingKind::Type)
+            .addModifier(HighlightingModifier::DependentName)
             .addModifier(HighlightingModifier::ClassScope);
     }
     return RecursiveASTVisitor::TraverseNestedNameSpecifierLoc(Q);
   }
 
 private:
   HighlightingsBuilder &H;
 };
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingKind K) {
   case HighlightingKind::Class:
     return OS << "Class";
   case HighlightingKind::Enum:
     return OS << "Enum";
   case HighlightingKind::EnumConstant:
     return OS << "EnumConstant";
   case HighlightingKind::Typedef:
     return OS << "Typedef";
-  case HighlightingKind::DependentType:
-    return OS << "DependentType";
-  case HighlightingKind::DependentName:
-    return OS << "DependentName";
+  case HighlightingKind::Type:
+    return OS << "Type";
+  case HighlightingKind::Unknown:
+    return OS << "Unknown";
   case HighlightingKind::Namespace:
     return OS << "Namespace";
   case HighlightingKind::TemplateParameter:
     return OS << "TemplateParameter";
   case HighlightingKind::Concept:
     return OS << "Concept";
   case HighlightingKind::Primitive:
     return OS << "Primitive";
case HighlightingKind::Field:
     return "property";
   case HighlightingKind::Class:
     return "class";
   case HighlightingKind::Enum:
     return "enum";
   case HighlightingKind::EnumConstant:
     return "enumMember";
   case HighlightingKind::Typedef:
+  case HighlightingKind::Type:
     return "type";
-  case HighlightingKind::DependentType:
-  case HighlightingKind::DependentName:
-    return "dependent"; // nonstandard
+  case HighlightingKind::Unknown:
+    return "unknown"; // nonstandard
   case HighlightingKind::Namespace:
     return "namespace";
   case HighlightingKind::TemplateParameter:
     return "typeParameter";
   case HighlightingKind::Concept:
     return "concept"; // nonstandard
   case HighlightingKind::Primitive:
     return "type";
llvm::StringRef toSemanticTokenModifier(HighlightingModifier Modifier) {
   case HighlightingModifier::Readonly:
     return "readonly";
   case HighlightingModifier::Static:
     return "static";
   case HighlightingModifier::Deduced:
     return "deduced"; // nonstandard
   case HighlightingModifier::Abstract:
     return "abstract";
+  case HighlightingModifier::DependentName:
+    return "dependentName"; // nonstandard
   case HighlightingModifier::FunctionScope:
     return "functionScope"; // nonstandard
   case HighlightingModifier::ClassScope:
     return "classScope"; // nonstandard
   case HighlightingModifier::FileScope:
     return "fileScope"; // nonstandard
   case HighlightingModifier::GlobalScope:
     return "globalScope"; // nonstandard
llvm::StringRef toTextMateScope(HighlightingKind Kind) {
   case HighlightingKind::Class:
     return "entity.name.type.class.cpp";
   case HighlightingKind::Enum:
     return "entity.name.type.enum.cpp";
   case HighlightingKind::EnumConstant:
     return "variable.other.enummember.cpp";
   case HighlightingKind::Typedef:
     return "entity.name.type.typedef.cpp";
-  case HighlightingKind::DependentType:
+  case HighlightingKind::Type:
+    // Fragile: all paths emitting `Type` are dependent names for now.
+    // But toTextMateScope is going away soon.
     return "entity.name.type.dependent.cpp";
-  case HighlightingKind::DependentName:
+  case HighlightingKind::Unknown:
+    // Fragile: all paths emitting `Unknown` are dependent names for now.
+    // But toTextMateScope is going away soon.
     return "entity.name.other.dependent.cpp";
   case HighlightingKind::Namespace:
     return "entity.name.namespace.cpp";
   case HighlightingKind::TemplateParameter:
     return "entity.name.type.template.cpp";
   case HighlightingKind::Concept:
     return "entity.name.type.concept.cpp";
   case HighlightingKind::Primitive:

clang-tools-extra/clangd/test/initialize-params.test

 # CHECK-NEXT:        },
 # CHECK-NEXT:        "legend": {
 # CHECK-NEXT:          "tokenModifiers": [
 # CHECK-NEXT:            "declaration",
 # CHECK-NEXT:            "deprecated",
 # CHECK-NEXT:            "deduced",
 # CHECK-NEXT:            "readonly",
 # CHECK-NEXT:            "static",
-# CHECK-NEXT:            "abstract"
+# CHECK-NEXT:            "abstract",
+# CHECK-NEXT:            "dependentName",
 # CHECK-NEXT:            "functionScope",
 # CHECK-NEXT:            "classScope",
 # CHECK-NEXT:            "fileScope",
 # CHECK-NEXT:            "globalScope"
 # CHECK-NEXT:          ],
 # CHECK-NEXT:          "tokenTypes": [
 # CHECK-NEXT:            "variable",
 # CHECK:               ]

clang-tools-extra/clangd/test/semantic-tokens.test

 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": {
 # CHECK-NEXT:    "data": [
 #                  First line, char 5, variable, declaration+globalScope
 # CHECK-NEXT:      0,
 # CHECK-NEXT:      4,
 # CHECK-NEXT:      1,
 # CHECK-NEXT:      0,
-# CHECK-NEXT:      513
+# CHECK-NEXT:      1025
 # CHECK-NEXT:    ],
 # CHECK-NEXT:    "resultId": "1"
 # CHECK-NEXT:  }
 ---
 {"jsonrpc":"2.0","method":"textDocument/didChange","params":{
   "textDocument": {"uri":"test:///foo.cpp","version":2},
   "contentChanges":[{"text":"int x = 2;\nint y = 3;"}]
 }}

 # CHECK-NEXT:    "edits": [
 # CHECK-NEXT:      {
 # CHECK-NEXT:        "data": [
 #                      Next line, char 5, variable, declaration+globalScope
 # CHECK-NEXT:          1,
 # CHECK-NEXT:          4,
 # CHECK-NEXT:          1,
 # CHECK-NEXT:          0,
-# CHECK-NEXT:          513
+# CHECK-NEXT:          1025
 # CHECK-NEXT:        ],
 #                    Inserted at position 1
 # CHECK-NEXT:        "deleteCount": 0,
 # CHECK-NEXT:        "start": 5
 # CHECK-NEXT:      }
 # CHECK-NEXT:    ],
 # CHECK-NEXT:    "resultId": "2"
 # CHECK-NEXT:  }
 ---
 # Incremental token request with incorrect baseline => full tokens list.
 {"jsonrpc":"2.0","id":2,"method":"textDocument/semanticTokens/full/delta","params":{
   "textDocument": {"uri":"test:///foo.cpp"},
   "previousResultId": "bogus"
 }}
 # CHECK:       "id": 2,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": {
 # CHECK-NEXT:    "data": [
 # CHECK-NEXT:      0,
 # CHECK-NEXT:      4,
 # CHECK-NEXT:      1,
 # CHECK-NEXT:      0,
-# CHECK-NEXT:      513,
+# CHECK-NEXT:      1025,
 # CHECK-NEXT:      1,
 # CHECK-NEXT:      4,
 # CHECK-NEXT:      1,
 # CHECK-NEXT:      0,
-# CHECK-NEXT:      513
+# CHECK-NEXT:      1025
 # CHECK-NEXT:    ],
 # CHECK-NEXT:    "resultId": "3"
 # CHECK-NEXT:  }
 ---
 {"jsonrpc":"2.0","id":3,"method":"shutdown"}
 ---
 {"jsonrpc":"2.0","method":"exit"}

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

static const std::map<HighlightingKind, std::string> KindToString{
       {HighlightingKind::Enum, "Enum"},
       {HighlightingKind::Namespace, "Namespace"},
       {HighlightingKind::EnumConstant, "EnumConstant"},
       {HighlightingKind::Field, "Field"},
       {HighlightingKind::StaticField, "StaticField"},
       {HighlightingKind::Method, "Method"},
       {HighlightingKind::StaticMethod, "StaticMethod"},
       {HighlightingKind::Typedef, "Typedef"},
-      {HighlightingKind::DependentType, "DependentType"},
-      {HighlightingKind::DependentName, "DependentName"},
+      {HighlightingKind::Type, "Type"},
+      {HighlightingKind::Unknown, "Unknown"},
       {HighlightingKind::TemplateParameter, "TemplateParameter"},
       {HighlightingKind::Concept, "Concept"},
       {HighlightingKind::Primitive, "Primitive"},
       {HighlightingKind::Macro, "Macro"}};
   std::vector<HighlightingToken> ExpectedTokens;
   for (const auto &KindString : KindToString) {
     std::vector<HighlightingToken> Toks = makeHighlightingTokens(
         Test.ranges(KindString.second), KindString.first);
)cpp",
       namespace $Namespace_decl[[abc]] {
         template<typename $TemplateParameter_decl[[T]]>
         struct $Class_decl[[A]] {
           $TemplateParameter[[T]] $Field_decl[[t]];
         };
       }
       template<typename $TemplateParameter_decl[[T]]>
       struct $Class_decl[[C]] : $Namespace[[abc]]::$Class[[A]]<$TemplateParameter[[T]]> {
-        typename $TemplateParameter[[T]]::$DependentType[[A]]* $Field_decl[[D]];
+        typename $TemplateParameter[[T]]::$Type_dependentName[[A]]* $Field_decl[[D]];
       };
       $Namespace[[abc]]::$Class[[A]]<int> $Variable_decl[[AA]];
       typedef $Namespace[[abc]]::$Class[[A]]<int> $Class_decl[[AAA]];
       struct $Class_decl[[B]] {
         $Class_decl[[B]]();
         ~$Class[[B]](); // FIXME: inconsistent with constructor
         void operator<<($Class[[B]]);
         $Class[[AAA]] $Field_decl[[AA]];
)cpp",
       class $Class_decl[[Foo]] {};
 
       template<typename $TemplateParameter_decl[[T]]>
       void $Function_decl[[foo]]($TemplateParameter[[T]] ...);
     )cpp",
       R"cpp(
       template <class $TemplateParameter_decl[[T]]>
       struct $Class_decl[[Tmpl]] {$TemplateParameter[[T]] $Field_decl[[x]] = 0;};
-      // FIXME: highlights dropped due to conflicts.
-      // explicitReferenceTargets reports ClassTemplateSpecializationDecl twice
-      // at its location, calling it a declaration/non-declaration once each.
-      extern template struct Tmpl<float>;
-      template struct Tmpl<double>;
+      extern template struct $Class_decl[[Tmpl]]<float>;
+      template struct $Class_decl[[Tmpl]]<double>;
     )cpp",
       // This test is to guard against highlightings disappearing when using
       // conversion operators as their behaviour in the clang AST differ from
       // other CXXMethodDecls.
       R"cpp(
       class $Class_decl[[Foo]] {};
       struct $Class_decl[[Bar]] {
         explicit operator $Class[[Foo]]*() const;
)cpp",
       };
     )cpp",
       R"cpp(
       template <class $TemplateParameter_decl[[T]]>
       void $Function_decl[[phase1]]($TemplateParameter[[T]]);
       template <class $TemplateParameter_decl[[T]]>
       void $Function_decl[[foo]]($TemplateParameter[[T]] $Parameter_decl[[P]]) {
         $Function[[phase1]]($Parameter[[P]]);
-        $DependentName[[phase2]]($Parameter[[P]]);
+        $Unknown_dependentName[[phase2]]($Parameter[[P]]);
       }
     )cpp",
       R"cpp(
       class $Class_decl[[A]] {
         template <class $TemplateParameter_decl[[T]]>
         void $Method_decl[[bar]]($TemplateParameter[[T]]);
       };
 
)cpp",
       struct $Class_decl[[B]] {
         void $Method_decl[[bar]]() {
           $Class[[A]]::$StaticMethod_static[[foo]]($TemplateParameter[[T]]());
         }
       };
     )cpp",
       R"cpp(
       template <class $TemplateParameter_decl[[T]]>
-      void $Function_decl[[foo]](typename $TemplateParameter[[T]]::$DependentType[[Type]]
-                                            = $TemplateParameter[[T]]::$DependentName[[val]]);
+      void $Function_decl[[foo]](typename $TemplateParameter[[T]]::$Type_dependentName[[Type]]
+                                            = $TemplateParameter[[T]]::$Unknown_dependentName[[val]]);
     )cpp",
       R"cpp(
       template <class $TemplateParameter_decl[[T]]>
       void $Function_decl[[foo]]($TemplateParameter[[T]] $Parameter_decl[[P]]) {
-        $Parameter[[P]].$DependentName[[Field]];
+        $Parameter[[P]].$Unknown_dependentName[[Field]];
       }
     )cpp",
       R"cpp(
       template <class $TemplateParameter_decl[[T]]>
       class $Class_decl[[A]] {
         int $Method_decl[[foo]]() {
-          return $TemplateParameter[[T]]::$DependentName[[Field]];
+          return $TemplateParameter[[T]]::$Unknown_dependentName[[Field]];
         }
       };
     )cpp",
       // Highlighting the using decl as the underlying using shadow decl.
       R"cpp(
       void $Function_decl[[foo]]();
       using ::$Function[[foo]];
     )cpp",

 sizeof...($TemplateParameter[[Elements]]);
       };
     )cpp",
       // More dependent types
       R"cpp(
       template <typename $TemplateParameter_decl[[T]]>
       struct $Class_decl[[Waldo]] {
         using $Typedef_decl[[Location1]] = typename $TemplateParameter[[T]]
-            ::$DependentType[[Resolver]]::$DependentType[[Location]];
+            ::$Type_dependentName[[Resolver]]::$Type_dependentName[[Location]];
         using $Typedef_decl[[Location2]] = typename $TemplateParameter[[T]]
-            ::template $DependentType[[Resolver]]<$TemplateParameter[[T]]>
-            ::$DependentType[[Location]];
+            ::template $Type_dependentName[[Resolver]]<$TemplateParameter[[T]]>
+            ::$Type_dependentName[[Location]];
         using $Typedef_decl[[Location3]] = typename $TemplateParameter[[T]]
-            ::$DependentType[[Resolver]]
-            ::template $DependentType[[Location]]<$TemplateParameter[[T]]>;
+            ::$Type_dependentName[[Resolver]]
+            ::template $Type_dependentName[[Location]]<$TemplateParameter[[T]]>;
         static const int $StaticField_decl_readonly_static[[Value]] = $TemplateParameter[[T]]
-            ::$DependentType[[Resolver]]::$DependentName[[Value]];
+            ::$Type_dependentName[[Resolver]]::$Unknown_dependentName[[Value]];
       };
     )cpp",
       // Dependent name with heuristic target
       R"cpp(
       template <typename>
       struct $Class_decl[[Foo]] {
         int $Field_decl[[Waldo]];
         void $Method_decl[[bar]]() {
-          $Class[[Foo]]().$Field[[Waldo]];
+          $Class[[Foo]]().$Field_dependentName[[Waldo]];
         }
         template <typename $TemplateParameter_decl[[U]]>
         void $Method_decl[[bar1]]() {
-          $Class[[Foo]]<$TemplateParameter[[U]]>().$Field[[Waldo]];
+          $Class[[Foo]]<$TemplateParameter[[U]]>().$Field_dependentName[[Waldo]];
         }
       };
     )cpp",
       // Concepts
       R"cpp(
       template <typename $TemplateParameter_decl[[T]]>
       concept $Concept_decl[[Fooable]] = 
           requires($TemplateParameter[[T]] $Parameter_decl[[F]]) {
-            $Parameter[[F]].$DependentName[[foo]]();
+            $Parameter[[F]].$Unknown_dependentName[[foo]]();
           };
       template <typename $TemplateParameter_decl[[T]]>
           requires $Concept[[Fooable]]<$TemplateParameter[[T]]>
       void $Function_decl[[bar]]($TemplateParameter[[T]] $Parameter_decl[[F]]) {
-        $Parameter[[F]].$DependentName[[foo]]();
+        $Parameter[[F]].$Unknown_dependentName[[foo]]();
       }
     )cpp",
       // Dependent template name
       R"cpp(
       template <template <typename> class> struct $Class_decl[[A]] {};
       template <typename $TemplateParameter_decl[[T]]>
       using $Typedef_decl[[W]] = $Class[[A]]<
-        $TemplateParameter[[T]]::template $DependentType[[Waldo]]
+        $TemplateParameter[[T]]::template $Class_dependentName[[Waldo]]
       >;
     )cpp",
       R"cpp(
       class $Class_decl_abstract[[Abstract]] {
         virtual void $Method_decl_abstract[[pure]]() = 0;
         virtual void $Method_decl[[impl]]();
       };
       )cpp",
const char *TestCases[] = {
         template <int $TemplateParameter_classScope[[T]]>
         class $Class_globalScope[[X]] {
         };
       )cpp",
       R"cpp(
         // No useful scope for template parameters of variable templates.
         template <typename $TemplateParameter[[A]]>
         unsigned $Variable_globalScope[[X]] =
-          $TemplateParameter[[A]]::$DependentName_classScope[[x]];
+          $TemplateParameter[[A]]::$Unknown_classScope[[x]];
       )cpp",
       R"cpp(
         #define $Macro_globalScope[[X]] 1
         int $Variable_globalScope[[Y]] = $Macro_globalScope[[X]];
       )cpp",
   };
 
   for (const char *Test : TestCases)