[clangd] Add a distinct highlighting for local variables

[nridge]

Summary

It's useful to be able to distinguish local variables from namespace
scope variables.

[ilya-biryukov]

clang-tools-extra/clangd/SemanticHighlighting.h

38

NIT: maybe put it right after Variable? IIUC, we do not rely on actual numeric values being the same across different clangd versions.

[kadircet]

clang-tools-extra/clangd/SemanticHighlighting.cpp

229

nit: addToken(Loc, VD->isLocalVarDecl() ? HighlightingKind::LocalVariable : HighlightingKind::Variable)

[hokein]

clang-tools-extra/clangd/SemanticHighlighting.h

38

+1, related symbols should be grouped together.

clang-tools-extra/clangd/SemanticHighlighting.h

enum class HighlightingKind {
   Method,
   Field,
   Class,
   Enum,
   EnumConstant,
   Namespace,
   TemplateParameter,
   Primitive,
+  LocalVariable,
 
   NumKinds,
 };
 
 // Contains all information needed for the highlighting a token.
 struct HighlightingToken {
   HighlightingKind Kind;
   Range R;

clang-tools-extra/clangd/SemanticHighlighting.cpp

void addToken(SourceLocation Loc, const NamedDecl *D) {
     if (isa<EnumConstantDecl>(D)) {
       addToken(Loc, HighlightingKind::EnumConstant);
       return;
     }
     if (isa<ParmVarDecl>(D)) {
       addToken(Loc, HighlightingKind::Parameter);
       return;
     }
-    if (isa<VarDecl>(D)) {
+    if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
+      if (VD->isLocalVarDecl()) {
+        addToken(Loc, HighlightingKind::LocalVariable);
+        return;
+      }
       addToken(Loc, HighlightingKind::Variable);
       return;
     }
     if (isa<FunctionDecl>(D)) {
       addToken(Loc, HighlightingKind::Function);
       return;
     }
     if (isa<NamespaceDecl>(D)) {
void addToken(SourceLocation Loc, const NamedDecl *D) {
     }
     if (isa<NonTypeTemplateParmDecl>(D)) {
       addToken(Loc, HighlightingKind::TemplateParameter);
       return;
     }
   }
 
   void addToken(SourceLocation Loc, HighlightingKind Kind) {
-    if(Loc.isMacroID()) {
+    if (Loc.isMacroID()) {
       // Only intereseted in highlighting arguments in macros (DEF_X(arg)).
       if (!SM.isMacroArgExpansion(Loc))
         return;
       Loc = SM.getSpellingLoc(Loc);
     }
 
     // Non top level decls that are included from a header are not filtered by
     // topLevelDecls. (example: method declarations being included from another
     // file for a class from another file)
-    // There are also cases with macros where the spelling loc will not be in the
-    // main file and the highlighting would be incorrect.
+    // There are also cases with macros where the spelling loc will not be in
+    // the main file and the highlighting would be incorrect.
     if (!isInsideMainFile(Loc, SM))
       return;
 
     auto R = getTokenRange(SM, Ctx.getLangOpts(), Loc);
     if (!R) {
       // R should always have a value, if it doesn't something is very wrong.
       elog("Tried to add semantic token with an invalid range");
       return;
return ArrayRef<HighlightingToken>(StartLineIt, AllTokens.end())
         return Token.R.start.line == Line;
       });
 }
 } // namespace
 
 std::vector<LineHighlightings>
 diffHighlightings(ArrayRef<HighlightingToken> New,
                   ArrayRef<HighlightingToken> Old, int NewMaxLine) {
-  assert(std::is_sorted(New.begin(), New.end()) && "New must be a sorted vector");
-  assert(std::is_sorted(Old.begin(), Old.end()) && "Old must be a sorted vector");
+  assert(std::is_sorted(New.begin(), New.end()) &&
+         "New must be a sorted vector");
+  assert(std::is_sorted(Old.begin(), Old.end()) &&
+         "Old must be a sorted vector");
 
   // FIXME: There's an edge case when tokens span multiple lines. If the first
   // token on the line started on a line above the current one and the rest of
   // the line is the equal to the previous one than we will remove all
   // highlights but the ones for the token spanning multiple lines. This means
   // that when we get into the LSP layer the only highlights that will be
   // visible are the ones for the token spanning multiple lines.
   // Example:
   // EndOfMultilineToken  Token Token Token
   // If "Token Token Token" don't differ from previously the line is
   // incorrectly removed. Suggestion to fix is to separate any multiline tokens
   // into one token for every line it covers. This requires reading from the
   // file buffer to figure out the length of each line though.
   std::vector<LineHighlightings> DiffedLines;
   // ArrayRefs to the current line in the highlightings.
   ArrayRef<HighlightingToken> NewLine(New.begin(),
                                       /*length*/ static_cast<size_t>(0));
   ArrayRef<HighlightingToken> OldLine(Old.begin(),
                                       /*length*/ static_cast<size_t>(0));
   auto NewEnd = New.end();
   auto OldEnd = Old.end();
   auto NextLineNumber = [&]() {
     int NextNew = NewLine.end() != NewEnd ? NewLine.end()->R.start.line
-                                             : std::numeric_limits<int>::max();
     int NextOld = OldLine.end() != OldEnd ? OldLine.end()->R.start.line
-                                             : std::numeric_limits<int>::max();
     return std::min(NextNew, NextOld);
   };
 
   // If the New file has fewer lines than the Old file we don't want to send
   // highlightings beyond the end of the file.
   for (int LineNumber = 0; LineNumber < NewMaxLine;
        LineNumber = NextLineNumber()) {
     NewLine = takeLine(New, NewLine.end(), LineNumber);
llvm::StringRef toTextMateScope(HighlightingKind Kind) {
   case HighlightingKind::EnumConstant:
     return "variable.other.enummember.cpp";
   case HighlightingKind::Namespace:
     return "entity.name.namespace.cpp";
   case HighlightingKind::TemplateParameter:
     return "entity.name.type.template.cpp";
   case HighlightingKind::Primitive:
     return "storage.type.primitive.cpp";
+  case HighlightingKind::LocalVariable:
+    return "variable.other.local.cpp";
   case HighlightingKind::NumKinds:
     llvm_unreachable("must not pass NumKinds to the function");
   }
   llvm_unreachable("unhandled HighlightingKind");
 }
 
 } // namespace clangd
 } // namespace clang

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

 # CHECK-NEXT:          [
 # CHECK-NEXT:            "entity.name.namespace.cpp"
 # CHECK-NEXT:          ],
 # CHECK-NEXT:          [
 # CHECK-NEXT:            "entity.name.type.template.cpp"
 # CHECK-NEXT:          ],
 # CHECK-NEXT:          [
 # CHECK-NEXT:            "storage.type.primitive.cpp"
