[clangd] Implement semantic token modifier "definition"

[ckandeler]

Indentation.

[ckandeler]

Addressed clang-format complaints.

[dgoldman]

clang-tools-extra/clangd/SemanticHighlighting.cpp

892–894

Do we need similar code for ObjCProtocolDecl? Also should ObjCImplDecl be considered definitions here?

[ckandeler]

clang-tools-extra/clangd/SemanticHighlighting.cpp

892–894

Possibly. I know next to nothing about Objective C, so I'll just do as I'm told here. On a related note, the code above regarding ObjCMethodDecl does not seem to do anything, i.e. none of the constructs that to my eye appear to be Objective-C methods get the "def" modifier.

[dgoldman]

clang-tools-extra/clangd/SemanticHighlighting.cpp

892–894

Gotcha, yeah I think it makes sense to do the same for ObjCImplDecl, ObjCProtocolDecl, and ObjCCategoryDecl.

re: methods, ah yeah, that's because canHighlightName will return false since we need to special case handling for ObjC methods since their names can be split across non contiguous tokens (selectors). Instead, would need to update VisitObjCMethodDecl and highlightObjCSelector.

[ckandeler]

Objective-C improvements.

[ckandeler]

Addressed remaining Objective-C issues

[ckandeler]

ping

[dgoldman]

clang-tools-extra/clangd/SemanticHighlighting.cpp

882

Instead of doing it like this, I wonder if would make more sense to call getDefinition from https://cs.github.com/llvm/llvm-project/blob/ae071a59bc6cc09e0e0043e0ef1d9725853f1681/clang-tools-extra/clangd/XRefs.cpp#L76 and if it matches Decl, add the Definition modifier?

[ckandeler]

clang-tools-extra/clangd/SemanticHighlighting.cpp

882

Won't that incur an additional look-up or some other type of work? I'm not deeply familiar with the implementation, but a cursory glance seems to suggests that isThisDeclarationADefinition() is just an accessor, while getDefinition() "does things".

[sammccall]

This is fantastic, I'm really not sure how I missed it, sorry :-(

clang-tools-extra/clangd/SemanticHighlighting.cpp

878–879

nit: move this comment to above the inner if?

882

Yeah, getDefinition may need to walk over all the redecl chain to find the actual def, which we don't care about.
Probably not a big deal, but it's not quite the right abstraction, and that function isn't exposed publicly currently anyway.

882

can you pull these checks out into a function bool isUniqueDefinition or so?

