diff --git a/clang-tools-extra/clangd/SemanticHighlighting.h b/clang-tools-extra/clangd/SemanticHighlighting.h
--- a/clang-tools-extra/clangd/SemanticHighlighting.h
+++ b/clang-tools-extra/clangd/SemanticHighlighting.h
@@ -60,7 +60,7 @@
 
 enum class HighlightingModifier {
   Declaration,
-  // FIXME: Definition (needs findExplicitReferences support)
+  Definition,
   Deprecated,
   Deduced,
   Readonly,
diff --git a/clang-tools-extra/clangd/SemanticHighlighting.cpp b/clang-tools-extra/clangd/SemanticHighlighting.cpp
--- a/clang-tools-extra/clangd/SemanticHighlighting.cpp
+++ b/clang-tools-extra/clangd/SemanticHighlighting.cpp
@@ -831,8 +831,26 @@
           // 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))
-            Tok.addModifier(HighlightingModifier::Declaration);
+          if (R.IsDecl) {
+            if (!isa<UnresolvedUsingValueDecl>(Decl))
+              Tok.addModifier(HighlightingModifier::Declaration);
+            if (const auto Func = dyn_cast<const FunctionDecl>(Decl)) {
+              if (Func->isThisDeclarationADefinition())
+                Tok.addModifier(HighlightingModifier::Definition);
+            } else if (const auto Method = dyn_cast<const ObjCMethodDecl>(Decl)) {
+              if (Method->isThisDeclarationADefinition())
+                Tok.addModifier(HighlightingModifier::Definition);
+            } else if (const auto Klass = dyn_cast<const CXXRecordDecl>(Decl)) {
+              if (Klass->isThisDeclarationADefinition())
+                Tok.addModifier(HighlightingModifier::Definition);
+            } else if (const auto Iface = dyn_cast<const ObjCInterfaceDecl>(Decl)) {
+              if (Iface->isThisDeclarationADefinition())
+                Tok.addModifier(HighlightingModifier::Definition);
+            } else if (const auto Var = dyn_cast<const VarDecl>(Decl)) {
+              if (!isa<ParmVarDecl>(Var) && Var->isThisDeclarationADefinition())
+                Tok.addModifier(HighlightingModifier::Definition);
+            }
+          }
         }
       },
       AST.getHeuristicResolver());
@@ -903,6 +921,8 @@
   switch (K) {
   case HighlightingModifier::Declaration:
     return OS << "decl"; // abbrevation for common case
+  case HighlightingModifier::Definition:
+    return OS << "def";  // abbrevation for common case
   default:
     return OS << toSemanticTokenModifier(K);
   }
@@ -998,6 +1018,8 @@
   switch (Modifier) {
   case HighlightingModifier::Declaration:
     return "declaration";
+  case HighlightingModifier::Definition:
+      return "definition";
   case HighlightingModifier::Deprecated:
     return "deprecated";
   case HighlightingModifier::Readonly:
diff --git a/clang-tools-extra/clangd/test/initialize-params.test b/clang-tools-extra/clangd/test/initialize-params.test
--- a/clang-tools-extra/clangd/test/initialize-params.test
+++ b/clang-tools-extra/clangd/test/initialize-params.test
@@ -86,6 +86,7 @@
 # CHECK-NEXT:        "legend": {
 # CHECK-NEXT:          "tokenModifiers": [
 # CHECK-NEXT:            "declaration",
+# CHECK-NEXT:            "definition",
 # CHECK-NEXT:            "deprecated",
 # CHECK-NEXT:            "deduced",
 # CHECK-NEXT:            "readonly",
diff --git a/clang-tools-extra/clangd/test/semantic-tokens.test b/clang-tools-extra/clangd/test/semantic-tokens.test
--- a/clang-tools-extra/clangd/test/semantic-tokens.test
+++ b/clang-tools-extra/clangd/test/semantic-tokens.test
@@ -23,7 +23,7 @@
 # CHECK-NEXT:      4,
 # CHECK-NEXT:      1,
 # CHECK-NEXT:      0,
-# CHECK-NEXT:      8193
+# CHECK-NEXT:      16387
 # CHECK-NEXT:    ],
 # CHECK-NEXT:    "resultId": "1"
 # CHECK-NEXT:  }
@@ -49,7 +49,7 @@
 # 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,
@@ -72,12 +72,12 @@
 # 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:  }
diff --git a/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp b/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
--- a/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
+++ b/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
@@ -97,52 +97,52 @@
 TEST(SemanticHighlighting, GetsCorrectTokens) {
   const char *TestCases[] = {
       R"cpp(
-      struct $Class_decl[[AS]] {
+      struct $Class_decl_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_decl_def[[S]];
+      void $Function_decl_def[[foo]](int $Parameter_decl[[A]], $Class[[AS]] $Parameter_decl[[As]]) {
+        $Primitive_deduced_defaultLibrary[[auto]] $LocalVariable_decl_def[[VeryLongVariableName]] = 12312;
+        $Class[[AS]]     $LocalVariable_decl_def[[AA]];
+        $Primitive_deduced_defaultLibrary[[auto]] $LocalVariable_decl_def[[L]] = $LocalVariable[[AA]].$Field[[SomeMember]] + $Parameter[[A]];
+        auto $LocalVariable_decl_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_decl_def[[foo]]() {
+        auto $LocalVariable_decl_def[[Bou]] = $Function[[Gah]];
       }
-      struct $Class_decl[[A]] {
+      struct $Class_decl_def[[A]] {
         void $Method_decl[[abc]]();
       };
     )cpp",
       R"cpp(
       namespace $Namespace_decl[[abc]] {
         template<typename $TemplateParameter_decl[[T]]>
-        struct $Class_decl[[A]] {
+        struct $Class_decl_def[[A]] {
           $TemplateParameter[[T]] $Field_decl[[t]];
         };
       }
       template<typename $TemplateParameter_decl[[T]]>
-      struct $Class_decl[[C]] : $Namespace[[abc]]::$Class[[A]]<$TemplateParameter[[T]]> {
+      struct $Class_decl_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_decl_def[[AA]];
       typedef $Namespace[[abc]]::$Class[[A]]<int> $Class_decl[[AAA]];
-      struct $Class_decl[[B]] {
+      struct $Class_decl_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_decl_def[[B]]() {}
       $Class[[B]]::~$Class[[B]]() {} // FIXME: inconsistent with constructor
-      void $Function_decl[[f]] () {
-        $Class[[B]] $LocalVariable_decl[[BB]] = $Class[[B]]();
+      void $Function_decl_def[[f]] () {
+        $Class[[B]] $LocalVariable_decl_def[[BB]] = $Class[[B]]();
         $LocalVariable[[BB]].~$Class[[B]]();
         $Class[[B]]();
       }
@@ -155,20 +155,20 @@
       enum $Enum_decl[[EE]] {
         $EnumConstant_decl_readonly[[Hi]],
       };
-      struct $Class_decl[[A]] {
+      struct $Class_decl_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_decl_def[[I]] = $EnumConstant_readonly[[Hi]];
+      $Enum[[E]] $Variable_decl_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_decl_def[[A]] {};
           namespace $Namespace_decl[[cde]] {
-            struct $Class_decl[[A]] {
+            struct $Class_decl_def[[A]] {
               enum class $Enum_decl[[B]] {
                 $EnumConstant_decl_readonly[[Hi]],
               };
@@ -179,22 +179,22 @@
       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_decl_def[[AA]];
+      $Namespace[[vwz]]::$Class[[A]]::$Enum[[B]] $Variable_decl_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_decl_def[[B]];
+      ::$Namespace[[abc]]::$Namespace[[bcd]]::$Class[[A]] $Variable_decl_def[[BB]];
     )cpp",
       R"cpp(
-      struct $Class_decl[[D]] {
+      struct $Class_decl_def[[D]] {
         double $Field_decl[[C]];
       };
-      struct $Class_decl[[A]] {
+      struct $Class_decl_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_decl_def_static[[bar]]() {}
+        void $Method_decl_def[[foo]]() {
           $Field[[B]] = 123;
           this->$Field[[B]] = 156;
           this->$Method[[foo]]();
@@ -203,8 +203,8 @@
           $StaticField_static[[S]] = 90.1;
         }
       };
-      void $Function_decl[[foo]]() {
-        $Class[[A]] $LocalVariable_decl[[AA]];
+      void $Function_decl_def[[foo]]() {
+        $Class[[A]] $LocalVariable_decl_def[[AA]];
         $LocalVariable[[AA]].$Field[[B]] += 2;
         $LocalVariable[[AA]].$Method[[foo]]();
         $LocalVariable[[AA]].$Field[[E]].$Field[[C]];
@@ -212,15 +212,15 @@
       }
     )cpp",
       R"cpp(
-      struct $Class_decl[[AA]] {
+      struct $Class_decl_def[[AA]] {
         int $Field_decl[[A]];
       };
-      int $Variable_decl[[B]];
-      $Class[[AA]] $Variable_decl[[A]]{$Variable[[B]]};
+      int $Variable_decl_def[[B]];
+      $Class[[AA]] $Variable_decl_def[[A]]{$Variable[[B]]};
     )cpp",
       R"cpp(
       namespace $Namespace_decl[[a]] {
-        struct $Class_decl[[A]] {};
+        struct $Class_decl_def[[A]] {};
         typedef char $Primitive_decl[[C]];
       }
       typedef $Namespace[[a]]::$Class[[A]] $Class_decl[[B]];
@@ -236,56 +236,56 @@
     )cpp",
       R"cpp(
       template<typename $TemplateParameter_decl[[T]], typename = void>
-      class $Class_decl[[A]] {
+      class $Class_decl_def[[A]] {
         $TemplateParameter[[T]] $Field_decl[[AA]];
         $TemplateParameter[[T]] $Method_decl[[foo]]();
       };
       template<class $TemplateParameter_decl[[TT]]>
-      class $Class_decl[[B]] {
+      class $Class_decl_def[[B]] {
         $Class[[A]]<$TemplateParameter[[TT]]> $Field_decl[[AA]];
       };
       template<class $TemplateParameter_decl[[TT]], class $TemplateParameter_decl[[GG]]>
-      class $Class_decl[[BB]] {};
+      class $Class_decl_def[[BB]] {};
       template<class $TemplateParameter_decl[[T]]>
-      class $Class_decl[[BB]]<$TemplateParameter[[T]], int> {};
+      class $Class_decl_def[[BB]]<$TemplateParameter[[T]], int> {};
       template<class $TemplateParameter_decl[[T]]>
-      class $Class_decl[[BB]]<$TemplateParameter[[T]], $TemplateParameter[[T]]*> {};
+      class $Class_decl_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_decl_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_decl_def[[Tmpl]] {$TemplateParameter[[T]] $Field_decl[[x]] = 0;};
+      extern template struct $Class_decl_def[[Tmpl]]<float>;
+      template struct $Class_decl_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_decl_def[[Foo]] {};
+      struct $Class_decl_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_decl_def[[f]]() {
+        $Class[[Bar]] $LocalVariable_decl_def[[B]];
+        $Class[[Foo]] $LocalVariable_decl_def[[F]] = $LocalVariable[[B]];
+        $Class[[Foo]] *$LocalVariable_decl_def[[FP]] = ($Class[[Foo]]*)$LocalVariable[[B]];
+        int $LocalVariable_decl_def[[I]] = (int)$LocalVariable[[B]];
       }
     )cpp",
       R"cpp(
-      struct $Class_decl[[B]] {};
-      struct $Class_decl[[A]] {
+      struct $Class_decl_def[[B]] {};
+      struct $Class_decl_def[[A]] {
         $Class[[B]] $Field_decl[[BB]];
         $Class[[A]] &operator=($Class[[A]] &&$Parameter_decl[[O]]);
       };
@@ -296,86 +296,86 @@
       enum $Enum_decl[[En]] {
         $EnumConstant_decl_readonly[[EC]],
       };
-      class $Class_decl[[Foo]] {};
-      class $Class_decl[[Bar]] {
+      class $Class_decl_def[[Foo]] {};
+      class $Class_decl_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_decl_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_decl_def[[Bar2]] : public $Class[[Bar]] {
+        $Class_decl_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_decl_def[[Foo]] {};
+      $Enum_deduced[[auto]] $Variable_decl_def[[AE]] = $Enum[[E]]::$EnumConstant_readonly[[E]];
+      $Class_deduced[[auto]] $Variable_decl_def[[AF]] = $Class[[Foo]]();
+      $Class_deduced[[decltype]](auto) $Variable_decl_def[[AF2]] = $Class[[Foo]]();
+      $Class_deduced[[auto]] *$Variable_decl_def[[AFP]] = &$Variable[[AF]];
+      $Enum_deduced[[auto]] &$Variable_decl_def[[AER]] = $Variable[[AE]];
+      $Primitive_deduced_defaultLibrary[[auto]] $Variable_decl_def[[Form]] = 10.2 + 2 * 4;
+      $Primitive_deduced_defaultLibrary[[decltype]]($Variable[[Form]]) $Variable_decl_def[[F]] = 10;
+      auto $Variable_decl_def[[Fun]] = []()->void{};
     )cpp",
       R"cpp(
-      class $Class_decl[[G]] {};
+      class $Class_decl_def[[G]] {};
       template<$Class[[G]] *$TemplateParameter_decl_readonly[[U]]>
-      class $Class_decl[[GP]] {};
+      class $Class_decl_def[[GP]] {};
       template<$Class[[G]] &$TemplateParameter_decl_readonly[[U]]>
-      class $Class_decl[[GR]] {};
+      class $Class_decl_def[[GR]] {};
       template<int *$TemplateParameter_decl_readonly[[U]]>
-      class $Class_decl[[IP]] {
-        void $Method_decl[[f]]() {
+      class $Class_decl_def[[IP]] {
+        void $Method_decl_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_decl_def[[Foo]] {
+        void $Method_decl_def[[f]]() {
+          for(int $LocalVariable_decl_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_decl_def[[L]];
+      void $Function_decl_def[[f]]() {
+        $Class[[Foo]]<123> $LocalVariable_decl_def[[F]];
+        $Class[[GP]]<&$Variable[[L]]> $LocalVariable_decl_def[[LL]];
+        $Class[[GR]]<$Variable[[L]]> $LocalVariable_decl_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_decl_def[[G]] {
+        void $Method_decl_def[[foo]](
             $TemplateParameter[[T]] *$Parameter_decl[[O]]) {
           ($Parameter[[O]]->*$TemplateParameter_readonly[[method]])(10);
         }
       };
-      struct $Class_decl[[F]] {
+      struct $Class_decl_def[[F]] {
         void $Method_decl[[f]](int);
       };
       template<void (*$TemplateParameter_decl_readonly[[Func]])()>
-      struct $Class_decl[[A]] {
-        void $Method_decl[[f]]() {
+      struct $Class_decl_def[[A]] {
+        void $Method_decl_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_decl_def[[foo]]() {
+        $Class[[F]] $LocalVariable_decl_def[[FF]];
+        $Class[[G]]<$Class[[F]], &$Class[[F]]::$Method[[f]]> $LocalVariable_decl_def[[GG]];
         $LocalVariable[[GG]].$Method[[foo]](&$LocalVariable[[FF]]);
-        $Class[[A]]<$Function[[foo]]> $LocalVariable_decl[[AA]];
+        $Class[[A]]<$Function[[foo]]> $LocalVariable_decl_def[[AA]];
       }
     )cpp",
       // Tokens that share a source range but have conflicting Kinds are not
@@ -386,7 +386,7 @@
       // Preamble ends.
       $Macro[[DEF_MULTIPLE]](XYZ);
       $Macro[[DEF_MULTIPLE]](XYZW);
-      $Macro[[DEF_CLASS]]($Class_decl[[A]])
+      $Macro[[DEF_CLASS]]($Class_decl_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
@@ -396,27 +396,27 @@
       #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_decl_def[[foo]]() {
+        $Macro[[DEF_VAR]]($LocalVariable_decl_def[[X]],  123);
+        $Macro[[DEF_VAR_REV]](908, $LocalVariable_decl_def[[XY]]);
+        int $Macro[[CPY]]( $LocalVariable_decl_def[[XX]] );
+        $Macro[[DEF_VAR_TYPE]]($Class[[A]], $LocalVariable_decl_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_decl_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_decl_def[[MMMMM]], 567);
+      $Macro[[DEF_VAR_REV]](756, $Variable_decl_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_decl_def[[g]]) {
         $Macro[[CALL_FN]]($Function[[foo]]);
       }
     )cpp",
@@ -424,10 +424,10 @@
       #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_decl_def[[x]];
+      int $Variable_decl_def[[y]];
       int $Function_decl[[f]]();
-      void $Function_decl[[foo]]() {
+      void $Function_decl_def[[foo]]() {
         $Macro[[assert]]($Variable[[x]] != $Variable[[y]]);
         $Macro[[assert]]($Variable[[x]] != $Function[[f]]());
       }
@@ -447,14 +447,14 @@
 $InactiveCode[[#endif]]
     )cpp",
       R"cpp(
-      struct $Class_decl[[S]] {
+      struct $Class_decl_def[[S]] {
         float $Field_decl[[Value]];
         $Class[[S]] *$Field_decl[[Next]];
       };
-      $Class[[S]] $Variable_decl[[Global]][2] = {$Class[[S]](), $Class[[S]]()};
+      $Class[[S]] $Variable_decl_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_decl_def[[f]]($Class[[S]] $Parameter_decl[[P]]) {
+        int $LocalVariable_decl_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]];
@@ -464,7 +464,7 @@
     )cpp",
       R"cpp(
       template<class $TemplateParameter_decl[[T]]>
-      class $Class_decl[[A]] {
+      class $Class_decl_def[[A]] {
         using $TemplateParameter_decl[[TemplateParam1]] = $TemplateParameter[[T]];
         typedef $TemplateParameter[[T]] $TemplateParameter_decl[[TemplateParam2]];
         using $Primitive_decl[[IntType]] = int;
@@ -485,31 +485,31 @@
       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_decl_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_decl_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_decl_def[[foo]]($TemplateParameter[[U]] $Parameter_decl[[P]]) {
         $Class[[A]]().$Method[[bar]]($Parameter[[P]]);
       }
     )cpp",
       R"cpp(
-      struct $Class_decl[[A]] {
+      struct $Class_decl_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_decl_def[[B]] {
+        void $Method_decl_def[[bar]]() {
           $Class[[A]]::$StaticMethod_static[[foo]]($TemplateParameter[[T]]());
         }
       };
@@ -521,14 +521,14 @@
     )cpp",
       R"cpp(
       template <class $TemplateParameter_decl[[T]]>
-      void $Function_decl[[foo]]($TemplateParameter[[T]] $Parameter_decl[[P]]) {
+      void $Function_decl_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_decl_def[[A]] {
+        int $Method_decl_def[[foo]]() {
           return $TemplateParameter[[T]]::$Unknown_dependentName[[Field]];
         }
       };
@@ -542,7 +542,7 @@
       R"cpp(
       template <template <class> class $TemplateParameter_decl[[TT]],
                 template <class> class ...$TemplateParameter_decl[[TTs]]>
-      struct $Class_decl[[Foo]] {
+      struct $Class_decl_def[[Foo]] {
         $Class[[Foo]]<$TemplateParameter[[TT]], $TemplateParameter[[TTs]]...>
           *$Field_decl[[t]];
       };
@@ -555,7 +555,7 @@
 $InactiveCode[[#endif]]
 
       // A declaration to cause the preamble to end.
-      int $Variable_decl[[EndPreamble]];
+      int $Variable_decl_def[[EndPreamble]];
 
       // Code after the preamble.
       // Code inside inactive blocks does not get regular highlightings
@@ -564,25 +564,25 @@
 $InactiveCode[[#if defined(test)]]
 $InactiveCode[[int Inactive2;]]
 $InactiveCode[[#elif defined(test2)]]
-      int $Variable_decl[[Active1]];
+      int $Variable_decl_def[[Active1]];
 $InactiveCode[[#else]]
 $InactiveCode[[int Inactive3;]]
 $InactiveCode[[#endif]]
 
       #ifndef $Macro[[test]]
-      int $Variable_decl[[Active2]];
+      int $Variable_decl_def[[Active2]];
       #endif
 
 $InactiveCode[[#ifdef test]]
 $InactiveCode[[int Inactive4;]]
 $InactiveCode[[#else]]
-      int $Variable_decl[[Active3]];
+      int $Variable_decl_def[[Active3]];
       #endif
     )cpp",
       // Argument to 'sizeof...'
       R"cpp(
       template <typename... $TemplateParameter_decl[[Elements]]>
-      struct $Class_decl[[TupleSize]] {
+      struct $Class_decl_def[[TupleSize]] {
         static const int $StaticField_decl_readonly_static[[size]] =
 sizeof...($TemplateParameter[[Elements]]);
       };
@@ -590,7 +590,7 @@
       // More dependent types
       R"cpp(
       template <typename $TemplateParameter_decl[[T]]>
-      struct $Class_decl[[Waldo]] {
+      struct $Class_decl_def[[Waldo]] {
         using $Typedef_decl[[Location1]] = typename $TemplateParameter[[T]]
             ::$Type_dependentName[[Resolver]]::$Type_dependentName[[Location]];
         using $Typedef_decl[[Location2]] = typename $TemplateParameter[[T]]
@@ -606,13 +606,13 @@
       // Dependent name with heuristic target
       R"cpp(
       template <typename>
-      struct $Class_decl[[Foo]] {
+      struct $Class_decl_def[[Foo]] {
         int $Field_decl[[Waldo]];
-        void $Method_decl[[bar]]() {
+        void $Method_decl_def[[bar]]() {
           $Class[[Foo]]().$Field_dependentName[[Waldo]];
         }
         template <typename $TemplateParameter_decl[[U]]>
-        void $Method_decl[[bar1]]() {
+        void $Method_decl_def[[bar1]]() {
           $Class[[Foo]]<$TemplateParameter[[U]]>().$Field_dependentName[[Waldo]];
         }
 
@@ -620,52 +620,52 @@
         void $Method_decl_readonly[[Overload]]() const;
       };
       template <typename $TemplateParameter_decl[[T]]>
-      void $Function_decl[[baz]]($Class[[Foo]]<$TemplateParameter[[T]]> $Parameter_decl[[o]]) {
+      void $Function_decl_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_decl_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_decl_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_decl_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_decl_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_decl_def_deprecated[[x]];
       )cpp",
       R"cpp(
         // ObjC: Classes and methods
         @class $Class_decl[[Forward]];
 
-        @interface $Class_decl[[Foo]]
+        @interface $Class_decl_def[[Foo]]
         @end
-        @interface $Class_decl[[Bar]] : $Class[[Foo]]
+        @interface $Class_decl_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]];
@@ -678,7 +678,7 @@
         +(void) $StaticMethod_decl_static[[explode]] {}
         @end
 
-        void $Function_decl[[m]]($Class[[Bar]] *$Parameter_decl[[b]]) {
+        void $Function_decl_def[[m]]($Class[[Bar]] *$Parameter_decl[[b]]) {
           [$Parameter[[b]] $Method[[x]]:1 $Method[[y]]:2];
           [$Class[[Bar]] $StaticMethod_static[[explode]]];
         }
@@ -689,13 +689,13 @@
         @end
         @protocol $Interface_decl[[Protocol2]] <$Interface[[Protocol]]>
         @end
-        @interface $Class_decl[[Klass]] <$Interface[[Protocol]]>
+        @interface $Class_decl_def[[Klass]] <$Interface[[Protocol]]>
         @end
-        id<$Interface[[Protocol]]> $Variable_decl[[x]];
+        id<$Interface[[Protocol]]> $Variable_decl_def[[x]];
       )cpp",
       R"cpp(
         // ObjC: Categories
-        @interface $Class_decl[[Foo]]
+        @interface $Class_decl_def[[Foo]]
         @end
         @interface $Class[[Foo]]($Namespace_decl[[Bar]])
         @end
@@ -704,7 +704,7 @@
       )cpp",
       R"cpp(
         // ObjC: Properties and Ivars.
-        @interface $Class_decl[[Foo]] {
+        @interface $Class_decl_def[[Foo]] {
           int $Field_decl[[_someProperty]];
         }
         @property(nonatomic, assign) int $Field_decl[[someProperty]];
@@ -724,65 +724,65 @@
       )cpp",
       // Member imported from dependent base
       R"cpp(
-        template <typename> struct $Class_decl[[Base]] {
+        template <typename> struct $Class_decl_def[[Base]] {
           int $Field_decl[[member]];
         };
         template <typename $TemplateParameter_decl[[T]]>
-        struct $Class_decl[[Derived]] : $Class[[Base]]<$TemplateParameter[[T]]> {
+        struct $Class_decl_def[[Derived]] : $Class[[Base]]<$TemplateParameter[[T]]> {
           using $Class[[Base]]<$TemplateParameter[[T]]>::$Field_dependentName[[member]];
 
-          void $Method_decl[[method]]() {
+          void $Method_decl_def[[method]]() {
             (void)$Field_dependentName[[member]];
           }
         };
       )cpp",
       // Modifier for variables passed as non-const references
       R"cpp(
-        void $Function_decl[[fun]](int, const int,
+        void $Function_decl_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_decl_def[[val]];
+          int* $LocalVariable_decl_def[[ptr]];
+          const int* $LocalVariable_decl_def_readonly[[constPtr]];
+          int** $LocalVariable_decl_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]]
                            );
         }
-        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_decl_def[[S]] {
+          $Class_decl_def[[S]](int&) {
+            $Class[[S]] $LocalVariable_decl_def[[s1]]($Field_usedAsMutableReference[[field]]);
+            $Class[[S]] $LocalVariable_decl_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_decl_def[[s3]]($StaticField_static_usedAsMutableReference[[staticField]]);
+            $Class[[S]] $LocalVariable_decl_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_decl_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_decl_def[[foo]]() {
+          int $LocalVariable_decl_def[[a]], $LocalVariable_decl_def[[b]];
+          [ $LocalVariable_decl_def[[c]] = $LocalVariable[[a]],
+            $LocalVariable_decl_def[[d]]($LocalVariable[[b]]) ]() {}();
         }
       )cpp",
       // Enum base specifier
@@ -802,24 +802,24 @@
         <:<: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_decl_def[[Bar]]($TemplateParameter[[T]] $Parameter_decl[[x]]) {
+            $Function_deprecated[[Foo]]($Parameter[[x]]);
+            $Function_deprecated[[Foo]]($Parameter[[x]]);
+            $Function_deprecated[[Foo]]($Parameter[[x]]);
         }
       )cpp",
       // Explicit template specialization
       R"cpp(
-        struct $Class_decl[[Base]]{};
+        struct $Class_decl_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_decl_def[[S]] : public $Class[[Base]] {};
+        template <>
+        struct $Class_decl_def[[S]]<void> : public $Class[[Base]] {};
 
         template <typename $TemplateParameter_decl[[T]]>
-        $TemplateParameter[[T]] $Variable_decl[[x]] = {};
+        $TemplateParameter[[T]] $Variable_decl_def[[x]] = {};
         template <>
-        int $Variable_decl[[x]]<int> = (int)sizeof($Class[[Base]]);
+        int $Variable_decl_def[[x]]<int> = (int)sizeof($Class[[Base]]);
       )cpp"};
   for (const auto &TestCase : TestCases)
     // Mask off scope modifiers to keep the tests manageable.
@@ -827,7 +827,7 @@
     checkHighlightings(TestCase, {}, ~ScopeModifierMask);
 
   checkHighlightings(R"cpp(
-    class $Class_decl[[A]] {
+    class $Class_decl_def[[A]] {
       #include "imp.h"
     };
   )cpp",
@@ -856,8 +856,8 @@
     @interface $Class_defaultLibrary[[SYSObject]] ($Namespace_decl[[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_decl_def[[somethingUsingSystemSymbols]]() {
+      $Class_defaultLibrary[[SYSObject]] *$LocalVariable_decl_def[[obj]] = [$Class_defaultLibrary[[SYSObject]] $StaticMethod_static_defaultLibrary[[new]]];
       return $LocalVariable[[obj]].$Field_defaultLibrary[[value]] + $LocalVariable[[obj]].$Field_readonly[[user_property]];
     }
   )cpp",
diff --git a/clang-tools-extra/clangd/unittests/tweaks/AnnotateHighlightingsTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/AnnotateHighlightingsTests.cpp
--- a/clang-tools-extra/clangd/unittests/tweaks/AnnotateHighlightingsTests.cpp
+++ b/clang-tools-extra/clangd/unittests/tweaks/AnnotateHighlightingsTests.cpp
@@ -18,18 +18,18 @@
 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