+# CHECK-NEXT:          ],
+# CHECK-NEXT:          [
+# CHECK-NEXT:            "variable.other.local.cpp"
 # CHECK-NEXT:          ]
 # CHECK-NEXT:        ]
 # CHECK-NEXT:      },
 ---
 {"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"test:///foo.cpp","languageId":"cpp","version":1,"text":"int x = 2;"}}}
 #      CHECK:  "method": "textDocument/semanticHighlighting",
 # CHECK-NEXT:  "params": {
 # CHECK-NEXT:    "lines": [

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

static const std::map<HighlightingKind, std::string> KindToString{
       {HighlightingKind::Function, "Function"},
       {HighlightingKind::Class, "Class"},
       {HighlightingKind::Enum, "Enum"},
       {HighlightingKind::Namespace, "Namespace"},
       {HighlightingKind::EnumConstant, "EnumConstant"},
       {HighlightingKind::Field, "Field"},
       {HighlightingKind::Method, "Method"},
       {HighlightingKind::TemplateParameter, "TemplateParameter"},
-      {HighlightingKind::Primitive, "Primitive"}};
+      {HighlightingKind::Primitive, "Primitive"},
+      {HighlightingKind::LocalVariable, "LocalVariable"}};
   std::vector<HighlightingToken> ExpectedTokens;
   for (const auto &KindString : KindToString) {
     std::vector<HighlightingToken> Toks = makeHighlightingTokens(
         Test.ranges(KindString.second), KindString.first);
     ExpectedTokens.insert(ExpectedTokens.end(), Toks.begin(), Toks.end());
   }
   llvm::sort(ExpectedTokens);
   return ExpectedTokens;
void checkDiffedHighlights(llvm::StringRef OldCode, llvm::StringRef NewCode) {
   std::vector<LineHighlightings> ActualDiffed =
       diffHighlightings(NewTokens, OldTokens, NewCode.count('\n'));
   EXPECT_THAT(ActualDiffed,
               testing::UnorderedElementsAreArray(ExpectedLinePairHighlighting));
 }
 
 TEST(SemanticHighlighting, GetsCorrectTokens) {
   const char *TestCases[] = {
       R"cpp(
       struct $Class[[AS]] {
         $Primitive[[double]] $Field[[SomeMember]];
       };
       struct {
       } $Variable[[S]];
       $Primitive[[void]] $Function[[foo]]($Primitive[[int]] $Parameter[[A]], $Class[[AS]] $Parameter[[As]]) {
-        $Primitive[[auto]] $Variable[[VeryLongVariableName]] = 12312;
-        $Class[[AS]]     $Variable[[AA]];
-        $Primitive[[auto]] $Variable[[L]] = $Variable[[AA]].$Field[[SomeMember]] + $Parameter[[A]];
-        auto $Variable[[FN]] = [ $Variable[[AA]]]($Primitive[[int]] $Parameter[[A]]) -> $Primitive[[void]] {};
-        $Variable[[FN]](12312);
+        $Primitive[[auto]] $LocalVariable[[VeryLongVariableName]] = 12312;
+        $Class[[AS]]     $LocalVariable[[AA]];
+        $Primitive[[auto]] $LocalVariable[[L]] = $LocalVariable[[AA]].$Field[[SomeMember]] + $Parameter[[A]];
+        auto $LocalVariable[[FN]] = [ $LocalVariable[[AA]]]($Primitive[[int]] $Parameter[[A]]) -> $Primitive[[void]] {};
+        $LocalVariable[[FN]](12312);
       }
     )cpp",
       R"cpp(
       $Primitive[[void]] $Function[[foo]]($Primitive[[int]]);
       $Primitive[[void]] $Function[[Gah]]();
       $Primitive[[void]] $Function[[foo]]() {
-        auto $Variable[[Bou]] = $Function[[Gah]];
+        auto $LocalVariable[[Bou]] = $Function[[Gah]];
       }
       struct $Class[[A]] {
         $Primitive[[void]] $Method[[abc]]();
       };
     )cpp",
       R"cpp(
       namespace $Namespace[[abc]] {
         template<typename $TemplateParameter[[T]]>
         struct $Class[[A]] {
           $TemplateParameter[[T]] $Field[[t]];
         };
       }
       template<typename $TemplateParameter[[T]]>
       struct $Class[[C]] : $Namespace[[abc]]::$Class[[A]]<$TemplateParameter[[T]]> {
         typename $TemplateParameter[[T]]::A* $Field[[D]];
       };
       $Namespace[[abc]]::$Class[[A]]<$Primitive[[int]]> $Variable[[AA]];
       typedef $Namespace[[abc]]::$Class[[A]]<$Primitive[[int]]> $Class[[AAA]];
       struct $Class[[B]] {
         $Class[[B]]();
         ~$Class[[B]]();
         $Primitive[[void]] operator<<($Class[[B]]);
         $Class[[AAA]] $Field[[AA]];
       };
       $Class[[B]]::$Class[[B]]() {}
       $Class[[B]]::~$Class[[B]]() {}
       $Primitive[[void]] $Function[[f]] () {
-        $Class[[B]] $Variable[[BB]] = $Class[[B]]();
-        $Variable[[BB]].~$Class[[B]]();
+        $Class[[B]] $LocalVariable[[BB]] = $Class[[B]]();
+        $LocalVariable[[BB]].~$Class[[B]]();
         $Class[[B]]();
       }
     )cpp",
       R"cpp(
       enum class $Enum[[E]] {
         $EnumConstant[[A]],
         $EnumConstant[[B]],
       };
       enum $Enum[[EE]] {
         $EnumConstant[[Hi]],
       };
       struct $Class[[A]] {
         $Enum[[E]] $Field[[EEE]];
         $Enum[[EE]] $Field[[EEEE]];
       };
       $Primitive[[int]] $Variable[[I]] = $EnumConstant[[Hi]];
       $Enum[[E]] $Variable[[L]] = $Enum[[E]]::$EnumConstant[[B]];
     )cpp",
       R"cpp(
       namespace $Namespace[[abc]] {
         namespace {}
         namespace $Namespace[[bcd]] {
           struct $Class[[A]] {};
           namespace $Namespace[[cde]] {
             struct $Class[[A]] {
               enum class $Enum[[B]] {
                 $EnumConstant[[Hi]],
               };
             };
           }
         }
       }
       using namespace $Namespace[[abc]]::$Namespace[[bcd]];
       namespace $Namespace[[vwz]] =
             $Namespace[[abc]]::$Namespace[[bcd]]::$Namespace[[cde]];
       $Namespace[[abc]]::$Namespace[[bcd]]::$Class[[A]] $Variable[[AA]];
       $Namespace[[vwz]]::$Class[[A]]::$Enum[[B]] $Variable[[AAA]] =
             $Namespace[[vwz]]::$Class[[A]]::$Enum[[B]]::$EnumConstant[[Hi]];
       ::$Namespace[[vwz]]::$Class[[A]] $Variable[[B]];
       ::$Namespace[[abc]]::$Namespace[[bcd]]::$Class[[A]] $Variable[[BB]];
     )cpp",
       R"cpp(
       struct $Class[[D]] {
         $Primitive[[double]] $Field[[C]];
       };
       struct $Class[[A]] {
         $Primitive[[double]] $Field[[B]];
         $Class[[D]] $Field[[E]];
         static $Primitive[[double]] $Variable[[S]];
         $Primitive[[void]] $Method[[foo]]() {
           $Field[[B]] = 123;
           this->$Field[[B]] = 156;
           this->$Method[[foo]]();
           $Method[[foo]]();
           $Variable[[S]] = 90.1;
         }
       };
       $Primitive[[void]] $Function[[foo]]() {
-        $Class[[A]] $Variable[[AA]];
-        $Variable[[AA]].$Field[[B]] += 2;
-        $Variable[[AA]].$Method[[foo]]();
-        $Variable[[AA]].$Field[[E]].$Field[[C]];
+        $Class[[A]] $LocalVariable[[AA]];
+        $LocalVariable[[AA]].$Field[[B]] += 2;
+        $LocalVariable[[AA]].$Method[[foo]]();
+        $LocalVariable[[AA]].$Field[[E]].$Field[[C]];
         $Class[[A]]::$Variable[[S]] = 90;
       }
     )cpp",
       R"cpp(
       struct $Class[[AA]] {
         $Primitive[[int]] $Field[[A]];
       }
       $Primitive[[int]] $Variable[[B]];
       $Class[[AA]] $Variable[[A]]{$Variable[[B]]};
     )cpp",
       R"cpp(
       namespace $Namespace[[a]] {
         struct $Class[[A]] {};
         typedef $Primitive[[char]] $Primitive[[C]];
       }
       typedef $Namespace[[a]]::$Class[[A]] $Class[[B]];
       using $Class[[BB]] = $Namespace[[a]]::$Class[[A]];
       enum class $Enum[[E]] {};
       typedef $Enum[[E]] $Enum[[C]];
       typedef $Enum[[C]] $Enum[[CC]];
       using $Enum[[CD]] = $Enum[[CC]];
       $Enum[[CC]] $Function[[f]]($Class[[B]]);
       $Enum[[CD]] $Function[[f]]($Class[[BB]]);
       typedef $Namespace[[a]]::$Primitive[[C]] $Primitive[[PC]];
       typedef $Primitive[[float]] $Primitive[[F]];
     )cpp",
       R"cpp(
       template<typename $TemplateParameter[[T]], typename = $Primitive[[void]]>
       class $Class[[A]] {
         $TemplateParameter[[T]] $Field[[AA]];
         $TemplateParameter[[T]] $Method[[foo]]();
       };
       template<class $TemplateParameter[[TT]]>
       class $Class[[B]] {
         $Class[[A]]<$TemplateParameter[[TT]]> $Field[[AA]];
)cpp",
       $TemplateParameter[[T]]<$TemplateParameter[[C]]> $Function[[f]]();
 
       template<typename>
       class $Class[[Foo]] {};
 
       template<typename $TemplateParameter[[T]]>
       $Primitive[[void]] $Function[[foo]]($TemplateParameter[[T]] ...);
     )cpp",
       R"cpp(
       template <class $TemplateParameter[[T]]>
       struct $Class[[Tmpl]] {$TemplateParameter[[T]] $Field[[x]] = 0;};
       extern template struct $Class[[Tmpl]]<$Primitive[[float]]>;
       template struct $Class[[Tmpl]]<$Primitive[[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[[Foo]] {};
       struct $Class[[Bar]] {
         explicit operator $Class[[Foo]]*() const;
         explicit operator $Primitive[[int]]() const;
         operator $Class[[Foo]]();
       };
       $Primitive[[void]] $Function[[f]]() {
-        $Class[[Bar]] $Variable[[B]];
-        $Class[[Foo]] $Variable[[F]] = $Variable[[B]];
-        $Class[[Foo]] *$Variable[[FP]] = ($Class[[Foo]]*)$Variable[[B]];
-        $Primitive[[int]] $Variable[[I]] = ($Primitive[[int]])$Variable[[B]];
+        $Class[[Bar]] $LocalVariable[[B]];
+        $Class[[Foo]] $LocalVariable[[F]] = $LocalVariable[[B]];
+        $Class[[Foo]] *$LocalVariable[[FP]] = ($Class[[Foo]]*)$LocalVariable[[B]];
+        $Primitive[[int]] $LocalVariable[[I]] = ($Primitive[[int]])$LocalVariable[[B]];
       }
     )cpp"
       R"cpp(
       struct $Class[[B]] {};
       struct $Class[[A]] {
         $Class[[B]] $Field[[BB]];
         $Class[[A]] &operator=($Class[[A]] &&$Parameter[[O]]);
       };
 
       $Class[[A]] &$Class[[A]]::operator=($Class[[A]] &&$Parameter[[O]]) = default;
     )cpp",
       R"cpp(
       enum $Enum[[En]] {
         $EnumConstant[[EC]],
       };
       class $Class[[Foo]] {};
       class $Class[[Bar]] {
         $Class[[Foo]] $Field[[Fo]];
         $Enum[[En]] $Field[[E]];
         $Primitive[[int]] $Field[[I]];
         $Class[[Bar]] ($Class[[Foo]] $Parameter[[F]],
                 $Enum[[En]] $Parameter[[E]])
         : $Field[[Fo]] ($Parameter[[F]]), $Field[[E]] ($Parameter[[E]]),
           $Field[[I]] (123) {}
       };
       class $Class[[Bar2]] : public $Class[[Bar]] {
         $Class[[Bar2]]() : $Class[[Bar]]($Class[[Foo]](), $EnumConstant[[EC]]) {}
       };
     )cpp",
       R"cpp(
       enum $Enum[[E]] {
         $EnumConstant[[E]],
       };
       class $Class[[Foo]] {};
       $Enum[[auto]] $Variable[[AE]] = $Enum[[E]]::$EnumConstant[[E]];
       $Class[[auto]] $Variable[[AF]] = $Class[[Foo]]();
       $Class[[decltype]](auto) $Variable[[AF2]] = $Class[[Foo]]();
       $Class[[auto]] *$Variable[[AFP]] = &$Variable[[AF]];
       $Enum[[auto]] &$Variable[[AER]] = $Variable[[AE]];
       $Primitive[[auto]] $Variable[[Form]] = 10.2 + 2 * 4;
       $Primitive[[decltype]]($Variable[[Form]]) $Variable[[F]] = 10;
       auto $Variable[[Fun]] = []()->$Primitive[[void]]{};
     )cpp",
       R"cpp(
       class $Class[[G]] {};
       template<$Class[[G]] *$TemplateParameter[[U]]>
       class $Class[[GP]] {};
       template<$Class[[G]] &$TemplateParameter[[U]]>
       class $Class[[GR]] {};
       template<$Primitive[[int]] *$TemplateParameter[[U]]>
       class $Class[[IP]] {
         $Primitive[[void]] $Method[[f]]() {
           *$TemplateParameter[[U]] += 5;
         }
       };
       template<$Primitive[[unsigned]] $TemplateParameter[[U]] = 2>
       class $Class[[Foo]] {
         $Primitive[[void]] $Method[[f]]() {
-          for($Primitive[[int]] $Variable[[I]] = 0;
-            $Variable[[I]] < $TemplateParameter[[U]];) {}
+          for($Primitive[[int]] $LocalVariable[[I]] = 0;
+            $LocalVariable[[I]] < $TemplateParameter[[U]];) {}
         }
       };
 
       $Class[[G]] $Variable[[L]];
       $Primitive[[void]] $Function[[f]]() {
-        $Class[[Foo]]<123> $Variable[[F]];
-        $Class[[GP]]<&$Variable[[L]]> $Variable[[LL]];
-        $Class[[GR]]<$Variable[[L]]> $Variable[[LLL]];
+        $Class[[Foo]]<123> $LocalVariable[[F]];
+        $Class[[GP]]<&$Variable[[L]]> $LocalVariable[[LL]];
+        $Class[[GR]]<$Variable[[L]]> $LocalVariable[[LLL]];
       }
     )cpp",
       R"cpp(
       template<typename $TemplateParameter[[T]], 
         $Primitive[[void]] (T::*$TemplateParameter[[method]])($Primitive[[int]])>
       struct $Class[[G]] {
         $Primitive[[void]] $Method[[foo]](
             $TemplateParameter[[T]] *$Parameter[[O]]) {
           ($Parameter[[O]]->*$TemplateParameter[[method]])(10);
         }
       };
       struct $Class[[F]] {
         $Primitive[[void]] $Method[[f]]($Primitive[[int]]);
       };
       template<$Primitive[[void]] (*$TemplateParameter[[Func]])()>
       struct $Class[[A]] {
         $Primitive[[void]] $Method[[f]]() {
           (*$TemplateParameter[[Func]])();
         }
       };
 
       $Primitive[[void]] $Function[[foo]]() {
-        $Class[[F]] $Variable[[FF]];
-        $Class[[G]]<$Class[[F]], &$Class[[F]]::$Method[[f]]> $Variable[[GG]];
-        $Variable[[GG]].$Method[[foo]](&$Variable[[FF]]);
-        $Class[[A]]<$Function[[foo]]> $Variable[[AA]];
+        $Class[[F]] $LocalVariable[[FF]];
+        $Class[[G]]<$Class[[F]], &$Class[[F]]::$Method[[f]]> $LocalVariable[[GG]];
+        $LocalVariable[[GG]].$Method[[foo]](&$LocalVariable[[FF]]);
+        $Class[[A]]<$Function[[foo]]> $LocalVariable[[AA]];
     )cpp",
       // Tokens that share a source range but have conflicting Kinds are not
       // highlighted.
       R"cpp(
       #define DEF_MULTIPLE(X) namespace X { class X { int X; }; }
       #define DEF_CLASS(T) class T {};
       DEF_MULTIPLE(XYZ);
       DEF_MULTIPLE(XYZW);
       DEF_CLASS($Class[[A]])
       #define MACRO_CONCAT(X, V, T) T foo##X = V
       #define DEF_VAR(X, V) int X = V
       #define DEF_VAR_T(T, X, V) T X = V
       #define DEF_VAR_REV(V, X) DEF_VAR(X, V)
       #define CPY(X) X
       #define DEF_VAR_TYPE(X, Y) X Y
       #define SOME_NAME variable
       #define SOME_NAME_SET variable2 = 123
       #define INC_VAR(X) X += 2
       $Primitive[[void]] $Function[[foo]]() {
-        DEF_VAR($Variable[[X]],  123);
-        DEF_VAR_REV(908, $Variable[[XY]]);
-        $Primitive[[int]] CPY( $Variable[[XX]] );
-        DEF_VAR_TYPE($Class[[A]], $Variable[[AA]]);
+        DEF_VAR($LocalVariable[[X]],  123);
+        DEF_VAR_REV(908, $LocalVariable[[XY]]);
+        $Primitive[[int]] CPY( $LocalVariable[[XX]] );
+        DEF_VAR_TYPE($Class[[A]], $LocalVariable[[AA]]);
         $Primitive[[double]] SOME_NAME;
         $Primitive[[int]] SOME_NAME_SET;
-        $Variable[[variable]] = 20.1;
+        $LocalVariable[[variable]] = 20.1;
         MACRO_CONCAT(var, 2, $Primitive[[float]]);
-        DEF_VAR_T($Class[[A]], CPY(CPY($Variable[[Nested]])),
+        DEF_VAR_T($Class[[A]], CPY(CPY($LocalVariable[[Nested]])),
               CPY($Class[[A]]()));
-        INC_VAR($Variable[[variable]]);
+        INC_VAR($LocalVariable[[variable]]);
       }
       $Primitive[[void]] SOME_NAME();
       DEF_VAR($Variable[[XYZ]], 567);
       DEF_VAR_REV(756, $Variable[[AB]]);
 
       #define CALL_FN(F) F();
       #define DEF_FN(F) void F ()
       DEF_FN($Function[[g]]) {
         CALL_FN($Function[[foo]]);
       }
     )cpp",
       R"cpp(
       #define fail(expr) expr
       #define assert(COND) if (!(COND)) { fail("assertion failed" #COND); }
       $Primitive[[int]] $Variable[[x]];
       $Primitive[[int]] $Variable[[y]];
       $Primitive[[int]] $Function[[f]]();
       $Primitive[[void]] $Function[[foo]]() {
         assert($Variable[[x]] != $Variable[[y]]);
         assert($Variable[[x]] != $Function[[f]]());