("unique" because I think we're intentionally returning false for things like NamespaceDecls which are definitions but may be multiply-defined)

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

59

I wonder if we want to special case when we're printing _def to not print _decl and instead assert that it is present?

It's a bit irregular but as you've seen this gets everywhere in the tests, and the noise level seems concerning.

[ckandeler]

Adapted according to latest comments.

[ckandeler]

clang-tools-extra/clangd/SemanticHighlighting.cpp

79

I'm not 100% sure about this one, by the way. I've just never heard anyone talk about a "parameter definition".

[ckandeler]

So, is this okay to merge now?

[sammccall]

Thanks! Sorry for letting this drop.

clang-tools-extra/clangd/SemanticHighlighting.cpp

79

ParmVarDecls should be marked as definition. They definitely are in the formal C++ sense, and they're so similar to local variables that I think we have to be consistent.
(There are other formally-definitions that we're not marking here like NamespaceDecl, but they seem unlikely to cause confusion).

I've just never heard anyone talk about a "parameter definition".

Yeah, I suspect this is mostly because:

• there's no definition/declaration distinction - you can't forward-declare a param.
• imprecise mental models of params as aliases to the written args rather than copies of them (at least I sometimes think this way)

But I think it's important we treat these consistently with e.g. local variables since they're so similar.

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

62

can you add a brief comment here: "// _decl_def is common and redundant, just print _def instead."

[ckandeler]

Use modifier also for parameters,

[sammccall]

Just realized ParmVarDecls (and template args) are maybe more complicated than I thought: I suppose they're only really definitions if the function/template has a body (i.e. is itself a definition).
Anyway don't worry about that, let's get this landed and maybe refine later.

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

845–846

nit: T should be a def here too.
it's not critical so if this case is hard at all feel free to leave it.

[ckandeler]

Template parameters are definitions

[ckandeler]

Everything good now?

[sammccall]

In D127403#3861619, @ckandeler wrote:

Everything good now?

Yes :-)
(I also marked it as accepted above, so feel free to land!)
Thank you!

[ckandeler]

Could you please land it for me? I don't have the privileges. (How does one attain those, by the way?)

[Trass3r]

https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access

[nridge]

I went ahead and landed this for you

[ormris]

Looks like there are some test failures associated with this commit: https://lab.llvm.org/buildbot/#/builders/123/builds/13698

The change list is a bit confusing, as it's only showing LLVM commits. But the change list includes the commit before and the commit after this one.

The tests in this patch are also failing in our internal CI. @ckandeler, could you take a look?

[nridge]

Looks like an error introduced when rebasing the patch: a recently added test case (for https://github.com/clangd/clangd/issues/1222) needs to be updated to reflect the _decl to _def change that this patch makes to all semantic highlighting tests. I'll land a fix.

[thakis]

Looks like this breaks check-clangd everywhere, eg http://45.33.8.238/linux/89237/step_9.txt

[nridge]

Landing the fix now

[nridge]

Landed https://reviews.llvm.org/rGc93430bae4fc

[thakis]

In D127403#3863641, @nridge wrote:

Landed https://reviews.llvm.org/rGc93430bae4fc

Still failing with that: http://45.33.8.238/linux/89240/step_9.txt

Time to revert to green? Things have been broken for a few hours now. Maybe time to regroup and analyze async?

[nridge]

In D127403#3863686, @thakis wrote:

In D127403#3863641, @nridge wrote:

Landed https://reviews.llvm.org/rGc93430bae4fc

Still failing with that: http://45.33.8.238/linux/89240/step_9.txt

Fixed in https://reviews.llvm.org/rGd5a99bf5e134, and confirmed via a local build and test run that the tests are passing. Apologies for the breakage.

[ckandeler]

In D127403#3863713, @nridge wrote:

In D127403#3863686, @thakis wrote:

In D127403#3863641, @nridge wrote:

Landed https://reviews.llvm.org/rGc93430bae4fc

Still failing with that: http://45.33.8.238/linux/89240/step_9.txt

Fixed in https://reviews.llvm.org/rGd5a99bf5e134, and confirmed via a local build and test run that the tests are passing. Apologies for the breakage.

Thanks.

clang-tools-extra/clangd/SemanticHighlighting.h

enum class HighlightingKind {
 
   LastKind = InactiveCode
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingKind K);
 
 enum class HighlightingModifier {
   Declaration,
-  // FIXME: Definition (needs findExplicitReferences support)
+  Definition,
   Deprecated,
   Deduced,
   Readonly,
   Static,
   Abstract,
   Virtual,
   DependentName,
   DefaultLibrary,

clang-tools-extra/clangd/SemanticHighlighting.cpp

bool canHighlightName(DeclarationName Name) {
   case DeclarationName::CXXDeductionGuideName:
   case DeclarationName::CXXLiteralOperatorName:
   case DeclarationName::CXXUsingDirective:
     return false;
   }
   llvm_unreachable("invalid name kind");
 }
 
+bool isUniqueDefinition(const NamedDecl *Decl) {
+  if (auto *Func = dyn_cast<FunctionDecl>(Decl))
+    return Func->isThisDeclarationADefinition();
+  if (auto *Klass = dyn_cast<CXXRecordDecl>(Decl))
+    return Klass->isThisDeclarationADefinition();
+  if (auto *Iface = dyn_cast<ObjCInterfaceDecl>(Decl))
+    return Iface->isThisDeclarationADefinition();
+  if (auto *Proto = dyn_cast<ObjCProtocolDecl>(Decl))
+    return Proto->isThisDeclarationADefinition();
+  if (auto *Var = dyn_cast<VarDecl>(Decl))
+    return !isa<ParmVarDecl>(Var) && Var->isThisDeclarationADefinition();
+  return isa<ObjCCategoryDecl>(Decl) || isa<ObjCImplDecl>(Decl);
+}
+
 llvm::Optional<HighlightingKind> kindForType(const Type *TP,
                                              const HeuristicResolver *Resolver);
 llvm::Optional<HighlightingKind>
 kindForDecl(const NamedDecl *D, const HeuristicResolver *Resolver) {
   if (auto *USD = dyn_cast<UsingShadowDecl>(D)) {
     if (auto *Target = USD->getTargetDecl())
       D = Target;
   }
bool VisitDeclaratorDecl(DeclaratorDecl *D) {
     if (isDefaultLibrary(Deduced))
       Tok.addModifier(HighlightingModifier::DefaultLibrary);
     return true;
   }
 
   // We handle objective-C selectors specially, because one reference can
   // cover several non-contiguous tokens.
   void highlightObjCSelector(const ArrayRef<SourceLocation> &Locs, bool Decl,
-                             bool Class, bool DefaultLibrary) {
+                             bool Def, bool Class, bool DefaultLibrary) {
     HighlightingKind Kind =
         Class ? HighlightingKind::StaticMethod : HighlightingKind::Method;
     for (SourceLocation Part : Locs) {
       auto &Tok =
           H.addToken(Part, Kind).addModifier(HighlightingModifier::ClassScope);
       if (Decl)
         Tok.addModifier(HighlightingModifier::Declaration);
+      if (Def)
+        Tok.addModifier(HighlightingModifier::Definition);
       if (Class)
         Tok.addModifier(HighlightingModifier::Static);
       if (DefaultLibrary)
         Tok.addModifier(HighlightingModifier::DefaultLibrary);
     }
   }
 
   bool VisitObjCMethodDecl(ObjCMethodDecl *OMD) {
     llvm::SmallVector<SourceLocation> Locs;
     OMD->getSelectorLocs(Locs);
-    highlightObjCSelector(Locs, /*Decl=*/true, OMD->isClassMethod(),
-                          isDefaultLibrary(OMD));
+    highlightObjCSelector(Locs, /*Decl=*/true,
+                          OMD->isThisDeclarationADefinition(),
+                          OMD->isClassMethod(), isDefaultLibrary(OMD));
     return true;
   }
 
   bool VisitObjCMessageExpr(ObjCMessageExpr *OME) {
     llvm::SmallVector<SourceLocation> Locs;
     OME->getSelectorLocs(Locs);
     bool DefaultLibrary = false;
     if (ObjCMethodDecl *OMD = OME->getMethodDecl())
       DefaultLibrary = isDefaultLibrary(OMD);
-    highlightObjCSelector(Locs, /*Decl=*/false, OME->isClassMessage(),
-                          DefaultLibrary);
+    highlightObjCSelector(Locs, /*Decl=*/false, /*Def=*/false,
+                          OME->isClassMessage(), DefaultLibrary);
     return true;
   }
 
   // Objective-C allows you to use property syntax `self.prop` as sugar for
   // `[self prop]` and `[self setProp:]` when there's no explicit `@property`
   // for `prop` as well as for class properties. We treat this like a property
   // even though semantically it's equivalent to a method expression.
   void highlightObjCImplicitPropertyRef(const ObjCMethodDecl *OMD,
findExplicitReferences(
             Tok.addModifier(HighlightingModifier::Abstract);
           if (isVirtual(Decl))
             Tok.addModifier(HighlightingModifier::Virtual);
           if (isDependent(Decl))
             Tok.addModifier(HighlightingModifier::DependentName);
           if (isDefaultLibrary(Decl))
             Tok.addModifier(HighlightingModifier::DefaultLibrary);
           if (Decl->isDeprecated())
             Tok.addModifier(HighlightingModifier::Deprecated);
+          if (R.IsDecl) {
             // Do not treat an UnresolvedUsingValueDecl as a declaration.
             // It's more common to think of it as a reference to the
             // underlying declaration.
-          if (R.IsDecl && !isa<UnresolvedUsingValueDecl>(Decl))
+            if (!isa<UnresolvedUsingValueDecl>(Decl))
               Tok.addModifier(HighlightingModifier::Declaration);
+            if (isUniqueDefinition(Decl))
+              Tok.addModifier(HighlightingModifier::Definition);
+          }
         }
       },
       AST.getHeuristicResolver());
   // Add highlightings for macro references.
   auto AddMacro = [&](const MacroOccurrence &M) {
     auto &T = Builder.addToken(M.Rng, HighlightingKind::Macro);
     T.addModifier(HighlightingModifier::GlobalScope);
     if (M.IsDefinition)
       T.addModifier(HighlightingModifier::Declaration);
   };
   for (const auto &SIDToRefs : AST.getMacros().MacroRefs)
     for (const auto &M : SIDToRefs.second)
       AddMacro(M);
   for (const auto &M : AST.getMacros().UnknownMacros)
     AddMacro(M);
case HighlightingKind::InactiveCode:
     return OS << "InactiveCode";
   }
   llvm_unreachable("invalid HighlightingKind");
 }
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingModifier K) {
   switch (K) {
   case HighlightingModifier::Declaration:
     return OS << "decl"; // abbreviation for common case
+  case HighlightingModifier::Definition:
+    return OS << "def"; // abbrevation for common case
   default:
     return OS << toSemanticTokenModifier(K);
   }
 }
 
 bool operator==(const HighlightingToken &L, const HighlightingToken &R) {
   return std::tie(L.R, L.Kind, L.Modifiers) ==
          std::tie(R.R, R.Kind, R.Modifiers);
llvm::StringRef toSemanticTokenType(HighlightingKind Kind) {
   }
   llvm_unreachable("unhandled HighlightingKind");
 }
 
 llvm::StringRef toSemanticTokenModifier(HighlightingModifier Modifier) {
   switch (Modifier) {
   case HighlightingModifier::Declaration:
     return "declaration";
+  case HighlightingModifier::Definition:
+    return "definition";
   case HighlightingModifier::Deprecated:
     return "deprecated";
   case HighlightingModifier::Readonly:
     return "readonly";
   case HighlightingModifier::Static:
     return "static";
   case HighlightingModifier::Deduced:
     return "deduced"; // nonstandard

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

 # CHECK-NEXT:      "selectionRangeProvider": true,
 # CHECK-NEXT:      "semanticTokensProvider": {
 # CHECK-NEXT:        "full": {
 # CHECK-NEXT:          "delta": true
 # CHECK-NEXT:        },
 # CHECK-NEXT:        "legend": {
 # CHECK-NEXT:          "tokenModifiers": [
 # CHECK-NEXT:            "declaration",
+# CHECK-NEXT:            "definition",
 # CHECK-NEXT:            "deprecated",
 # CHECK-NEXT:            "deduced",
 # CHECK-NEXT:            "readonly",
 # CHECK-NEXT:            "static",
 # CHECK-NEXT:            "abstract",
 # CHECK-NEXT:            "virtual",
 # CHECK-NEXT:            "dependentName",
 # CHECK-NEXT:            "defaultLibrary",

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:      8193
+# CHECK-NEXT:      16387
 # 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:          8193
+# CHECK-NEXT:          16387
 # 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:      8193,
+# CHECK-NEXT:      16387,
 # CHECK-NEXT:      1,
 # CHECK-NEXT:      4,
 # CHECK-NEXT:      1,
 # CHECK-NEXT:      0,
-# CHECK-NEXT:      8193
+# CHECK-NEXT:      16387
 # 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

std::string annotate(llvm::StringRef Input,
   llvm::raw_string_ostream OS(Buf);
   unsigned NextChar = 0;
   for (auto &T : Tokens) {
     unsigned StartOffset = llvm::cantFail(positionToOffset(Input, T.R.start));
     unsigned EndOffset = llvm::cantFail(positionToOffset(Input, T.R.end));
     assert(StartOffset <= EndOffset);
     assert(NextChar <= StartOffset);
 
+    bool hasDef =
+        T.Modifiers & (1 << uint32_t(HighlightingModifier::Definition));
+    bool hasDecl =
+        T.Modifiers & (1 << uint32_t(HighlightingModifier::Declaration));
+    EXPECT_TRUE(!hasDef || hasDecl);
+
     OS << Input.substr(NextChar, StartOffset - NextChar);
     OS << '$' << T.Kind;
     for (unsigned I = 0;
          I <= static_cast<uint32_t>(HighlightingModifier::LastModifier); ++I) {
-      if (T.Modifiers & (1 << I))
+      if (T.Modifiers & (1 << I)) {
+        if (I != uint32_t(HighlightingModifier::Declaration) || !hasDef)
           OS << '_' << static_cast<HighlightingModifier>(I);
       }
+    }
     OS << "[[" << Input.substr(StartOffset, EndOffset - StartOffset) << "]]";
     NextChar = EndOffset;
   }
   OS << Input.substr(NextChar);
   return std::move(OS.str());
 }
 
 void checkHighlightings(llvm::StringRef Code,
constexpr static uint32_t ScopeModifierMask =
     1 << unsigned(HighlightingModifier::FunctionScope) |
     1 << unsigned(HighlightingModifier::ClassScope) |
     1 << unsigned(HighlightingModifier::FileScope) |
     1 << unsigned(HighlightingModifier::GlobalScope);
 
 TEST(SemanticHighlighting, GetsCorrectTokens) {
   const char *TestCases[] = {
       R"cpp(
-      struct $Class_decl[[AS]] {
+      struct $Class_def[[AS]] {
         double $Field_decl[[SomeMember]];
       };
       struct {
-      } $Variable_decl[[S]];
-      void $Function_decl[[foo]](int $Parameter_decl[[A]], $Class[[AS]] $Parameter_decl[[As]]) {
-        $Primitive_deduced_defaultLibrary[[auto]] $LocalVariable_decl[[VeryLongVariableName]] = 12312;
-        $Class[[AS]]     $LocalVariable_decl[[AA]];
-        $Primitive_deduced_defaultLibrary[[auto]] $LocalVariable_decl[[L]] = $LocalVariable[[AA]].$Field[[SomeMember]] + $Parameter[[A]];
-        auto $LocalVariable_decl[[FN]] = [ $LocalVariable[[AA]]](int $Parameter_decl[[A]]) -> void {};
+      } $Variable_def[[S]];
+      void $Function_def[[foo]](int $Parameter_decl[[A]], $Class[[AS]] $Parameter_decl[[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_decl[[A]]) -> void {};
         $LocalVariable[[FN]](12312);
       }
     )cpp",
       R"cpp(
       void $Function_decl[[foo]](int);
       void $Function_decl[[Gah]]();
-      void $Function_decl[[foo]]() {
-        auto $LocalVariable_decl[[Bou]] = $Function[[Gah]];
+      void $Function_def[[foo]]() {
+        auto $LocalVariable_def[[Bou]] = $Function[[Gah]];
       }
-      struct $Class_decl[[A]] {
+      struct $Class_def[[A]] {
         void $Method_decl[[abc]]();
       };
     )cpp",
       R"cpp(
       namespace $Namespace_decl[[abc]] {
         template<typename $TemplateParameter_decl[[T]]>
-        struct $Class_decl[[A]] {
+        struct $Class_def[[A]] {
           $TemplateParameter[[T]] $Field_decl[[t]];
         };
       }
       template<typename $TemplateParameter_decl[[T]]>
-      struct $Class_decl[[C]] : $Namespace[[abc]]::$Class[[A]]<$TemplateParameter[[T]]> {
+      struct $Class_def[[C]] : $Namespace[[abc]]::$Class[[A]]<$TemplateParameter[[T]]> {
         typename $TemplateParameter[[T]]::$Type_dependentName[[A]]* $Field_decl[[D]];
       };
-      $Namespace[[abc]]::$Class[[A]]<int> $Variable_decl[[AA]];
+      $Namespace[[abc]]::$Class[[A]]<int> $Variable_def[[AA]];
       typedef $Namespace[[abc]]::$Class[[A]]<int> $Class_decl[[AAA]];
-      struct $Class_decl[[B]] {
+      struct $Class_def[[B]] {
         $Class_decl[[B]]();
         ~$Class[[B]](); // FIXME: inconsistent with constructor
         void operator<<($Class[[B]]);
         $Class[[AAA]] $Field_decl[[AA]];
       };
-      $Class[[B]]::$Class_decl[[B]]() {}
+      $Class[[B]]::$Class_def[[B]]() {}
       $Class[[B]]::~$Class[[B]]() {} // FIXME: inconsistent with constructor
-      void $Function_decl[[f]] () {
-        $Class[[B]] $LocalVariable_decl[[BB]] = $Class[[B]]();
+      void $Function_def[[f]] () {
+        $Class[[B]] $LocalVariable_def[[BB]] = $Class[[B]]();
         $LocalVariable[[BB]].~$Class[[B]]();
         $Class[[B]]();
       }
     )cpp",
       R"cpp(
       enum class $Enum_decl[[E]] {
         $EnumConstant_decl_readonly[[A]],
         $EnumConstant_decl_readonly[[B]],
       };
       enum $Enum_decl[[EE]] {
         $EnumConstant_decl_readonly[[Hi]],
       };
-      struct $Class_decl[[A]] {
+      struct $Class_def[[A]] {
         $Enum[[E]] $Field_decl[[EEE]];
         $Enum[[EE]] $Field_decl[[EEEE]];
       };
-      int $Variable_decl[[I]] = $EnumConstant_readonly[[Hi]];
-      $Enum[[E]] $Variable_decl[[L]] = $Enum[[E]]::$EnumConstant_readonly[[B]];
+      int $Variable_def[[I]] = $EnumConstant_readonly[[Hi]];
+      $Enum[[E]] $Variable_def[[L]] = $Enum[[E]]::$EnumConstant_readonly[[B]];
     )cpp",
       R"cpp(
       namespace $Namespace_decl[[abc]] {
         namespace {}
         namespace $Namespace_decl[[bcd]] {
-          struct $Class_decl[[A]] {};
+          struct $Class_def[[A]] {};
           namespace $Namespace_decl[[cde]] {
-            struct $Class_decl[[A]] {
+            struct $Class_def[[A]] {
               enum class $Enum_decl[[B]] {
                 $EnumConstant_decl_readonly[[Hi]],
               };
             };
           }
         }
       }
       using namespace $Namespace[[abc]]::$Namespace[[bcd]];
       namespace $Namespace_decl[[vwz]] =
             $Namespace[[abc]]::$Namespace[[bcd]]::$Namespace[[cde]];
-      $Namespace[[abc]]::$Namespace[[bcd]]::$Class[[A]] $Variable_decl[[AA]];
-      $Namespace[[vwz]]::$Class[[A]]::$Enum[[B]] $Variable_decl[[AAA]] =
+      $Namespace[[abc]]::$Namespace[[bcd]]::$Class[[A]] $Variable_def[[AA]];
+      $Namespace[[vwz]]::$Class[[A]]::$Enum[[B]] $Variable_def[[AAA]] =
             $Namespace[[vwz]]::$Class[[A]]::$Enum[[B]]::$EnumConstant_readonly[[Hi]];
-      ::$Namespace[[vwz]]::$Class[[A]] $Variable_decl[[B]];
-      ::$Namespace[[abc]]::$Namespace[[bcd]]::$Class[[A]] $Variable_decl[[BB]];
+      ::$Namespace[[vwz]]::$Class[[A]] $Variable_def[[B]];
+      ::$Namespace[[abc]]::$Namespace[[bcd]]::$Class[[A]] $Variable_def[[BB]];
     )cpp",
       R"cpp(
-      struct $Class_decl[[D]] {
+      struct $Class_def[[D]] {
         double $Field_decl[[C]];
       };
-      struct $Class_decl[[A]] {
+      struct $Class_def[[A]] {
         double $Field_decl[[B]];
         $Class[[D]] $Field_decl[[E]];
         static double $StaticField_decl_static[[S]];
-        static void $StaticMethod_decl_static[[bar]]() {}
-        void $Method_decl[[foo]]() {
+        static void $StaticMethod_def_static[[bar]]() {}
+        void $Method_def[[foo]]() {
           $Field[[B]] = 123;
           this->$Field[[B]] = 156;
           this->$Method[[foo]]();
           $Method[[foo]]();
           $StaticMethod_static[[bar]]();
           $StaticField_static[[S]] = 90.1;
         }
       };
-      void $Function_decl[[foo]]() {
-        $Class[[A]] $LocalVariable_decl[[AA]];
+      void $Function_def[[foo]]() {
+        $Class[[A]] $LocalVariable_def[[AA]];
         $LocalVariable[[AA]].$Field[[B]] += 2;
         $LocalVariable[[AA]].$Method[[foo]]();
         $LocalVariable[[AA]].$Field[[E]].$Field[[C]];
         $Class[[A]]::$StaticField_static[[S]] = 90;
       }
     )cpp",
       R"cpp(
-      struct $Class_decl[[AA]] {
+      struct $Class_def[[AA]] {
         int $Field_decl[[A]];
       };
-      int $Variable_decl[[B]];
-      $Class[[AA]] $Variable_decl[[A]]{$Variable[[B]]};
+      int $Variable_def[[B]];
+      $Class[[AA]] $Variable_def[[A]]{$Variable[[B]]};
     )cpp",
       R"cpp(
       namespace $Namespace_decl[[a]] {
-        struct $Class_decl[[A]] {};
+        struct $Class_def[[A]] {};
         typedef char $Primitive_decl[[C]];
       }
       typedef $Namespace[[a]]::$Class[[A]] $Class_decl[[B]];
       using $Class_decl[[BB]] = $Namespace[[a]]::$Class[[A]];
       enum class $Enum_decl[[E]] {};
       typedef $Enum[[E]] $Enum_decl[[C]];
       typedef $Enum[[C]] $Enum_decl[[CC]];
       using $Enum_decl[[CD]] = $Enum[[CC]];
       $Enum[[CC]] $Function_decl[[f]]($Class[[B]]);
       $Enum[[CD]] $Function_decl[[f]]($Class[[BB]]);
       typedef $Namespace[[a]]::$Primitive[[C]] $Primitive_decl[[PC]];
       typedef float $Primitive_decl[[F]];
     )cpp",
       R"cpp(
       template<typename $TemplateParameter_decl[[T]], typename = void>
-      class $Class_decl[[A]] {
+      class $Class_def[[A]] {
         $TemplateParameter[[T]] $Field_decl[[AA]];
         $TemplateParameter[[T]] $Method_decl[[foo]]();
       };
       template<class $TemplateParameter_decl[[TT]]>
-      class $Class_decl[[B]] {
+      class $Class_def[[B]] {
         $Class[[A]]<$TemplateParameter[[TT]]> $Field_decl[[AA]];
       };
       template<class $TemplateParameter_decl[[TT]], class $TemplateParameter_decl[[GG]]>
-      class $Class_decl[[BB]] {};
+      class $Class_def[[BB]] {};
       template<class $TemplateParameter_decl[[T]]>
-      class $Class_decl[[BB]]<$TemplateParameter[[T]], int> {};
+      class $Class_def[[BB]]<$TemplateParameter[[T]], int> {};
       template<class $TemplateParameter_decl[[T]]>
-      class $Class_decl[[BB]]<$TemplateParameter[[T]], $TemplateParameter[[T]]*> {};
+      class $Class_def[[BB]]<$TemplateParameter[[T]], $TemplateParameter[[T]]*> {};
 
       template<template<class> class $TemplateParameter_decl[[T]], class $TemplateParameter_decl[[C]]>
       $TemplateParameter[[T]]<$TemplateParameter[[C]]> $Function_decl[[f]]();
 
       template<typename>
-      class $Class_decl[[Foo]] {};
+      class $Class_def[[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;};
-      extern template struct $Class_decl[[Tmpl]]<float>;
-      template struct $Class_decl[[Tmpl]]<double>;
+      struct $Class_def[[Tmpl]] {$TemplateParameter[[T]] $Field_decl[[x]] = 0;};
+      extern template struct $Class_def[[Tmpl]]<float>;
+      template struct $Class_def[[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]] {
+      class $Class_def[[Foo]] {};
+      struct $Class_def[[Bar]] {
         explicit operator $Class[[Foo]]*() const;
         explicit operator int() const;
         operator $Class[[Foo]]();
       };
-      void $Function_decl[[f]]() {
-        $Class[[Bar]] $LocalVariable_decl[[B]];
-        $Class[[Foo]] $LocalVariable_decl[[F]] = $LocalVariable[[B]];
-        $Class[[Foo]] *$LocalVariable_decl[[FP]] = ($Class[[Foo]]*)$LocalVariable[[B]];
-        int $LocalVariable_decl[[I]] = (int)$LocalVariable[[B]];
+      void $Function_def[[f]]() {
+        $Class[[Bar]] $LocalVariable_def[[B]];
+        $Class[[Foo]] $LocalVariable_def[[F]] = $LocalVariable[[B]];
+        $Class[[Foo]] *$LocalVariable_def[[FP]] = ($Class[[Foo]]*)$LocalVariable[[B]];
+        int $LocalVariable_def[[I]] = (int)$LocalVariable[[B]];
       }
     )cpp",
       R"cpp(
-      struct $Class_decl[[B]] {};
-      struct $Class_decl[[A]] {
+      struct $Class_def[[B]] {};
+      struct $Class_def[[A]] {
         $Class[[B]] $Field_decl[[BB]];
         $Class[[A]] &operator=($Class[[A]] &&$Parameter_decl[[O]]);
       };
 
       $Class[[A]] &$Class[[A]]::operator=($Class[[A]] &&$Parameter_decl[[O]]) = default;
     )cpp",
       R"cpp(
       enum $Enum_decl[[En]] {
         $EnumConstant_decl_readonly[[EC]],
       };
-      class $Class_decl[[Foo]] {};
-      class $Class_decl[[Bar]] {
+      class $Class_def[[Foo]] {};
+      class $Class_def[[Bar]] {
       public:
         $Class[[Foo]] $Field_decl[[Fo]];
         $Enum[[En]] $Field_decl[[E]];
         int $Field_decl[[I]];
-        $Class_decl[[Bar]] ($Class[[Foo]] $Parameter_decl[[F]],
+        $Class_def[[Bar]] ($Class[[Foo]] $Parameter_decl[[F]],
                 $Enum[[En]] $Parameter_decl[[E]])
         : $Field[[Fo]] ($Parameter[[F]]), $Field[[E]] ($Parameter[[E]]),
           $Field[[I]] (123) {}
       };
-      class $Class_decl[[Bar2]] : public $Class[[Bar]] {
-        $Class_decl[[Bar2]]() : $Class[[Bar]]($Class[[Foo]](), $EnumConstant_readonly[[EC]]) {}
+      class $Class_def[[Bar2]] : public $Class[[Bar]] {
+        $Class_def[[Bar2]]() : $Class[[Bar]]($Class[[Foo]](), $EnumConstant_readonly[[EC]]) {}
       };
     )cpp",
       R"cpp(
       enum $Enum_decl[[E]] {
         $EnumConstant_decl_readonly[[E]],
       };
-      class $Class_decl[[Foo]] {};
-      $Enum_deduced[[auto]] $Variable_decl[[AE]] = $Enum[[E]]::$EnumConstant_readonly[[E]];
-      $Class_deduced[[auto]] $Variable_decl[[AF]] = $Class[[Foo]]();
-      $Class_deduced[[decltype]](auto) $Variable_decl[[AF2]] = $Class[[Foo]]();
-      $Class_deduced[[auto]] *$Variable_decl[[AFP]] = &$Variable[[AF]];
-      $Enum_deduced[[auto]] &$Variable_decl[[AER]] = $Variable[[AE]];
-      $Primitive_deduced_defaultLibrary[[auto]] $Variable_decl[[Form]] = 10.2 + 2 * 4;
-      $Primitive_deduced_defaultLibrary[[decltype]]($Variable[[Form]]) $Variable_decl[[F]] = 10;
-      auto $Variable_decl[[Fun]] = []()->void{};
+      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{};
     )cpp",
       R"cpp(
-      class $Class_decl[[G]] {};
+      class $Class_def[[G]] {};
       template<$Class[[G]] *$TemplateParameter_decl_readonly[[U]]>
-      class $Class_decl[[GP]] {};
+      class $Class_def[[GP]] {};
       template<$Class[[G]] &$TemplateParameter_decl_readonly[[U]]>
-      class $Class_decl[[GR]] {};
+      class $Class_def[[GR]] {};
       template<int *$TemplateParameter_decl_readonly[[U]]>
-      class $Class_decl[[IP]] {
-        void $Method_decl[[f]]() {
+      class $Class_def[[IP]] {
+        void $Method_def[[f]]() {
           *$TemplateParameter_readonly[[U]] += 5;
         }
       };
       template<unsigned $TemplateParameter_decl_readonly[[U]] = 2>
-      class $Class_decl[[Foo]] {
-        void $Method_decl[[f]]() {
-          for(int $LocalVariable_decl[[I]] = 0;
+      class $Class_def[[Foo]] {
+        void $Method_def[[f]]() {
+          for(int $LocalVariable_def[[I]] = 0;
             $LocalVariable[[I]] < $TemplateParameter_readonly[[U]];) {}
         }
       };
 
-      $Class[[G]] $Variable_decl[[L]];
-      void $Function_decl[[f]]() {
-        $Class[[Foo]]<123> $LocalVariable_decl[[F]];
-        $Class[[GP]]<&$Variable[[L]]> $LocalVariable_decl[[LL]];
-        $Class[[GR]]<$Variable[[L]]> $LocalVariable_decl[[LLL]];
+      $Class[[G]] $Variable_def[[L]];
+      void $Function_def[[f]]() {
+        $Class[[Foo]]<123> $LocalVariable_def[[F]];
+        $Class[[GP]]<&$Variable[[L]]> $LocalVariable_def[[LL]];
+        $Class[[GR]]<$Variable[[L]]> $LocalVariable_def[[LLL]];
       }
     )cpp",
       R"cpp(
       template<typename $TemplateParameter_decl[[T]],
         void ($TemplateParameter[[T]]::*$TemplateParameter_decl_readonly[[method]])(int)>
-      struct $Class_decl[[G]] {
-        void $Method_decl[[foo]](
+      struct $Class_def[[G]] {
+        void $Method_def[[foo]](
             $TemplateParameter[[T]] *$Parameter_decl[[O]]) {
           ($Parameter[[O]]->*$TemplateParameter_readonly[[method]])(10);
         }
       };
-      struct $Class_decl[[F]] {
+      struct $Class_def[[F]] {
         void $Method_decl[[f]](int);
       };
       template<void (*$TemplateParameter_decl_readonly[[Func]])()>
-      struct $Class_decl[[A]] {
-        void $Method_decl[[f]]() {
+      struct $Class_def[[A]] {
+        void $Method_def[[f]]() {
           (*$TemplateParameter_readonly[[Func]])();
         }
       };
 
-      void $Function_decl[[foo]]() {
-        $Class[[F]] $LocalVariable_decl[[FF]];
-        $Class[[G]]<$Class[[F]], &$Class[[F]]::$Method[[f]]> $LocalVariable_decl[[GG]];
+      void $Function_def[[foo]]() {
+        $Class[[F]] $LocalVariable_def[[FF]];
+        $Class[[G]]<$Class[[F]], &$Class[[F]]::$Method[[f]]> $LocalVariable_def[[GG]];
         $LocalVariable[[GG]].$Method[[foo]](&$LocalVariable[[FF]]);
-        $Class[[A]]<$Function[[foo]]> $LocalVariable_decl[[AA]];
+        $Class[[A]]<$Function[[foo]]> $LocalVariable_def[[AA]];
       }
     )cpp",
       // Tokens that share a source range but have conflicting Kinds are not
       // highlighted.
       R"cpp(
       #define $Macro_decl[[DEF_MULTIPLE]](X) namespace X { class X { int X; }; }
       #define $Macro_decl[[DEF_CLASS]](T) class T {};
       // Preamble ends.
       $Macro[[DEF_MULTIPLE]](XYZ);
       $Macro[[DEF_MULTIPLE]](XYZW);
-      $Macro[[DEF_CLASS]]($Class_decl[[A]])
+      $Macro[[DEF_CLASS]]($Class_def[[A]])
       #define $Macro_decl[[MACRO_CONCAT]](X, V, T) T foo##X = V
       #define $Macro_decl[[DEF_VAR]](X, V) int X = V
       #define $Macro_decl[[DEF_VAR_T]](T, X, V) T X = V
       #define $Macro_decl[[DEF_VAR_REV]](V, X) DEF_VAR(X, V)
       #define $Macro_decl[[CPY]](X) X
       #define $Macro_decl[[DEF_VAR_TYPE]](X, Y) X Y
       #define $Macro_decl[[SOME_NAME]] variable
       #define $Macro_decl[[SOME_NAME_SET]] variable2 = 123
       #define $Macro_decl[[INC_VAR]](X) X += 2
-      void $Function_decl[[foo]]() {
-        $Macro[[DEF_VAR]]($LocalVariable_decl[[X]],  123);
-        $Macro[[DEF_VAR_REV]](908, $LocalVariable_decl[[XY]]);
-        int $Macro[[CPY]]( $LocalVariable_decl[[XX]] );
-        $Macro[[DEF_VAR_TYPE]]($Class[[A]], $LocalVariable_decl[[AA]]);
+      void $Function_def[[foo]]() {
+        $Macro[[DEF_VAR]]($LocalVariable_def[[X]],  123);
+        $Macro[[DEF_VAR_REV]](908, $LocalVariable_def[[XY]]);
+        int $Macro[[CPY]]( $LocalVariable_def[[XX]] );
+        $Macro[[DEF_VAR_TYPE]]($Class[[A]], $LocalVariable_def[[AA]]);
         double $Macro[[SOME_NAME]];
         int $Macro[[SOME_NAME_SET]];
         $LocalVariable[[variable]] = 20.1;
         $Macro[[MACRO_CONCAT]](var, 2, float);
         $Macro[[DEF_VAR_T]]($Class[[A]], $Macro[[CPY]](
-              $Macro[[CPY]]($LocalVariable_decl[[Nested]])),
+              $Macro[[CPY]]($LocalVariable_def[[Nested]])),
             $Macro[[CPY]]($Class[[A]]()));
         $Macro[[INC_VAR]]($LocalVariable[[variable]]);
       }
       void $Macro[[SOME_NAME]]();
-      $Macro[[DEF_VAR]]($Variable_decl[[MMMMM]], 567);
-      $Macro[[DEF_VAR_REV]](756, $Variable_decl[[AB]]);
+      $Macro[[DEF_VAR]]($Variable_def[[MMMMM]], 567);
+      $Macro[[DEF_VAR_REV]](756, $Variable_def[[AB]]);
 
       #define $Macro_decl[[CALL_FN]](F) F();
       #define $Macro_decl[[DEF_FN]](F) void F ()
-      $Macro[[DEF_FN]]($Function_decl[[g]]) {
+      $Macro[[DEF_FN]]($Function_def[[g]]) {
         $Macro[[CALL_FN]]($Function[[foo]]);
       }
     )cpp",
       R"cpp(
       #define $Macro_decl[[fail]](expr) expr
       #define $Macro_decl[[assert]](COND) if (!(COND)) { fail("assertion failed" #COND); }
       // Preamble ends.
-      int $Variable_decl[[x]];
-      int $Variable_decl[[y]];
+      int $Variable_def[[x]];
+      int $Variable_def[[y]];
       int $Function_decl[[f]]();
-      void $Function_decl[[foo]]() {
+      void $Function_def[[foo]]() {
         $Macro[[assert]]($Variable[[x]] != $Variable[[y]]);
         $Macro[[assert]]($Variable[[x]] != $Function[[f]]());
       }
     )cpp",
       // highlighting all macro references
       R"cpp(
       #ifndef $Macro[[name]]
       #define $Macro_decl[[name]]
       #endif
 
       #define $Macro_decl[[test]]
       #undef $Macro[[test]]
 $InactiveCode[[#ifdef test]]
 $InactiveCode[[#endif]]
 
 $InactiveCode[[#if defined(test)]]
 $InactiveCode[[#endif]]
     )cpp",
       R"cpp(
-      struct $Class_decl[[S]] {
+      struct $Class_def[[S]] {
         float $Field_decl[[Value]];
         $Class[[S]] *$Field_decl[[Next]];
       };
-      $Class[[S]] $Variable_decl[[Global]][2] = {$Class[[S]](), $Class[[S]]()};
+      $Class[[S]] $Variable_def[[Global]][2] = {$Class[[S]](), $Class[[S]]()};
       auto [$Variable_decl[[G1]], $Variable_decl[[G2]]] = $Variable[[Global]];
-      void $Function_decl[[f]]($Class[[S]] $Parameter_decl[[P]]) {
-        int $LocalVariable_decl[[A]][2] = {1,2};
+      void $Function_def[[f]]($Class[[S]] $Parameter_decl[[P]]) {
+        int $LocalVariable_def[[A]][2] = {1,2};
         auto [$LocalVariable_decl[[B1]], $LocalVariable_decl[[B2]]] = $LocalVariable[[A]];
         auto [$LocalVariable_decl[[G1]], $LocalVariable_decl[[G2]]] = $Variable[[Global]];
         $Class_deduced[[auto]] [$LocalVariable_decl[[P1]], $LocalVariable_decl[[P2]]] = $Parameter[[P]];
         // Highlights references to BindingDecls.
         $LocalVariable[[B1]]++;
       }
     )cpp",
       R"cpp(
       template<class $TemplateParameter_decl[[T]]>
-      class $Class_decl[[A]] {
+      class $Class_def[[A]] {
         using $TemplateParameter_decl[[TemplateParam1]] = $TemplateParameter[[T]];
         typedef $TemplateParameter[[T]] $TemplateParameter_decl[[TemplateParam2]];
         using $Primitive_decl[[IntType]] = int;
 
         using $Typedef_decl[[Pointer]] = $TemplateParameter[[T]] *;
         using $Typedef_decl[[LVReference]] = $TemplateParameter[[T]] &;
         using $Typedef_decl[[RVReference]] = $TemplateParameter[[T]]&&;
         using $Typedef_decl[[Array]] = $TemplateParameter[[T]]*[3];
         using $Typedef_decl[[MemberPointer]] = int ($Class[[A]]::*)(int);
 
         // Use various previously defined typedefs in a function type.
         void $Method_decl[[func]](
           $Typedef[[Pointer]], $Typedef[[LVReference]], $Typedef[[RVReference]],
           $Typedef[[Array]], $Typedef[[MemberPointer]]);
       };
     )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]]) {
+      void $Function_def[[foo]]($TemplateParameter[[T]] $Parameter_decl[[P]]) {
         $Function[[phase1]]($Parameter[[P]]);
         $Unknown_dependentName[[phase2]]($Parameter[[P]]);
       }
     )cpp",
       R"cpp(
-      class $Class_decl[[A]] {
+      class $Class_def[[A]] {
         template <class $TemplateParameter_decl[[T]]>
         void $Method_decl[[bar]]($TemplateParameter[[T]]);
       };
 
       template <class $TemplateParameter_decl[[U]]>
-      void $Function_decl[[foo]]($TemplateParameter[[U]] $Parameter_decl[[P]]) {
+      void $Function_def[[foo]]($TemplateParameter[[U]] $Parameter_decl[[P]]) {
         $Class[[A]]().$Method[[bar]]($Parameter[[P]]);
       }
     )cpp",
       R"cpp(
-      struct $Class_decl[[A]] {
+      struct $Class_def[[A]] {
         template <class $TemplateParameter_decl[[T]]>
         static void $StaticMethod_decl_static[[foo]]($TemplateParameter[[T]]);
       };
 
       template <class $TemplateParameter_decl[[T]]>
-      struct $Class_decl[[B]] {
-        void $Method_decl[[bar]]() {
+      struct $Class_def[[B]] {
+        void $Method_def[[bar]]() {
           $Class[[A]]::$StaticMethod_static[[foo]]($TemplateParameter[[T]]());
         }
       };
     )cpp",
       R"cpp(
       template <class $TemplateParameter_decl[[T]]>
       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]]) {
+      void $Function_def[[foo]]($TemplateParameter[[T]] $Parameter_decl[[P]]) {
         $Parameter[[P]].$Unknown_dependentName[[Field]];
       }
     )cpp",
       R"cpp(
       template <class $TemplateParameter_decl[[T]]>
-      class $Class_decl[[A]] {
-        int $Method_decl[[foo]]() {
+      class $Class_def[[A]] {
+        int $Method_def[[foo]]() {
           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",
       // Highlighting of template template arguments.
       R"cpp(
       template <template <class> class $TemplateParameter_decl[[TT]],
                 template <class> class ...$TemplateParameter_decl[[TTs]]>
-      struct $Class_decl[[Foo]] {
+      struct $Class_def[[Foo]] {
         $Class[[Foo]]<$TemplateParameter[[TT]], $TemplateParameter[[TTs]]...>
           *$Field_decl[[t]];
       };
     )cpp",
       // Inactive code highlighting
       R"cpp(
       // Code in the preamble.
       // Inactive lines get an empty InactiveCode token at the beginning.
 $InactiveCode[[#ifdef test]]
 $InactiveCode[[#endif]]
 
       // A declaration to cause the preamble to end.
-      int $Variable_decl[[EndPreamble]];
+      int $Variable_def[[EndPreamble]];
 
       // Code after the preamble.
       // Code inside inactive blocks does not get regular highlightings
       // because it's not part of the AST.
       #define $Macro_decl[[test2]]
 $InactiveCode[[#if defined(test)]]
 $InactiveCode[[int Inactive2;]]
 $InactiveCode[[#elif defined(test2)]]
-      int $Variable_decl[[Active1]];
+      int $Variable_def[[Active1]];
 $InactiveCode[[#else]]
 $InactiveCode[[int Inactive3;]]
 $InactiveCode[[#endif]]
 
       #ifndef $Macro[[test]]
-      int $Variable_decl[[Active2]];
+      int $Variable_def[[Active2]];
       #endif
 
 $InactiveCode[[#ifdef test]]
 $InactiveCode[[int Inactive4;]]
 $InactiveCode[[#else]]
-      int $Variable_decl[[Active3]];
+      int $Variable_def[[Active3]];
       #endif
     )cpp",
       // Argument to 'sizeof...'
       R"cpp(
       template <typename... $TemplateParameter_decl[[Elements]]>
-      struct $Class_decl[[TupleSize]] {
+      struct $Class_def[[TupleSize]] {
         static const int $StaticField_decl_readonly_static[[size]] =
 sizeof...($TemplateParameter[[Elements]]);
       };
     )cpp",
       // More dependent types
       R"cpp(
       template <typename $TemplateParameter_decl[[T]]>
-      struct $Class_decl[[Waldo]] {
+      struct $Class_def[[Waldo]] {
         using $Typedef_decl[[Location1]] = typename $TemplateParameter[[T]]
             ::$Type_dependentName[[Resolver]]::$Type_dependentName[[Location]];
         using $Typedef_decl[[Location2]] = typename $TemplateParameter[[T]]
             ::template $Type_dependentName[[Resolver]]<$TemplateParameter[[T]]>
             ::$Type_dependentName[[Location]];
         using $Typedef_decl[[Location3]] = typename $TemplateParameter[[T]]
             ::$Type_dependentName[[Resolver]]
             ::template $Type_dependentName[[Location]]<$TemplateParameter[[T]]>;
         static const int $StaticField_decl_readonly_static[[Value]] = $TemplateParameter[[T]]
             ::$Type_dependentName[[Resolver]]::$Unknown_dependentName[[Value]];
       };
     )cpp",
       // Dependent name with heuristic target
       R"cpp(
       template <typename>
-      struct $Class_decl[[Foo]] {
+      struct $Class_def[[Foo]] {
         int $Field_decl[[Waldo]];
-        void $Method_decl[[bar]]() {
+        void $Method_def[[bar]]() {
           $Class[[Foo]]().$Field_dependentName[[Waldo]];
         }
         template <typename $TemplateParameter_decl[[U]]>
-        void $Method_decl[[bar1]]() {
+        void $Method_def[[bar1]]() {
           $Class[[Foo]]<$TemplateParameter[[U]]>().$Field_dependentName[[Waldo]];
         }
 
         void $Method_decl[[Overload]]();
         void $Method_decl_readonly[[Overload]]() const;
       };
       template <typename $TemplateParameter_decl[[T]]>
-      void $Function_decl[[baz]]($Class[[Foo]]<$TemplateParameter[[T]]> $Parameter_decl[[o]]) {
+      void $Function_def[[baz]]($Class[[Foo]]<$TemplateParameter[[T]]> $Parameter_decl[[o]]) {
         $Parameter[[o]].$Method_readonly_dependentName[[Overload]]();
       }
     )cpp",
       // Concepts
       R"cpp(
       template <typename $TemplateParameter_decl[[T]]>
-      concept $Concept_decl[[Fooable]] = 
+      concept $Concept_decl[[Fooable]] =
           requires($TemplateParameter[[T]] $Parameter_decl[[F]]) {
             $Parameter[[F]].$Unknown_dependentName[[foo]]();
           };
       template <typename $TemplateParameter_decl[[T]]>
           requires $Concept[[Fooable]]<$TemplateParameter[[T]]>
-      void $Function_decl[[bar]]($TemplateParameter[[T]] $Parameter_decl[[F]]) {
+      void $Function_def[[bar]]($TemplateParameter[[T]] $Parameter_decl[[F]]) {
         $Parameter[[F]].$Unknown_dependentName[[foo]]();
       }
     )cpp",
       // Dependent template name
       R"cpp(
-      template <template <typename> class> struct $Class_decl[[A]] {};
+      template <template <typename> class> struct $Class_def[[A]] {};
       template <typename $TemplateParameter_decl[[T]]>
       using $Typedef_decl[[W]] = $Class[[A]]<
         $TemplateParameter[[T]]::template $Class_dependentName[[Waldo]]
       >;
     )cpp",
       R"cpp(
-      class $Class_decl_abstract[[Abstract]] {
+      class $Class_def_abstract[[Abstract]] {
       public:
         virtual void $Method_decl_abstract_virtual[[pure]]() = 0;
         virtual void $Method_decl_virtual[[impl]]();
       };
-      void $Function_decl[[foo]]($Class_abstract[[Abstract]]* $Parameter_decl[[A]]) {
+      void $Function_def[[foo]]($Class_abstract[[Abstract]]* $Parameter_decl[[A]]) {
           $Parameter[[A]]->$Method_abstract_virtual[[pure]]();
           $Parameter[[A]]->$Method_virtual[[impl]]();
       }
       )cpp",
       R"cpp(
-      <:[deprecated]:> int $Variable_decl_deprecated[[x]];
+      <:[deprecated]:> int $Variable_def_deprecated[[x]];
       )cpp",
       R"cpp(
         // ObjC: Classes and methods
         @class $Class_decl[[Forward]];
 
-        @interface $Class_decl[[Foo]]
+        @interface $Class_def[[Foo]]
         @end
-        @interface $Class_decl[[Bar]] : $Class[[Foo]]
+        @interface $Class_def[[Bar]] : $Class[[Foo]]
         -(id) $Method_decl[[x]]:(int)$Parameter_decl[[a]] $Method_decl[[y]]:(int)$Parameter_decl[[b]];
         +(instancetype)$StaticMethod_decl_static[[sharedInstance]];
         +(void) $StaticMethod_decl_static[[explode]];
         @end
-        @implementation $Class_decl[[Bar]]
-        -(id) $Method_decl[[x]]:(int)$Parameter_decl[[a]] $Method_decl[[y]]:(int)$Parameter_decl[[b]] {
+        @implementation $Class_def[[Bar]]
+        -(id) $Method_def[[x]]:(int)$Parameter_decl[[a]] $Method_def[[y]]:(int)$Parameter_decl[[b]] {
           return self;
         }
-        +(instancetype)$StaticMethod_decl_static[[sharedInstance]] { return 0; }
-        +(void) $StaticMethod_decl_static[[explode]] {}
+        +(instancetype)$StaticMethod_def_static[[sharedInstance]] { return 0; }
+        +(void) $StaticMethod_def_static[[explode]] {}
         @end
 
-        void $Function_decl[[m]]($Class[[Bar]] *$Parameter_decl[[b]]) {
+        void $Function_def[[m]]($Class[[Bar]] *$Parameter_decl[[b]]) {
           [$Parameter[[b]] $Method[[x]]:1 $Method[[y]]:2];
           [$Class[[Bar]] $StaticMethod_static[[explode]]];
         }
       )cpp",
       R"cpp(
         // ObjC: Protocols
-        @protocol $Interface_decl[[Protocol]]
+        @protocol $Interface_def[[Protocol]]
         @end
-        @protocol $Interface_decl[[Protocol2]] <$Interface[[Protocol]]>
+        @protocol $Interface_def[[Protocol2]] <$Interface[[Protocol]]>
         @end
-        @interface $Class_decl[[Klass]] <$Interface[[Protocol]]>
+        @interface $Class_def[[Klass]] <$Interface[[Protocol]]>
         @end
-        id<$Interface[[Protocol]]> $Variable_decl[[x]];
+        id<$Interface[[Protocol]]> $Variable_def[[x]];
       )cpp",
       R"cpp(
         // ObjC: Categories
-        @interface $Class_decl[[Foo]]
+        @interface $Class_def[[Foo]]
         @end
-        @interface $Class[[Foo]]($Namespace_decl[[Bar]])
+        @interface $Class[[Foo]]($Namespace_def[[Bar]])
         @end
-        @implementation $Class[[Foo]]($Namespace_decl[[Bar]])
+        @implementation $Class[[Foo]]($Namespace_def[[Bar]])
         @end
       )cpp",
       R"cpp(
         // ObjC: Properties and Ivars.
-        @interface $Class_decl[[Foo]] {
+        @interface $Class_def[[Foo]] {
           int $Field_decl[[_someProperty]];
         }
         @property(nonatomic, assign) int $Field_decl[[someProperty]];
         @property(readonly, class) $Class[[Foo]] *$Field_decl_readonly_static[[sharedInstance]];
         @end
-        @implementation $Class_decl[[Foo]]
+        @implementation $Class_def[[Foo]]
         @synthesize someProperty = _someProperty;
-        - (int)$Method_decl[[otherMethod]] {
+        - (int)$Method_def[[otherMethod]] {
           return 0;
         }
-        - (int)$Method_decl[[doSomething]] {
+        - (int)$Method_def[[doSomething]] {
           $Class[[Foo]].$Field_static[[sharedInstance]].$Field[[someProperty]] = 1;
           self.$Field[[someProperty]] = self.$Field[[someProperty]] + self.$Field[[otherMethod]] + 1;
           self->$Field[[_someProperty]] = $Field[[_someProperty]] + 1;
         }
         @end
       )cpp",
       // Member imported from dependent base
       R"cpp(
-        template <typename> struct $Class_decl[[Base]] {
+        template <typename> struct $Class_def[[Base]] {
           int $Field_decl[[member]];
         };
         template <typename $TemplateParameter_decl[[T]]>
-        struct $Class_decl[[Derived]] : $Class[[Base]]<$TemplateParameter[[T]]> {
+        struct $Class_def[[Derived]] : $Class[[Base]]<$TemplateParameter[[T]]> {
           using $Class[[Base]]<$TemplateParameter[[T]]>::$Field_dependentName[[member]];
 
-          void $Method_decl[[method]]() {
+          void $Method_def[[method]]() {
             (void)$Field_dependentName[[member]];
           }
         };
       )cpp",
       // Modifier for variables passed as non-const references
       R"cpp(
-        struct $Class_decl[[ClassWithOp]] {
+        struct $Class_def[[ClassWithOp]] {
             void operator()(int);
             void operator()(int, int &);
             void operator()(int, int, const int &);
             int &operator[](int &);
             int operator[](int) const;
         };
-        struct $Class_decl[[ClassWithStaticMember]] {
-            static inline int $StaticField_decl_static[[j]] = 0;
+        struct $Class_def[[ClassWithStaticMember]] {
+            static inline int $StaticField_def_static[[j]] = 0;
         };
-        struct $Class_decl[[ClassWithRefMembers]] {
-          $Class_decl[[ClassWithRefMembers]](int $Parameter_decl[[i]])
+        struct $Class_def[[ClassWithRefMembers]] {
+          $Class_def[[ClassWithRefMembers]](int $Parameter_decl[[i]])
             : $Field[[i1]]($Parameter[[i]]),
               $Field_readonly[[i2]]($Parameter[[i]]),
               $Field[[i3]]($Parameter_usedAsMutableReference[[i]]),
               $Field_readonly[[i4]]($Class[[ClassWithStaticMember]]::$StaticField_static[[j]]),
               $Field[[i5]]($Class[[ClassWithStaticMember]]::$StaticField_static_usedAsMutableReference[[j]])
           {}
           int $Field_decl[[i1]];
           const int &$Field_decl_readonly[[i2]];
           int &$Field_decl[[i3]];
           const int &$Field_decl_readonly[[i4]];
           int &$Field_decl[[i5]];
         };
-        void $Function_decl[[fun]](int, const int,
+        void $Function_def[[fun]](int, const int,
                                    int*, const int*,
                                    int&, const int&,
                                    int*&, const int*&, const int* const &,
                                    int**, int**&, int** const &,
                                    int = 123) {
-          int $LocalVariable_decl[[val]];
-          int* $LocalVariable_decl[[ptr]];
-          const int* $LocalVariable_decl_readonly[[constPtr]];
-          int** $LocalVariable_decl[[array]];
-          $Function[[fun]]($LocalVariable[[val]], $LocalVariable[[val]], 
-                           $LocalVariable[[ptr]], $LocalVariable_readonly[[constPtr]], 
-                           $LocalVariable_usedAsMutableReference[[val]], $LocalVariable[[val]], 
+          int $LocalVariable_def[[val]];
+          int* $LocalVariable_def[[ptr]];
+          const int* $LocalVariable_def_readonly[[constPtr]];
+          int** $LocalVariable_def[[array]];
+          $Function[[fun]]($LocalVariable[[val]], $LocalVariable[[val]],
+                           $LocalVariable[[ptr]], $LocalVariable_readonly[[constPtr]],
+                           $LocalVariable_usedAsMutableReference[[val]], $LocalVariable[[val]],
 
                            $LocalVariable_usedAsMutableReference[[ptr]],
                            $LocalVariable_readonly_usedAsMutableReference[[constPtr]],
                            $LocalVariable_readonly[[constPtr]],
 
-                           $LocalVariable[[array]], $LocalVariable_usedAsMutableReference[[array]], 
+                           $LocalVariable[[array]], $LocalVariable_usedAsMutableReference[[array]],
                            $LocalVariable[[array]]
                            );
           [](int){}($LocalVariable[[val]]);
           [](int&){}($LocalVariable_usedAsMutableReference[[val]]);
           [](const int&){}($LocalVariable[[val]]);
-          $Class[[ClassWithOp]] $LocalVariable_decl[[c]];
-          const $Class[[ClassWithOp]] $LocalVariable_decl_readonly[[c2]];
+          $Class[[ClassWithOp]] $LocalVariable_def[[c]];
+          const $Class[[ClassWithOp]] $LocalVariable_def_readonly[[c2]];
           $LocalVariable[[c]]($LocalVariable[[val]]);
           $LocalVariable[[c]](0, $LocalVariable_usedAsMutableReference[[val]]);
           $LocalVariable[[c]](0, 0, $LocalVariable[[val]]);
           $LocalVariable[[c]][$LocalVariable_usedAsMutableReference[[val]]];
           $LocalVariable_readonly[[c2]][$LocalVariable[[val]]];
         }
-        struct $Class_decl[[S]] {
-          $Class_decl[[S]](int&) {
-            $Class[[S]] $LocalVariable_decl[[s1]]($Field_usedAsMutableReference[[field]]);
-            $Class[[S]] $LocalVariable_decl[[s2]]($LocalVariable[[s1]].$Field_usedAsMutableReference[[field]]);
+        struct $Class_def[[S]] {
+          $Class_def[[S]](int&) {
+            $Class[[S]] $LocalVariable_def[[s1]]($Field_usedAsMutableReference[[field]]);
+            $Class[[S]] $LocalVariable_def[[s2]]($LocalVariable[[s1]].$Field_usedAsMutableReference[[field]]);
 
-            $Class[[S]] $LocalVariable_decl[[s3]]($StaticField_static_usedAsMutableReference[[staticField]]);
-            $Class[[S]] $LocalVariable_decl[[s4]]($Class[[S]]::$StaticField_static_usedAsMutableReference[[staticField]]);
+            $Class[[S]] $LocalVariable_def[[s3]]($StaticField_static_usedAsMutableReference[[staticField]]);
+            $Class[[S]] $LocalVariable_def[[s4]]($Class[[S]]::$StaticField_static_usedAsMutableReference[[staticField]]);
           }
           int $Field_decl[[field]];
           static int $StaticField_decl_static[[staticField]];
         };
         template <typename $TemplateParameter_decl[[X]]>
-        void $Function_decl[[foo]]($TemplateParameter[[X]]& $Parameter_decl[[x]]) {
+        void $Function_def[[foo]]($TemplateParameter[[X]]& $Parameter_decl[[x]]) {
           // We do not support dependent types, so this one should *not* get the modifier.
-          $Function[[foo]]($Parameter[[x]]); 
+          $Function[[foo]]($Parameter[[x]]);
         }
       )cpp",
       // init-captures
       R"cpp(
-        void $Function_decl[[foo]]() {
-          int $LocalVariable_decl[[a]], $LocalVariable_decl[[b]];
-          [ $LocalVariable_decl[[c]] = $LocalVariable[[a]],
-            $LocalVariable_decl[[d]]($LocalVariable[[b]]) ]() {}();
+        void $Function_def[[foo]]() {
+          int $LocalVariable_def[[a]], $LocalVariable_def[[b]];
+          [ $LocalVariable_def[[c]] = $LocalVariable[[a]],
+            $LocalVariable_def[[d]]($LocalVariable[[b]]) ]() {}();
         }
       )cpp",
       // Enum base specifier
       R"cpp(
         using $Primitive_decl[[MyTypedef]] = int;
         enum $Enum_decl[[MyEnum]] : $Primitive[[MyTypedef]] {};
       )cpp",
       // Enum base specifier
       R"cpp(
         typedef int $Primitive_decl[[MyTypedef]];
         enum $Enum_decl[[MyEnum]] : $Primitive[[MyTypedef]] {};
       )cpp",
       // Issue 1096
       R"cpp(
         void $Function_decl[[Foo]]();
         // Use <: :> digraphs for deprecated attribute to avoid conflict with annotation syntax
         <:<:deprecated:>:> void $Function_decl_deprecated[[Foo]](int* $Parameter_decl[[x]]);
         void $Function_decl[[Foo]](int $Parameter_decl[[x]]);
         template <typename $TemplateParameter_decl[[T]]>
-        void $Function_decl[[Bar]]($TemplateParameter[[T]] $Parameter_decl[[x]]) {
-            $Function_deprecated[[Foo]]($Parameter[[x]]); 
-            $Function_deprecated[[Foo]]($Parameter[[x]]); 
-            $Function_deprecated[[Foo]]($Parameter[[x]]); 
+        void $Function_def[[Bar]]($TemplateParameter[[T]] $Parameter_decl[[x]]) {
+            $Function_deprecated[[Foo]]($Parameter[[x]]);
+            $Function_deprecated[[Foo]]($Parameter[[x]]);
+            $Function_deprecated[[Foo]]($Parameter[[x]]);
         }
       )cpp",
       // Predefined identifiers
       R"cpp(
-        void $Function_decl[[Foo]]() {
-            const char *$LocalVariable_decl_readonly[[s]] = $LocalVariable_readonly_static[[__func__]];
+        void $Function_def[[Foo]]() {
+            const char *$LocalVariable_def_readonly[[s]] = $LocalVariable_readonly_static[[__func__]];
         }
       )cpp",
       // Explicit template specialization
       R"cpp(
-        struct $Class_decl[[Base]]{};
+        struct $Class_def[[Base]]{};
         template <typename $TemplateParameter_decl[[T]]>
-        struct $Class_decl[[S]] : public $Class[[Base]] {};
-        template <> 
-        struct $Class_decl[[S]]<void> : public $Class[[Base]] {};
+        struct $Class_def[[S]] : public $Class[[Base]] {};
+        template <>
+        struct $Class_def[[S]]<void> : public $Class[[Base]] {};
 
         template <typename $TemplateParameter_decl[[T]]>
-        $TemplateParameter[[T]] $Variable_decl[[x]] = {};
+        $TemplateParameter[[T]] $Variable_def[[x]] = {};
         template <>
-        int $Variable_decl[[x]]<int> = (int)sizeof($Class[[Base]]);
+        int $Variable_def[[x]]<int> = (int)sizeof($Class[[Base]]);
       )cpp"};
   for (const auto &TestCase : TestCases)
     // Mask off scope modifiers to keep the tests manageable.
     // They're tested separately.
     checkHighlightings(TestCase, {}, ~ScopeModifierMask);
 
   checkHighlightings(R"cpp(
-    class $Class_decl[[A]] {
+    class $Class_def[[A]] {
       #include "imp.h"
     };
   )cpp",
                      {{"imp.h", R"cpp(
     int someMethod();
     void otherMethod();
   )cpp"}},
                      ~ScopeModifierMask);
)cpp",
     #define DXYZ_Y(Y) DXYZ(x##Y)
     #define DEFINE(X) int X;
     #define DEFINE_Y DEFINE(Y)
   )cpp"}},
                      ~ScopeModifierMask);
 
   checkHighlightings(R"cpp(
     #include "SYSObject.h"
-    @interface $Class_defaultLibrary[[SYSObject]] ($Namespace_decl[[UserCategory]])
+    @interface $Class_defaultLibrary[[SYSObject]] ($Namespace_def[[UserCategory]])
     @property(nonatomic, readonly) int $Field_decl_readonly[[user_property]];
     @end
-    int $Function_decl[[somethingUsingSystemSymbols]]() {
-      $Class_defaultLibrary[[SYSObject]] *$LocalVariable_decl[[obj]] = [$Class_defaultLibrary[[SYSObject]] $StaticMethod_static_defaultLibrary[[new]]];
+    int $Function_def[[somethingUsingSystemSymbols]]() {
+      $Class_defaultLibrary[[SYSObject]] *$LocalVariable_def[[obj]] = [$Class_defaultLibrary[[SYSObject]] $StaticMethod_static_defaultLibrary[[new]]];
       return $LocalVariable[[obj]].$Field_defaultLibrary[[value]] + $LocalVariable[[obj]].$Field_readonly[[user_property]];
     }
   )cpp",
                      {{"SystemSDK/SYSObject.h", R"cpp(
     @interface SYSObject
     @property(nonatomic, assign) int value;
     + (instancetype)new;
     @end

clang-tools-extra/clangd/unittests/tweaks/AnnotateHighlightingsTests.cpp

 namespace clangd {
 namespace {
 
 TWEAK_TEST(AnnotateHighlightings);
 
 TEST_F(AnnotateHighlightingsTest, Test) {
   EXPECT_AVAILABLE("^vo^id^ ^f(^) {^}^"); // available everywhere.
   EXPECT_AVAILABLE("[[int a; int b;]]");
-  EXPECT_EQ("void /* Function [decl] [globalScope] */f() {}",
+  EXPECT_EQ("void /* Function [decl] [def] [globalScope] */f() {}",
             apply("void ^f() {}"));
 
   EXPECT_EQ(apply("[[int f1(); const int x = f1();]]"),
             "int /* Function [decl] [globalScope] */f1(); "
-            "const int /* Variable [decl] [readonly] [fileScope] */x = "
+            "const int /* Variable [decl] [def] [readonly] [fileScope] */x = "
             "/* Function [globalScope] */f1();");
 
   // Only the targeted range is annotated.
   EXPECT_EQ(apply("void f1(); void f2() {^}"),
             "void f1(); "
-            "void /* Function [decl] [globalScope] */f2() {}");
+            "void /* Function [decl] [def] [globalScope] */f2() {}");
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang