[clangd] Add semantic token for angle brackets

[ckandeler]

Summary

This is needed for clients that would like to visualize matching
opening and closing angle brackets, which can be valuable in non-trivial
template declarations or instantiations.
It is not possible to do this with simple lexing, as the tokens
could also refer to operators.

[ckandeler]

Rebased.

[nridge]

I'm happy to review the implementation, but I would first appreciate some guidance from @sammccall or @kadircet about whether we should add these semantic token kinds in the first place.

They would be a non-standard extension to the LSP token kinds, so I think the use case for them should be fairly compelling.

It's true that there is an ambiguity between < and > as operators, vs. template arg/param list delimiters, but, at least in terms of user understanding of code, my sense is that the highlighting of the preceding token should be sufficient to disambiguate -- i.e. it would be some sort of type name in the template case, vs. a variable / literal / punctuation ending an expression in the operator case.

This is needed for clients that would like to visualize matching opening and closing angle brackets, which can be valuable in non-trivial template declarations or instantiations.

For this use case, could an editor make use of the recently added operator tokens (https://reviews.llvm.org/D136594) instead, inferring that a < token which does not have an operator semantic token is a template delimiter?

[ckandeler]

In D139926#4030782, @nridge wrote:

It's true that there is an ambiguity between < and > as operators, vs. template arg/param list delimiters, but, at least in terms of user understanding of code, my sense is that the highlighting of the preceding token should be sufficient to disambiguate -- i.e. it would be some sort of type name in the template case, vs. a variable / literal / punctuation ending an expression in the operator case.

We used to do this sort of heuristic in our old libclang-based implementation, and it turned out to be rather messy, with a surprising amount of exceptions having to be added.

This is needed for clients that would like to visualize matching opening and closing angle brackets, which can be valuable in non-trivial template declarations or instantiations.

For this use case, could an editor make use of the recently added operator tokens (https://reviews.llvm.org/D136594) instead, inferring that a < token which does not have an operator semantic token is a template delimiter?

I have a suspicion that this will lead to false positives for invalid code.

[nridge]

In D139926#4032473, @ckandeler wrote:

In D139926#4030782, @nridge wrote:

It's true that there is an ambiguity between < and > as operators, vs. template arg/param list delimiters, but, at least in terms of user understanding of code, my sense is that the highlighting of the preceding token should be sufficient to disambiguate -- i.e. it would be some sort of type name in the template case, vs. a variable / literal / punctuation ending an expression in the operator case.

We used to do this sort of heuristic in our old libclang-based implementation, and it turned out to be rather messy, with a surprising amount of exceptions having to be added.

To clarify, I'm not suggesting that any client-side logic use this heuristic, only that it's probably good enough for a human reader to disambiguate without needing to assign angle brackets and comparison operators different colors.

This is needed for clients that would like to visualize matching opening and closing angle brackets, which can be valuable in non-trivial template declarations or instantiations.

For this use case, could an editor make use of the recently added operator tokens (https://reviews.llvm.org/D136594) instead, inferring that a < token which does not have an operator semantic token is a template delimiter?

I have a suspicion that this will lead to false positives for invalid code.

Ah, interesting. I guess in the case of invalid code (no/malformed AST) you wouldn't get AngleBracket tokens either, so this gives you a three-way signal (Operator vs. AngleBracket vs. no semantic token) that's richer than just the two-way signal of Operator vs. no Operator.

[ckandeler]

In D139926#4033152, @nridge wrote:

In D139926#4032473, @ckandeler wrote:

In D139926#4030782, @nridge wrote:

It's true that there is an ambiguity between < and > as operators, vs. template arg/param list delimiters, but, at least in terms of user understanding of code, my sense is that the highlighting of the preceding token should be sufficient to disambiguate -- i.e. it would be some sort of type name in the template case, vs. a variable / literal / punctuation ending an expression in the operator case.

We used to do this sort of heuristic in our old libclang-based implementation, and it turned out to be rather messy, with a surprising amount of exceptions having to be added.

To clarify, I'm not suggesting that any client-side logic use this heuristic, only that it's probably good enough for a human reader to disambiguate without needing to assign angle brackets and comparison operators different colors.

Note that we use this information to *animate* the matching tokens, i.e. when the cursor is on one of them, both it and its counterpart get a special highlighting. That's why it's so important that the language server guarantees they always come in pairs.

[kadircet]

Sorry for missing this one, apparently I've already started writing an answer but got context switching and forgot about it.

This is needed for clients that would like to visualize matching
opening and closing angle brackets, which can be valuable in non-trivial
template declarations or instantiations.

I am not sure how the clients will make use of this information to visualize "matching" angle brackets. all the opening and closing brackets are likely to be visualized in the same way (respectively), no?
This will only make sure we have a distinction between << and >> used as operators vs </> and the rest of the work to highlight matching braces needs to be specially done by the editor.
Since we've the distinction of "operator" now as @nridge pointed out, I would rather want editors to use that information to skip brackets that have the operator highlighting.
I am not sure what concrete cases you've (it would help if you could provide some examples) for the incomplete code argument, because it goes both ways, i.e. I don't think the false positives you get in operators vs template argument lists won't be any different (e.g. foo<int> x, where foo is not defined won't have right highlighting).

[kadircet]

Note that we use this information to *animate* the matching tokens, i.e. when the cursor is on one of them, both it and its counterpart get a special highlighting. That's why it's so important that the language server guarantees they always come in pairs.

Oh I see the argument here (somehow missed comment, probably because i had a stale window lying around), this totally makes sense. but I am still feeling uneasy due to implementation complexity (it's embarrassing but dealing with >> is quite problematic, still, with little value :/) + the UX we'll have in other editors by default.
Especially as this comes as two different HighlightingKinds and they're likely to get colored differently, and having your matching brackets in different colors is quite annoying.

I feel like editors can still have a quite good behaviour with existing operator highlights, as one can build an extra layer on top to provide "matching bracket" support, and whenever the data is broken (e.g. non-matching brackets) just keep using the results from last "successful" run.

clang-tools-extra/clangd/SemanticHighlighting.cpp

409

there can be weird cases like (same goes for -1 below):

foo>\
>

can you add tests to make sure we're handling these properly (or not producing braces for them if it complicates the logic too much, i don't think there'll be many cases where they pop-up).

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

930

could you also add tests for >> and >>> to make sure they're handled correctly

[ckandeler]

In D139926#4056585, @kadircet wrote:

Especially as this comes as two different HighlightingKinds and they're likely to get colored differently, and having your matching brackets in different colors is quite annoying.

We can easily check the actual character at the given position in the client, so I could just merge the two highlighting kinds.

[nridge]

In D139926#4056478, @kadircet wrote:

This will only make sure we have a distinction between << and >> used as operators vs </>

Note that << and >> are not the only (or even the primary, in my mind) issue: there is an ambiguity between </> as template argument list delimiters vs. comparison operators.

For example:

template <bool>
class a {};

constexpr int b = 2;
constexpr int c = 3;

a<b>c> e;

Here, if the cursor is next to the <, a naive client-side angle-bracket matcher might highlight the first >, when the correct one to highlight would be the second one.

[nridge]

Sorry, that was a bad example as it's not actually valid. Here's a slightly modified one:

template <bool,int>
class a {};

constexpr int b = 2;
constexpr int c = 3;
constexpr int d = 4;

a<b<c,d> e;

The parser knows the first < opens a template-argument-list because the name before it, a, resolves to a template-name, and that the second < is a comparison operator because the name before that, b, does not.

But a naive client-side matcher might incorrectly pick the second < as the opening angle-bracket to match the >.

[ckandeler]

Added test cases, merged the two HighlightingKinds.

[kadircet]

We can easily check the actual character at the given position in the client, so I could just merge the two highlighting kinds.

Thanks! Note that it might not be as easy at the face of templates, eg:

#define LESS <
template LESS typename T > class A {};

Note that << and >> are not the only (or even the primary, in my mind) issue: there is an ambiguity between </> as template argument list delimiters vs. comparison operators.

Right, I was trying to imply all operator uses (e.g. including comparisons).

---

Currently my only high level comment is renaming the new kind to just bracket, apart from that i think the idea LG. LMK if you're going to take a look at the implementation @nridge, otherwise I am happy to do that as well.

clang-tools-extra/clangd/SemanticHighlighting.h

54

actually let's name these as Bracket rather than AngleBracket, as we might want to increase the coverage further in the future (and a use case such as yours can still look at the textual tokens to match relevant brackets).

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

939

i don't think this is enough of a test case, we probably need a bunch other like:

foo >\
>>

foo >\
 >>

i think the firstone is going to highlight \ for example.

[ckandeler]

Made token name more generic, added test cases.

[ckandeler]

In D139926#4064769, @kadircet wrote:

We can easily check the actual character at the given position in the client, so I could just merge the two highlighting kinds.

Thanks! Note that it might not be as easy at the face of templates, eg:

#define LESS <
template LESS typename T > class A {};

At least this one doesn't seem to be an issue; added test case.

clang-tools-extra/clangd/SemanticHighlighting.h

54

Yes, I was going to suggest this myself.

[nridge]

I played around with the patch a little, and found some cases where semantic tokens should be present but aren't:

template <typename T> class S {
public:
  template <typename U> class Nested;
};

// explicit specialization
// parameter list is missing semantic tokens
template <>
class S<int> {};

// partial specialization
// parameter and argument lists are missing semantic tokens
template <typename T>
class S<T*> {};

// nested template definition
// outer parameter list is missing semantic tokens
template <typename T>
template <typename U>
class S<T>::Nested {};

// nested template specialization
// both parameter lists are missing semantic tokens
template <>
template <>
class S<float>::Nested<float> {};

template <typename T> void foo();

void bar() {
  // function call with explicit template arguments
  // argument list is missing semantic tokens
  foo<int>();
}

template <typename T> constexpr int V = 42;

// variable template reference
// argument list is missing semantic tokens
constexpr int Y = V<char>;

// variable template specialization
// parameter and argument lists are missing semantic tokens
template <>
constexpr int V<int> = 5;

// variable template partial specialization
// parameter and argument lists are missing semantic tokens
template <typename T>
constexpr int V<T*> = 6;

template <typename T>
concept C = true;

// constrained template
// concept's argument list is missing semantic tokens
template <typename T> requires C<T>
class Z {};

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

939

It's easy to overlook this, could you please add a comment similar to:

// Semantic tokens for outer argument list are deliberately omitted to
// avoid having to handle line-continuations

(feel free to reword to better express the reason)

[nridge]

One other thought that has occurred to me is that as we add more semantic tolens for punctuation, the test cases in GetsCorrectTokens become harder to read.

What would you think about omitting punctuation tokens in the GetsCorrectTokens test cases (both Operator and Bracket, and any future ones), similarly to the way we already omit scope modifiers like _classScope, and have another test case like GetsCorrectPunctuationTokens where we put specifically test cases that test for punctuation tokens?

[ckandeler]

Added test cases from review comment and made them pass.

[ckandeler]

Thanks for the test cases!
All fixed, except:

variable template specialization
parameter and argument lists are missing semantic tokens
template <>
constexpr int V<int> = 5;

Argument list fixed. I didn't manage to make the parameter list work.

[ckandeler]

In D139926#4076057, @nridge wrote:

One other thought that has occurred to me is that as we add more semantic tolens for punctuation, the test cases in GetsCorrectTokens become harder to read.

What would you think about omitting punctuation tokens in the GetsCorrectTokens test cases (both Operator and Bracket, and any future ones), similarly to the way we already omit scope modifiers like _classScope, and have another test case like GetsCorrectPunctuationTokens where we put specifically test cases that test for punctuation tokens?

I suppose that's an option, but I don't have a strong opinion on this.

[nridge]

In D139926#4076652, @ckandeler wrote:

Thanks for the test cases!
All fixed, except:

variable template specialization
parameter and argument lists are missing semantic tokens
template <>
constexpr int V<int> = 5;

Argument list fixed. I didn't manage to make the parameter list work.

Thanks! That one remaining case seems to be a bug in the AST, I investigated it a bit and posted a fix at D142692. It should make your code work without further modification (the missing template parameter list will start showing up in VarTemplateSpecializationDecl::getNumTemplateParameterLists()).

[nridge]

Function calls are still missing some cases:

template <typename> void free();

template <typename T>
struct A {
  template <typename> void mem();
};

void foo() {
  A<int> a;
  a.mem<int>();  // <--
}

template<typename T>
void bar() {
    free<T>();  // <--

    A<int> a;
    a.mem<T>();  // <--

    A<T> b;
    b.template mem<T>();  // <--
}

[nridge]

Two more cases I found:

template <typename, typename>
concept C = true;

template <C<int> A>  // <-- (inner pair)
class B {};

This is a TypeConstraint, but RecursiveASTVisitor is lacking a Visit() method for it, so I think you'll need to override TraverseTypeConstraint() instead (example)

template <class T>
class A {
   template <class U> void foo(U a) { }
   template<> void foo(int a) { }  // <--
};

This one is ClassScopeFunctionSpecializationDecl::getTemplateArgsAsWritten()

clang-tools-extra/clangd/SemanticHighlighting.cpp

631

I would suggest moving this loop into VisitTagDecl(), as TagDecl is the base class of ClassTemplateSpecializationDecl that declares getNumTemplateParameterLists(). That way, we can be sure every derived class is handled.

648

Similarly, I would suggest moving this loop into VisitDeclaratorDecl.

(The args loop can stay here.)

[nridge]

clang-tools-extra/clangd/SemanticHighlighting.cpp

631

(Here's an example of a TagDecl which is not a ClassTemplateSpecializationDecl but has a template parameter list:

template <typename>
class A {
  enum class E;
};

template <typename T> // <--
enum class A<T>::E {X, Y, Z};

)

[ckandeler]

In D139926#4084801, @nridge wrote:

Function calls are still missing some cases:

I would have expected these to be handled by VisitDeclRefExpr(), but they aren't. Any idea?

[nridge]

In D139926#4084854, @ckandeler wrote:

I would have expected these to be handled by VisitDeclRefExpr(), but they aren't. Any idea?

There are two other expression types, DependentScopeDeclRefExpr and CXXDependentScopeMemberExpr, which are used to model decl-ref-exprs where the referent decl cannot be resolved until instantiation.

[nridge]

In D139926#4084856, @nridge wrote:

In D139926#4084854, @ckandeler wrote:

I would have expected these to be handled by VisitDeclRefExpr(), but they aren't. Any idea?

There are two other expression types, DependentScopeDeclRefExpr and CXXDependentScopeMemberExpr, which are used to model decl-ref-exprs where the referent decl cannot be resolved until instantiation.

Oh and the non-dependent a.mem<int> one is MemberExpr

[nridge]

I figured I might as well look through the AST API for classes with getLAngleLoc/getRAngleLoc methods.

It looks like we've got almost all of them (including the ones mentioned in recent comments) except:

• OverloadExpr
• DependentTemplateSpecializationTypeLoc
• AutoTypeLoc

[ckandeler]

Handled more cases.

[ckandeler]

In D139926#4084868, @nridge wrote:

I figured I might as well look through the AST API for classes with getLAngleLoc/getRAngleLoc methods.

It looks like we've got almost all of them (including the ones mentioned in recent comments) except:

• OverloadExpr
• DependentTemplateSpecializationTypeLoc
• AutoTypeLoc

Adding AutoTypeLoc broke tons of tests, so I left it out for now.

[ckandeler]

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

1026

Note that C2 does not get a token here. Maybe we can fix that along the way?

[nridge]

In D139926#4084970, @ckandeler wrote:

Adding AutoTypeLoc broke tons of tests, so I left it out for now.

Poked at this a bit, it looks like AutoTypeLoc.getLAngleLoc() is only safe to access if it isConstrained(). This is poor API (it would be better to return an invalid SourceLocation rather than garbage in the !isConstrained() case) but for now we can check isConstrained() at our call site.

[nridge]

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

1026

That token should come via findExplicitReferences rather than CollectExtraHighlightings, so I put the fix in a separate patch: D142871

[nridge]

In D139926#4084846, @nridge wrote:

template <class T>
class A {
   template <class U> void foo(U a) { }
   template<> void foo(int a) { }  // <--
};

This one is ClassScopeFunctionSpecializationDecl::getTemplateArgsAsWritten()

I got this testcase slightly wrong, the template<> is handled via VisitDeclaratorDecl, but it can have arguments as well:

template <class T>
class A {
   template <class U> void foo(U a) { }
   template<> void foo<int>(int a) { }  // note the <int>
};

which is what requires handling ClassScopeFunctionSpecializationDecl::getTemplateArgsAsWritten()

[nridge]

I did find one other edge case (last one, I promise!)

template <class T> void foo(T);
template <class T> class A {
  friend void foo<>(T);  // <--
};

This one is FunctionDecl::getDependentSpecializationInfo()->getLAngleLoc()

[ckandeler]

Support more cases as per review comments.

[nridge]

Thanks for the updates!

In D139926#4064769, @kadircet wrote:

LMK if you're going to take a look at the implementation @nridge, otherwise I am happy to do that as well.

The implementation looks good to me now. (I admit I don't have a high level of confidence in my understanding of the SourceLocation stuff in the implementation of addAngleBracketTokens(), but it sounds like you've looked at that).

I'll leave final approval to you @kadircet in case you have any remaining comments.

[kadircet]

clang-tools-extra/clangd/SemanticHighlighting.cpp

382

i am actually having a hard time following the logic here. it feels like what you really want is map > back to its file location, possibly to a >> token, and deal with second case specially.
so maybe something like:

// RLoc might be pointing at a virtual buffer when it's part of a `>>` token.
RLoc = SM.getFileLoc(RLoc);
// Make sure token is part of the main file.
RLoc = getHighlightableSpellingToken(RLoc);
if(!RLoc.isValid())
  return;

const auto *RTok = TB.spelledTokenAt(RLoc);
// Handle `>>`. RLoc is always pointing at the right location, just change
// the end to be offset by 1.
// We'll either point at the beginning of `>>`, hence get a proper spelled
// or point in the middle of `>>` hence get no spelled tok.
if (!RTok || RTok->kind() == tok::greatergreater) {
  Position Begin = sourceLocToPosition(SourceMgr, RLoc);
  Position End = sourceLocToPosition(SourceMgr, RLoc.getLocWithOffset(1));
  addToken(*LRange, HighlightingKind::Bracket);
  addToken({Begin, End}, HighlightingKind::Bracket);
  return;
}

// Easy case, we have the `>` token directly available.
if (RTok->kind() == tok::greater) {
  if (auto RRange = getRangeForSourceLocation(RLoc)) {
    addToken(*LRange, HighlightingKind::Bracket);
    addToken(*RRange, HighlightingKind::Bracket);
  }
  return;
}

This should also make sure you're handling line continuations properly.

[ckandeler]

Improved implementation as per review comment.

clang-tools-extra/clangd/SemanticHighlighting.cpp

382

Indeed, thanks.

[kadircet]

In D139926#4091990, @nridge wrote:

but it sounds like you've looked at that

well i did now :P

---

thanks a lot to you both, let's ship it!

clang-tools-extra/clangd/SemanticHighlighting.cpp

408

nit: i'd actually keep the return; here to make sure we don't fall into handling of other cases implicitly in the future.

[ckandeler]

Incorporated review comment.

clang-tools-extra/clangd/SemanticHighlighting.h

enum class HighlightingKind {
   Unknown,
   Namespace,
   TemplateParameter,
   Concept,
   Primitive,
   Macro,
   Modifier,
   Operator,
+  Bracket,
 
   // This one is different from the other kinds as it's a line style
   // rather than a token style.
   InactiveCode,
 
   LastKind = InactiveCode
 };
 

clang-tools-extra/clangd/SemanticHighlighting.cpp

public:
   HighlightingToken &addToken(SourceLocation Loc, HighlightingKind Kind) {
     auto Range = getRangeForSourceLocation(Loc);
     if (!Range)
       return InvalidHighlightingToken;
 
     return addToken(*Range, Kind);
   }
 
+  // Most of this function works around
+  // https://github.com/clangd/clangd/issues/871.
+  void addAngleBracketTokens(SourceLocation LLoc, SourceLocation RLoc) {
+    if (!LLoc.isValid() || !RLoc.isValid())
+      return;
+
+    auto LRange = getRangeForSourceLocation(LLoc);
+    if (!LRange)
+      return;
+
+    // RLoc might be pointing at a virtual buffer when it's part of a `>>`
+    // token.
+    RLoc = SourceMgr.getFileLoc(RLoc);
+    // Make sure token is part of the main file.
+    RLoc = getHighlightableSpellingToken(RLoc, SourceMgr);
+    if (!RLoc.isValid())
+      return;
+
+    const auto *RTok = TB.spelledTokenAt(RLoc);
+    // Handle `>>`. RLoc is always pointing at the right location, just change
+    // the end to be offset by 1.
+    // We'll either point at the beginning of `>>`, hence get a proper spelled
+    // or point in the middle of `>>` hence get no spelled tok.
+    if (!RTok || RTok->kind() == tok::greatergreater) {
+      Position Begin = sourceLocToPosition(SourceMgr, RLoc);
+      Position End = sourceLocToPosition(SourceMgr, RLoc.getLocWithOffset(1));
+      addToken(*LRange, HighlightingKind::Bracket);
+      addToken({Begin, End}, HighlightingKind::Bracket);
+      return;
+    }
+
+    // Easy case, we have the `>` token directly available.
+    if (RTok->kind() == tok::greater) {
+      if (auto RRange = getRangeForSourceLocation(RLoc)) {
+        addToken(*LRange, HighlightingKind::Bracket);
+        addToken(*RRange, HighlightingKind::Bracket);
+      }
+      return;
+    }
+  }
+
   HighlightingToken &addToken(Range R, HighlightingKind Kind) {
     HighlightingToken HT;
     HT.R = std::move(R);
     HT.Kind = Kind;
     Tokens.push_back(std::move(HT));
     return Tokens.back();
   }
 
public:
 
   bool TraverseConstructorInitializer(CXXCtorInitializer *Init) {
     if (Init->isMemberInitializer())
       if (auto *Member = Init->getMember())
         highlightMutableReferenceArgument(Member->getType(), Init->getInit());
     return Base::TraverseConstructorInitializer(Init);
   }
 
+  bool TraverseTypeConstraint(const TypeConstraint *C) {
+    if (auto *Args = C->getTemplateArgsAsWritten())
+      H.addAngleBracketTokens(Args->getLAngleLoc(), Args->getRAngleLoc());
+    return Base::TraverseTypeConstraint(C);
+  }
+
   bool VisitPredefinedExpr(PredefinedExpr *E) {
     H.addToken(E->getLocation(), HighlightingKind::LocalVariable)
         .addModifier(HighlightingModifier::Static)
         .addModifier(HighlightingModifier::Readonly)
         .addModifier(HighlightingModifier::FunctionScope);
     return true;
   }
 
+  bool VisitConceptSpecializationExpr(ConceptSpecializationExpr *E) {
+    if (auto *Args = E->getTemplateArgsAsWritten())
+      H.addAngleBracketTokens(Args->getLAngleLoc(), Args->getRAngleLoc());
+    return true;
+  }
+
+  bool VisitTemplateDecl(TemplateDecl *D) {
+    if (auto *TPL = D->getTemplateParameters())
+      H.addAngleBracketTokens(TPL->getLAngleLoc(), TPL->getRAngleLoc());
+    return true;
+  }
+
+  bool VisitTagDecl(TagDecl *D) {
+    for (unsigned i = 0; i < D->getNumTemplateParameterLists(); ++i) {
+      if (auto *TPL = D->getTemplateParameterList(i))
+        H.addAngleBracketTokens(TPL->getLAngleLoc(), TPL->getRAngleLoc());
+    }
+    return true;
+  }
+
+  bool VisitClassTemplatePartialSpecializationDecl(
+      ClassTemplatePartialSpecializationDecl *D) {
+    if (auto *TPL = D->getTemplateParameters())
+      H.addAngleBracketTokens(TPL->getLAngleLoc(), TPL->getRAngleLoc());
+    if (auto *Args = D->getTemplateArgsAsWritten())
+      H.addAngleBracketTokens(Args->getLAngleLoc(), Args->getRAngleLoc());
+    return true;
+  }
+
+  bool VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) {
+    if (auto *Args = D->getTemplateArgsInfo())
+      H.addAngleBracketTokens(Args->getLAngleLoc(), Args->getRAngleLoc());
+    return true;
+  }
+
+  bool VisitVarTemplatePartialSpecializationDecl(
+      VarTemplatePartialSpecializationDecl *D) {
+    if (auto *TPL = D->getTemplateParameters())
+      H.addAngleBracketTokens(TPL->getLAngleLoc(), TPL->getRAngleLoc());
+    if (auto *Args = D->getTemplateArgsAsWritten())
+      H.addAngleBracketTokens(Args->getLAngleLoc(), Args->getRAngleLoc());
+    return true;
+  }
+
+  bool VisitClassScopeFunctionSpecializationDecl(
+      ClassScopeFunctionSpecializationDecl *D) {
+    if (auto *Args = D->getTemplateArgsAsWritten())
+      H.addAngleBracketTokens(Args->getLAngleLoc(), Args->getRAngleLoc());
+    return true;
+  }
+
+  bool VisitDeclRefExpr(DeclRefExpr *E) {
+    H.addAngleBracketTokens(E->getLAngleLoc(), E->getRAngleLoc());
+    return true;
+  }
+  bool VisitMemberExpr(MemberExpr *E) {
+    H.addAngleBracketTokens(E->getLAngleLoc(), E->getRAngleLoc());
+    return true;
+  }
+
+  bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc L) {
+    H.addAngleBracketTokens(L.getLAngleLoc(), L.getRAngleLoc());
+    return true;
+  }
+
+  bool VisitAutoTypeLoc(AutoTypeLoc L) {
+    if (L.isConstrained())
+      H.addAngleBracketTokens(L.getLAngleLoc(), L.getRAngleLoc());
+    return true;
+  }
+
   bool VisitFunctionDecl(FunctionDecl *D) {
     if (D->isOverloadedOperator()) {
       const auto AddOpDeclToken = [&](SourceLocation Loc) {
         auto &Token = H.addToken(Loc, HighlightingKind::Operator)
                           .addModifier(HighlightingModifier::Declaration);
         if (D->isThisDeclarationADefinition())
           Token.addModifier(HighlightingModifier::Definition);
       };
       const auto Range = D->getNameInfo().getCXXOperatorNameRange();
       AddOpDeclToken(Range.getBegin());
       const auto Kind = D->getOverloadedOperator();
       if (Kind == OO_Call || Kind == OO_Subscript)
         AddOpDeclToken(Range.getEnd());
     }
+    if (auto *Args = D->getTemplateSpecializationArgsAsWritten())
+      H.addAngleBracketTokens(Args->getLAngleLoc(), Args->getRAngleLoc());
+    if (auto *I = D->getDependentSpecializationInfo())
+      H.addAngleBracketTokens(I->getLAngleLoc(), I->getRAngleLoc());
     return true;
   }
 
   bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
     const auto AddOpToken = [&](SourceLocation Loc) {
       H.addToken(Loc, HighlightingKind::Operator)
           .addModifier(HighlightingModifier::UserDefined);
     };
public:
 
   bool VisitCXXDeleteExpr(CXXDeleteExpr *E) {
     auto &Token = H.addToken(E->getBeginLoc(), HighlightingKind::Operator);
     if (isa_and_present<CXXMethodDecl>(E->getOperatorDelete()))
       Token.addModifier(HighlightingModifier::UserDefined);
     return true;
   }
 
+  bool VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
+    const auto &B = E->getAngleBrackets();
+    H.addAngleBracketTokens(B.getBegin(), B.getEnd());
+    return true;
+  }
+
   bool VisitCallExpr(CallExpr *E) {
     // Highlighting parameters passed by non-const reference does not really
     // make sense for literals...
     if (isa<UserDefinedLiteral>(E))
       return true;
 
     // FIXME: consider highlighting parameters of some other overloaded
     // operators as well
if (auto *D = CE->getMethodDecl()) {
                HighlightingKind::Operator)
               .addModifier(HighlightingModifier::UserDefined);
       }
     }
     return true;
   }
 
   bool VisitDeclaratorDecl(DeclaratorDecl *D) {
+    for (unsigned i = 0; i < D->getNumTemplateParameterLists(); ++i) {
+      if (auto *TPL = D->getTemplateParameterList(i))
+        H.addAngleBracketTokens(TPL->getLAngleLoc(), TPL->getRAngleLoc());
+    }
     auto *AT = D->getType()->getContainedAutoType();
     if (!AT)
       return true;
     auto K =
         kindForType(AT->getDeducedType().getTypePtrOrNull(), H.getResolver());
     if (!K)
       return true;
     SourceLocation StartLoc = D->getTypeSpecStartLoc();
bool VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *OPRE) {
     if (OPRE->isMessagingSetter()) {
       highlightObjCImplicitPropertyRef(OPRE->getImplicitPropertySetter(),
                                        OPRE->getLocation());
     }
     return true;
   }
 
   bool VisitOverloadExpr(OverloadExpr *E) {
+    H.addAngleBracketTokens(E->getLAngleLoc(), E->getRAngleLoc());
     if (!E->decls().empty())
       return true; // handled by findExplicitReferences.
     auto &Tok = H.addToken(E->getNameLoc(), HighlightingKind::Unknown)
                     .addModifier(HighlightingModifier::DependentName);
     if (llvm::isa<UnresolvedMemberExpr>(E))
       Tok.addModifier(HighlightingModifier::ClassScope);
     // other case is UnresolvedLookupExpr, scope is unknown.
     return true;
   }
 
   bool VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) {
     H.addToken(E->getMemberNameInfo().getLoc(), HighlightingKind::Unknown)
         .addModifier(HighlightingModifier::DependentName)
         .addModifier(HighlightingModifier::ClassScope);
+    H.addAngleBracketTokens(E->getLAngleLoc(), E->getRAngleLoc());
     return true;
   }
 
   bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
     H.addToken(E->getNameInfo().getLoc(), HighlightingKind::Unknown)
         .addModifier(HighlightingModifier::DependentName)
         .addModifier(HighlightingModifier::ClassScope);
+    H.addAngleBracketTokens(E->getLAngleLoc(), E->getRAngleLoc());
     return true;
   }
 
   bool VisitAttr(Attr *A) {
     switch (A->getKind()) {
     case attr::Override:
     case attr::Final:
       H.addToken(A->getLocation(), HighlightingKind::Modifier);
bool VisitDependentNameTypeLoc(DependentNameTypeLoc L) {
     return true;
   }
 
   bool VisitDependentTemplateSpecializationTypeLoc(
       DependentTemplateSpecializationTypeLoc L) {
     H.addToken(L.getTemplateNameLoc(), HighlightingKind::Type)
         .addModifier(HighlightingModifier::DependentName)
         .addModifier(HighlightingModifier::ClassScope);
+    H.addAngleBracketTokens(L.getLAngleLoc(), L.getRAngleLoc());
     return true;
   }
 
   bool TraverseTemplateArgumentLoc(TemplateArgumentLoc L) {
     // Handle template template arguments only (other arguments are handled by
     // their Expr, TypeLoc etc values).
     if (L.getArgument().getKind() != TemplateArgument::Template &&
         L.getArgument().getKind() != TemplateArgument::TemplateExpansion)
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingKind K) {
   case HighlightingKind::Primitive:
     return OS << "Primitive";
   case HighlightingKind::Macro:
     return OS << "Macro";
   case HighlightingKind::Modifier:
     return OS << "Modifier";
   case HighlightingKind::Operator:
     return OS << "Operator";
+  case HighlightingKind::Bracket:
+    return OS << "Bracket";
   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:
llvm::StringRef toSemanticTokenType(HighlightingKind Kind) {
   case HighlightingKind::Primitive:
     return "type";
   case HighlightingKind::Macro:
     return "macro";
   case HighlightingKind::Modifier:
     return "modifier";
   case HighlightingKind::Operator:
     return "operator";
+  case HighlightingKind::Bracket:
+    return "bracket";
   case HighlightingKind::InactiveCode:
     return "comment";
   }
   llvm_unreachable("unhandled HighlightingKind");
 }
 
 llvm::StringRef toSemanticTokenModifier(HighlightingModifier Modifier) {
   switch (Modifier) {

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

)cpp",
         auto $LocalVariable_def[[Bou]] = $Function[[Gah]];
       }
       struct $Class_def[[A]] {
         void $Method_decl[[abc]]();
       };
     )cpp",
       R"cpp(
       namespace $Namespace_decl[[abc]] {
-        template<typename $TemplateParameter_def[[T]]>
+        template$Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
         struct $Class_def[[A]] {
           $TemplateParameter[[T]] $Field_decl[[t]];
         };
       }
-      template<typename $TemplateParameter_def[[T]]>
-      struct $Class_def[[C]] : $Namespace[[abc]]::$Class[[A]]<$TemplateParameter[[T]]> {
+      template$Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
+      struct $Class_def[[C]] : $Namespace[[abc]]::$Class[[A]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]] {
         typename $TemplateParameter[[T]]::$Type_dependentName[[A]]* $Field_decl[[D]];
       };
-      $Namespace[[abc]]::$Class[[A]]<int> $Variable_def[[AA]];
-      typedef $Namespace[[abc]]::$Class[[A]]<int> $Class_decl[[AAA]];
+      $Namespace[[abc]]::$Class[[A]]$Bracket[[<]]int$Bracket[[>]] $Variable_def[[AA]];
+      typedef $Namespace[[abc]]::$Class[[A]]$Bracket[[<]]int$Bracket[[>]] $Class_decl[[AAA]];
       struct $Class_def[[B]] {
         $Class_decl_constrDestr[[B]]();
         ~$Class_decl_constrDestr[[B]]();
         void operator$Operator_decl[[<<]]($Class[[B]]);
         $Class[[AAA]] $Field_decl[[AA]];
       };
       $Class[[B]]::$Class_def_constrDestr[[B]]() {}
       $Class[[B]]::~$Class_def_constrDestr[[B]]() {}
)cpp",
       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_def[[T]], typename = void>
+      template$Bracket[[<]]typename $TemplateParameter_def[[T]], typename = void$Bracket[[>]]
       class $Class_def[[A]] {
         $TemplateParameter[[T]] $Field_decl[[AA]];
         $TemplateParameter[[T]] $Method_decl[[foo]]();
       };
-      template<class $TemplateParameter_def[[TT]]>
+      template$Bracket[[<]]class $TemplateParameter_def[[TT]]$Bracket[[>]]
       class $Class_def[[B]] {
-        $Class[[A]]<$TemplateParameter[[TT]]> $Field_decl[[AA]];
+        $Class[[A]]$Bracket[[<]]$TemplateParameter[[TT]]$Bracket[[>]] $Field_decl[[AA]];
       };
-      template<class $TemplateParameter_def[[TT]], class $TemplateParameter_def[[GG]]>
+      template$Bracket[[<]]class $TemplateParameter_def[[TT]], class $TemplateParameter_def[[GG]]$Bracket[[>]]
       class $Class_def[[BB]] {};
-      template<class $TemplateParameter_def[[T]]>
-      class $Class_def[[BB]]<$TemplateParameter[[T]], int> {};
-      template<class $TemplateParameter_def[[T]]>
-      class $Class_def[[BB]]<$TemplateParameter[[T]], $TemplateParameter[[T]]*> {};
+      template$Bracket[[<]]class $TemplateParameter_def[[T]]$Bracket[[>]]
+      class $Class_def[[BB]]$Bracket[[<]]$TemplateParameter[[T]], int$Bracket[[>]] {};
+      template$Bracket[[<]]class $TemplateParameter_def[[T]]$Bracket[[>]]
+      class $Class_def[[BB]]$Bracket[[<]]$TemplateParameter[[T]], $TemplateParameter[[T]]*$Bracket[[>]] {};
 
-      template<template<class> class $TemplateParameter_def[[T]], class $TemplateParameter_def[[C]]>
-      $TemplateParameter[[T]]<$TemplateParameter[[C]]> $Function_decl[[f]]();
+      template$Bracket[[<]]template$Bracket[[<]]class$Bracket[[>]] class $TemplateParameter_def[[T]], class $TemplateParameter_def[[C]]$Bracket[[>]]
+      $TemplateParameter[[T]]$Bracket[[<]]$TemplateParameter[[C]]$Bracket[[>]] $Function_decl[[f]]();
 
-      template<typename>
+      template$Bracket[[<]]typename$Bracket[[>]]
       class $Class_def[[Foo]] {};
 
-      template<typename $TemplateParameter_def[[T]]>
+      template$Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
       void $Function_decl[[foo]]($TemplateParameter[[T]] ...);
     )cpp",
       R"cpp(
-      template <class $TemplateParameter_def[[T]]>
+      template $Bracket[[<]]class $TemplateParameter_def[[T]]$Bracket[[>]]
       struct $Class_def[[Tmpl]] {$TemplateParameter[[T]] $Field_decl[[x]] = 0;};
-      extern template struct $Class_def[[Tmpl]]<float>;
-      template struct $Class_def[[Tmpl]]<double>;
+      extern template struct $Class_def[[Tmpl]]$Bracket[[<]]float$Bracket[[>]];
+      template struct $Class_def[[Tmpl]]$Bracket[[<]]double$Bracket[[>]];
     )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_def[[Foo]] {};
       struct $Class_def[[Bar]] {
         explicit operator $Class[[Foo]]*() const;
)cpp",
       $Class_deduced[[auto]] *$Variable_def[[AFP]] = $Operator[[&]]$Variable[[AF]];
       $Enum_deduced[[auto]] &$Variable_def[[AER]] = $Variable[[AE]];
       $Primitive_deduced_defaultLibrary[[auto]] $Variable_def[[Form]] = 10.2 $Operator[[+]] 2 $Operator[[*]] 4;
       $Primitive_deduced_defaultLibrary[[decltype]]($Variable[[Form]]) $Variable_def[[F]] = 10;
       auto $Variable_def[[Fun]] = []()->void{};
     )cpp",
       R"cpp(
       class $Class_def[[G]] {};
-      template<$Class[[G]] *$TemplateParameter_def_readonly[[U]]>
+      template$Bracket[[<]]$Class[[G]] *$TemplateParameter_def_readonly[[U]]$Bracket[[>]]
       class $Class_def[[GP]] {};
-      template<$Class[[G]] &$TemplateParameter_def_readonly[[U]]>
+      template$Bracket[[<]]$Class[[G]] &$TemplateParameter_def_readonly[[U]]$Bracket[[>]]
       class $Class_def[[GR]] {};
-      template<int *$TemplateParameter_def_readonly[[U]]>
+      template$Bracket[[<]]int *$TemplateParameter_def_readonly[[U]]$Bracket[[>]]
       class $Class_def[[IP]] {
         void $Method_def[[f]]() {
           $Operator[[*]]$TemplateParameter_readonly[[U]] $Operator[[+=]] 5;
         }
       };
-      template<unsigned $TemplateParameter_def_readonly[[U]] = 2>
+      template$Bracket[[<]]unsigned $TemplateParameter_def_readonly[[U]] = 2$Bracket[[>]]
       class $Class_def[[Foo]] {
         void $Method_def[[f]]() {
           for(int $LocalVariable_def[[I]] = 0;
             $LocalVariable[[I]] $Operator[[<]] $TemplateParameter_readonly[[U]];) {}
         }
       };
 
       $Class[[G]] $Variable_def[[L]];
       void $Function_def[[f]]() {
-        $Class[[Foo]]<123> $LocalVariable_def[[F]];
-        $Class[[GP]]<$Operator[[&]]$Variable[[L]]> $LocalVariable_def[[LL]];
-        $Class[[GR]]<$Variable[[L]]> $LocalVariable_def[[LLL]];
+        $Class[[Foo]]$Bracket[[<]]123$Bracket[[>]] $LocalVariable_def[[F]];
+        $Class[[GP]]$Bracket[[<]]$Operator[[&]]$Variable[[L]]$Bracket[[>]] $LocalVariable_def[[LL]];
+        $Class[[GR]]$Bracket[[<]]$Variable[[L]]$Bracket[[>]] $LocalVariable_def[[LLL]];
       }
     )cpp",
       R"cpp(
-      template<typename $TemplateParameter_def[[T]],
-        void ($TemplateParameter[[T]]::*$TemplateParameter_def_readonly[[method]])(int)>
+      template$Bracket[[<]]typename $TemplateParameter_def[[T]],
+        void ($TemplateParameter[[T]]::*$TemplateParameter_def_readonly[[method]])(int)$Bracket[[>]]
       struct $Class_def[[G]] {
         void $Method_def[[foo]](
             $TemplateParameter[[T]] *$Parameter_def[[O]]) {
           ($Parameter[[O]]$Operator_userDefined[[->*]]$TemplateParameter_readonly[[method]])(10);
 
         }
       };
       struct $Class_def[[F]] {
         void $Method_decl[[f]](int);
       };
-      template<void (*$TemplateParameter_def_readonly[[Func]])()>
+      template$Bracket[[<]]void (*$TemplateParameter_def_readonly[[Func]])()$Bracket[[>]]
       struct $Class_def[[A]] {
         void $Method_def[[f]]() {
           ($Operator[[*]]$TemplateParameter_readonly[[Func]])();
         }
       };
 
       void $Function_def[[foo]]() {
         $Class[[F]] $LocalVariable_def[[FF]];
-        $Class[[G]]<$Class[[F]], $Operator[[&]]$Class[[F]]::$Method[[f]]> $LocalVariable_def[[GG]];
+        $Class[[G]]$Bracket[[<]]$Class[[F]], $Operator[[&]]$Class[[F]]::$Method[[f]]$Bracket[[>]] $LocalVariable_def[[GG]];
         $LocalVariable[[GG]].$Method[[foo]]($Operator[[&]]$LocalVariable_usedAsMutablePointer[[FF]]);
-        $Class[[A]]<$Function[[foo]]> $LocalVariable_def[[AA]];
+        $Class[[A]]$Bracket[[<]]$Function[[foo]]$Bracket[[>]] $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.
)cpp",
         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]]$Operator[[++]];
       }
     )cpp",
       R"cpp(
-      template<class $TemplateParameter_def[[T]]>
+      template$Bracket[[<]]class $TemplateParameter_def[[T]]$Bracket[[>]]
       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_def[[T]]>
+      template $Bracket[[<]]class $TemplateParameter_def[[T]]$Bracket[[>]]
       void $Function_decl[[phase1]]($TemplateParameter[[T]]);
-      template <class $TemplateParameter_def[[T]]>
+      template $Bracket[[<]]class $TemplateParameter_def[[T]]$Bracket[[>]]
       void $Function_def[[foo]]($TemplateParameter[[T]] $Parameter_def[[P]]) {
         $Function[[phase1]]($Parameter[[P]]);
         $Unknown_dependentName[[phase2]]($Parameter[[P]]);
       }
     )cpp",
       R"cpp(
       class $Class_def[[A]] {
-        template <class $TemplateParameter_def[[T]]>
+        template $Bracket[[<]]class $TemplateParameter_def[[T]]$Bracket[[>]]
         void $Method_decl[[bar]]($TemplateParameter[[T]]);
       };
 
-      template <class $TemplateParameter_def[[U]]>
+      template $Bracket[[<]]class $TemplateParameter_def[[U]]$Bracket[[>]]
       void $Function_def[[foo]]($TemplateParameter[[U]] $Parameter_def[[P]]) {
         $Class[[A]]().$Method[[bar]]($Parameter[[P]]);
       }
     )cpp",
       R"cpp(
       struct $Class_def[[A]] {
-        template <class $TemplateParameter_def[[T]]>
+        template $Bracket[[<]]class $TemplateParameter_def[[T]]$Bracket[[>]]
         static void $StaticMethod_decl_static[[foo]]($TemplateParameter[[T]]);
       };
 
-      template <class $TemplateParameter_def[[T]]>
+      template $Bracket[[<]]class $TemplateParameter_def[[T]]$Bracket[[>]]
       struct $Class_def[[B]] {
         void $Method_def[[bar]]() {
           $Class[[A]]::$StaticMethod_static[[foo]]($TemplateParameter[[T]]());
         }
       };
     )cpp",
       R"cpp(
-      template <class $TemplateParameter_def[[T]]>
+      template $Bracket[[<]]class $TemplateParameter_def[[T]]$Bracket[[>]]
       void $Function_decl[[foo]](typename $TemplateParameter[[T]]::$Type_dependentName[[Type]]
                                             = $TemplateParameter[[T]]::$Unknown_dependentName[[val]]);
     )cpp",
       R"cpp(
-      template <class $TemplateParameter_def[[T]]>
+      template $Bracket[[<]]class $TemplateParameter_def[[T]]$Bracket[[>]]
       void $Function_def[[foo]]($TemplateParameter[[T]] $Parameter_def[[P]]) {
         $Parameter[[P]].$Unknown_dependentName[[Field]];
       }
     )cpp",
       R"cpp(
-      template <class $TemplateParameter_def[[T]]>
+      template $Bracket[[<]]class $TemplateParameter_def[[T]]$Bracket[[>]]
       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_def[[TT]],
-                template <class> class ...$TemplateParameter_def[[TTs]]>
+      template $Bracket[[<]]template $Bracket[[<]]class$Bracket[[>]] class $TemplateParameter_def[[TT]],
+                template $Bracket[[<]]class$Bracket[[>]] class ...$TemplateParameter_def[[TTs]]$Bracket[[>]]
       struct $Class_def[[Foo]] {
-        $Class[[Foo]]<$TemplateParameter[[TT]], $TemplateParameter[[TTs]]...>
+        $Class[[Foo]]$Bracket[[<]]$TemplateParameter[[TT]], $TemplateParameter[[TTs]]...$Bracket[[>]]
           *$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[[#ifdef test]]
 $InactiveCode[[int Inactive4;]]
 $InactiveCode[[#else]]
       int $Variable_def[[Active3]];
       #endif
     )cpp",
       // Argument to 'sizeof...'
       R"cpp(
-      template <typename... $TemplateParameter_def[[Elements]]>
+      template $Bracket[[<]]typename... $TemplateParameter_def[[Elements]]$Bracket[[>]]
       struct $Class_def[[TupleSize]] {
         static const int $StaticField_decl_readonly_static[[size]] =
 sizeof...($TemplateParameter[[Elements]]);
       };
     )cpp",
       // More dependent types
       R"cpp(
-      template <typename $TemplateParameter_def[[T]]>
+      template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
       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]]>
+            ::template $Type_dependentName[[Resolver]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]]
             ::$Type_dependentName[[Location]];
         using $Typedef_decl[[Location3]] = typename $TemplateParameter[[T]]
             ::$Type_dependentName[[Resolver]]
-            ::template $Type_dependentName[[Location]]<$TemplateParameter[[T]]>;
+            ::template $Type_dependentName[[Location]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]];
         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>
+      template $Bracket[[<]]typename$Bracket[[>]]
       struct $Class_def[[Foo]] {
         int $Field_decl[[Waldo]];
         void $Method_def[[bar]]() {
           $Class[[Foo]]().$Field_dependentName[[Waldo]];
         }
-        template <typename $TemplateParameter_def[[U]]>
+        template $Bracket[[<]]typename $TemplateParameter_def[[U]]$Bracket[[>]]
         void $Method_def[[bar1]]() {
-          $Class[[Foo]]<$TemplateParameter[[U]]>().$Field_dependentName[[Waldo]];
+          $Class[[Foo]]$Bracket[[<]]$TemplateParameter[[U]]$Bracket[[>]]().$Field_dependentName[[Waldo]];
         }
 
         void $Method_decl[[Overload]]();
         void $Method_decl_readonly[[Overload]]() const;
       };
-      template <typename $TemplateParameter_def[[T]]>
-      void $Function_def[[baz]]($Class[[Foo]]<$TemplateParameter[[T]]> $Parameter_def[[o]]) {
+      template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
+      void $Function_def[[baz]]($Class[[Foo]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]] $Parameter_def[[o]]) {
         $Parameter[[o]].$Method_readonly_dependentName[[Overload]]();
       }
     )cpp",
       // Concepts
       R"cpp(
-      template <typename $TemplateParameter_def[[T]]>
+      template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
       concept $Concept_decl[[Fooable]] =
           requires($TemplateParameter[[T]] $Parameter_def[[F]]) {
             $Parameter[[F]].$Unknown_dependentName[[foo]]();
           };
-      template <typename $TemplateParameter_def[[T]]>
-          requires $Concept[[Fooable]]<$TemplateParameter[[T]]>
+      template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
+          requires $Concept[[Fooable]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]]
       void $Function_def[[bar]]($TemplateParameter[[T]] $Parameter_def[[F]]) {
         $Parameter[[F]].$Unknown_dependentName[[foo]]();
       }
     )cpp",
       // Dependent template name
       R"cpp(
-      template <template <typename> class> struct $Class_def[[A]] {};
-      template <typename $TemplateParameter_def[[T]]>
-      using $Typedef_decl[[W]] = $Class[[A]]<
+      template $Bracket[[<]]template $Bracket[[<]]typename$Bracket[[>]] class$Bracket[[>]] struct $Class_def[[A]] {};
+      template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
+      using $Typedef_decl[[W]] = $Class[[A]]$Bracket[[<]]
         $TemplateParameter[[T]]::template $Class_dependentName[[Waldo]]
-      >;
+      $Bracket[[>]];
     )cpp",
       R"cpp(
       class $Class_def_abstract[[Abstract]] {
       public:
         virtual void $Method_decl_abstract_virtual[[pure]]() = 0;
         virtual void $Method_decl_virtual[[impl]]();
       };
       void $Function_def[[foo]]($Class_abstract[[Abstract]]* $Parameter_def[[A]]) {
)cpp",
           $Class[[Foo]].$Field_static[[sharedInstance]].$Field[[someProperty]] $Operator[[=]] 1;
           self.$Field[[someProperty]] $Operator[[=]] self.$Field[[someProperty]] $Operator[[+]] self.$Field[[otherMethod]] $Operator[[+]] 1;
           self->$Field[[_someProperty]] $Operator[[=]] $Field[[_someProperty]] $Operator[[+]] 1;
         }
         @end
       )cpp",
       // Member imported from dependent base
       R"cpp(
-        template <typename> struct $Class_def[[Base]] {
+        template $Bracket[[<]]typename$Bracket[[>]] struct $Class_def[[Base]] {
           int $Field_decl[[member]];
         };
-        template <typename $TemplateParameter_def[[T]]>
-        struct $Class_def[[Derived]] : $Class[[Base]]<$TemplateParameter[[T]]> {
-          using $Class[[Base]]<$TemplateParameter[[T]]>::$Field_dependentName[[member]];
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
+        struct $Class_def[[Derived]] : $Class[[Base]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]] {
+          using $Class[[Base]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]]::$Field_dependentName[[member]];
 
           void $Method_def[[method]]() {
             (void)$Field_dependentName[[member]];
           }
         };
       )cpp",
       // Modifier for variables passed as non-const references
       R"cpp(
)cpp",
             $Class[[S]] $LocalVariable_def[[s2]]($LocalVariable[[s1]].$Field_usedAsMutableReference[[field]]);
 
             $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_def[[X]]>
+        template $Bracket[[<]]typename $TemplateParameter_def[[X]]$Bracket[[>]]
         void $Function_def[[foo]]($TemplateParameter[[X]]& $Parameter_def[[x]]) {
           // We do not support dependent types, so this one should *not* get the modifier.
           $Function[[foo]]($Parameter[[x]]);
         }
       )cpp",
       // init-captures
       R"cpp(
         void $Function_def[[foo]]() {
)cpp",
       }
       )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_def[[x]]);
         void $Function_decl[[Foo]](int $Parameter_def[[x]]);
-        template <typename $TemplateParameter_def[[T]]>
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
         void $Function_def[[Bar]]($TemplateParameter[[T]] $Parameter_def[[x]]) {
             $Function_deprecated[[Foo]]($Parameter[[x]]);
             $Function_deprecated[[Foo]]($Parameter[[x]]);
             $Function_deprecated[[Foo]]($Parameter[[x]]);
         }
       )cpp",
       // Predefined identifiers
       R"cpp(
         void $Function_def[[Foo]]() {
             const char *$LocalVariable_def_readonly[[s]] = $LocalVariable_readonly_static[[__func__]];
         }
       )cpp",
       // override and final
       R"cpp(
         class $Class_def_abstract[[Base]] { virtual void $Method_decl_abstract_virtual[[m]]() = 0; };
         class $Class_def[[override]] : public $Class_abstract[[Base]] { void $Method_decl_virtual[[m]]() $Modifier[[override]]; };
         class $Class_def[[final]] : public $Class[[override]] { void $Method_decl_virtual[[m]]() $Modifier[[override]] $Modifier[[final]]; };
       )cpp",
       // Issue 1222: readonly modifier for generic parameter
       R"cpp(
-        template <typename $TemplateParameter_def[[T]]>
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
         auto $Function_def[[foo]](const $TemplateParameter[[T]] $Parameter_def_readonly[[template_type]], 
                                   const $TemplateParameter[[auto]] $Parameter_def_readonly[[auto_type]], 
                                   const int $Parameter_def_readonly[[explicit_type]]) {
             return $Parameter_readonly[[template_type]] 
                  $Operator_userDefined[[+]] $Parameter_readonly[[auto_type]]
                  $Operator_userDefined[[+]] $Parameter_readonly[[explicit_type]];
         }
       )cpp",
       // Explicit template specialization
       R"cpp(
         struct $Class_def[[Base]]{};
-        template <typename $TemplateParameter_def[[T]]>
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
         struct $Class_def[[S]] : public $Class[[Base]] {};
-        template <>
-        struct $Class_def[[S]]<void> : public $Class[[Base]] {};
+        template $Bracket[[<]]$Bracket[[>]]
+        struct $Class_def[[S]]$Bracket[[<]]void$Bracket[[>]] : public $Class[[Base]] {};
 
-        template <typename $TemplateParameter_def[[T]]>
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
         $TemplateParameter[[T]] $Variable_def[[x]] = {};
         template <>
-        int $Variable_def[[x]]<int> = (int)sizeof($Class[[Base]]);
+        int $Variable_def[[x]]$Bracket[[<]]int$Bracket[[>]] = (int)sizeof($Class[[Base]]);
       )cpp",
       // operator calls in template
       R"cpp(
-        template<typename $TemplateParameter_def[[T]]> class $Class_def[[C]] {
+        template$Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]] class $Class_def[[C]] {
             bool $Method_def[[compare]]($TemplateParameter[[T]] $Parameter_def[[t1]], $TemplateParameter[[T]] $Parameter_def[[t2]]) { return $Parameter[[t1]] $Operator_userDefined[[==]] $Parameter[[t2]]; }
             $TemplateParameter[[T]] $Method_def[[deref]]($TemplateParameter[[T]] *$Parameter_def[[t]]) { return $Operator_userDefined[[*]]$Parameter[[t]]; }
         };
       )cpp",
       // new and delete
       R"cpp(
         struct $Class_def[[S]] { int *$Field_decl[[a]]; };
         void $Function_def[[f]]() {
           $Class[[S]] *$LocalVariable_def[[s]] = $Operator[[new]] $Class[[S]];
           $LocalVariable[[s]]->$Field[[a]] $Operator[[=]] $Operator[[new]] int[10];
           $Operator[[delete]][] $LocalVariable[[s]]->$Field[[a]];
           $Operator[[delete]] $LocalVariable[[s]];
         }
       )cpp",
       // explicit operator invocation
       R"cpp(
         struct $Class_def[[S]] {
             $Class[[S]] operator$Operator_decl[[+]](const $Class[[S]] &$Parameter_def_readonly[[other]]);
         };
         void $Function_def[[f]]() {
             $Class[[S]] $LocalVariable_def[[s]];
             $Class[[S]] $LocalVariable_def[[s2]] = $LocalVariable[[s]].operator$Operator_userDefined[[+]]($LocalVariable[[s]]);
         }
       )cpp",
+      R"cpp(
+        // Brackets support: C++ casts
+        void $Function_def[[f]]() {
+          struct $Class_def[[B]] { virtual ~$Class_decl_constrDestr[[B]](); };
+          struct $Class_def[[D]] : public $Class[[B]] {};
+          $Class[[B]] $LocalVariable_def[[b]];
+          int $LocalVariable_def[[i]] = static_cast$Bracket[[<]]int$Bracket[[>]](3.5);
+          void *$LocalVariable_def[[p]] = reinterpret_cast$Bracket[[<]]void *$Bracket[[>]](0);
+          $Class[[D]] &$LocalVariable_def[[d]] = dynamic_cast$Bracket[[<]]$Class[[D]] &$Bracket[[>]]($LocalVariable[[b]]);
+        }
+      )cpp",
+      // Brackets support: Nested template instantiations.
+      R"cpp(
+        template$Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]] struct $Class_def[[S]] {};
+        void $Function_def[[f]]() {
+            $Class[[S]]$Bracket[[<]]$Class[[S]]$Bracket[[<]]int$Bracket[[>]]$Bracket[[>]] $LocalVariable_def[[s1]];
+            $Class[[S]]$Bracket[[<]]$Class[[S]]$Bracket[[<]]int$Bracket[[>]]\
+$Bracket[[>]] $LocalVariable_def[[s2]];
+            $Class[[S]]$Bracket[[<]]$Class[[S]]$Bracket[[<]]$Class[[S]]$Bracket[[<]]int$Bracket[[>]]$Bracket[[>]]$Bracket[[>]] $LocalVariable_def[[s3]];
+            $Class[[S]]$Bracket[[<]]$Class[[S]]$Bracket[[<]]$Class[[S]]$Bracket[[<]]int$Bracket[[>]]\
+$Bracket[[>]]$Bracket[[>]] $LocalVariable_def[[s4]];
+            $Class[[S]]$Bracket[[<]]$Class[[S]]$Bracket[[<]]$Class[[S]]$Bracket[[<]]int$Bracket[[>]]\
+  $Bracket[[>]]$Bracket[[>]] $LocalVariable_def[[s5]];
+            $Class[[S]]$Bracket[[<]]$Class[[S]]$Bracket[[<]]$Class[[S]]$Bracket[[<]]int$Bracket[[>]]\
+$Bracket[[>]]$Bracket[[>]] $LocalVariable_def[[s6]];
+            $Class[[S]]$Bracket[[<]]$Class[[S]]$Bracket[[<]]$Class[[S]]$Bracket[[<]]int$Bracket[[>]]$Bracket[[>]]\
+  $Bracket[[>]] $LocalVariable_def[[s7]];
+      }
+      )cpp",
+      // Brackets support: One of the brackets is a macro.
+      R"cpp(
+        #define $Macro_decl[[LESS]] <
+        template $Macro[[LESS]] typename $TemplateParameter_def[[T]] > class $Class_def[[A]] {};
+      )cpp",
+      // Brackets support: Specializations
+      R"cpp(
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]] class $Class_def[[S]] {
+        public:
+          template $Bracket[[<]]typename $TemplateParameter_def[[U]]$Bracket[[>]] class $Class_decl[[Nested]];
+        };
+        template $Bracket[[<]]$Bracket[[>]] class $Class_def[[S]]$Bracket[[<]]int$Bracket[[>]] {};
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
+        class $Class_def[[S]]$Bracket[[<]]$TemplateParameter[[T]]*$Bracket[[>]] {};
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
+        template $Bracket[[<]]typename $TemplateParameter_def[[U]]$Bracket[[>]]
+        class $Class[[S]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]]::$Class_def[[Nested]] {};
+        template $Bracket[[<]]$Bracket[[>]]
+        template $Bracket[[<]]$Bracket[[>]]
+        class $Class[[S]]$Bracket[[<]]float$Bracket[[>]]::$Class_def[[Nested]]$Bracket[[<]]float$Bracket[[>]] {};
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]] void $Function_decl[[foo]]();
+        void $Function_def[[bar]]() {
+          $Function[[foo]]$Bracket[[<]]int$Bracket[[>]]();
+        }
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]] constexpr int $Variable_def_readonly[[V]] = 42;
+        constexpr int $Variable_def_readonly[[Y]] = $Variable_readonly[[V]]$Bracket[[<]]char$Bracket[[>]];
+        template <>
+        constexpr int $Variable_def_readonly[[V]]$Bracket[[<]]int$Bracket[[>]] = 5;
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
+        constexpr int $Variable_def_readonly[[V]]$Bracket[[<]]$TemplateParameter[[T]]*$Bracket[[>]] = 6;
+        template $Bracket[[<]]typename$Bracket[[>]]
+        class $Class_def[[A]] {
+          enum class $Enum_decl[[E]];
+        };
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
+        enum class $Class[[A]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]]::$Enum_decl[[E]] {$EnumConstant_decl_readonly[[X]], $EnumConstant_decl_readonly[[Y]], $EnumConstant_decl_readonly[[Z]]};
+        template $Bracket[[<]]class $TemplateParameter_def[[T]]$Bracket[[>]]
+        class $Class_def[[B]] {
+          template $Bracket[[<]]class $TemplateParameter_def[[U]]$Bracket[[>]] void $Method_def[[foo]]($TemplateParameter[[U]]) { }
+          template$Bracket[[<]]$Bracket[[>]] void $Method_def[[foo]]$Bracket[[<]]int$Bracket[[>]](int) { } 
+          friend void $Function_decl[[foo]]$Bracket[[<]]$Bracket[[>]]($TemplateParameter[[T]]);
+        };
+      )cpp",
+      // Brackets support: Function calls
+      R"cpp(
+        template $Bracket[[<]]typename$Bracket[[>]] void $Function_decl[[free]]();
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
+          struct $Class_def[[A]] {
+            template $Bracket[[<]]typename$Bracket[[>]] void $Method_decl[[mem]]();
+        };
+        void $Function_def[[foo]]() {
+          $Class[[A]]$Bracket[[<]]int$Bracket[[>]] $LocalVariable_def[[a]];
+          $LocalVariable[[a]].$Method[[mem]]$Bracket[[<]]int$Bracket[[>]]();
+        }
+        template$Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
+        void $Function_def[[bar]]() {
+          $Function[[free]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]]();
+          $Class[[A]]$Bracket[[<]]int$Bracket[[>]] $LocalVariable_def[[a]];
+          $LocalVariable[[a]].$Method[[mem]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]]();
+          $Class[[A]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]] $LocalVariable_def[[b]];
+          $LocalVariable[[b]].template $Method_dependentName[[mem]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]]();
+        }
+      )cpp",
+      // Brackets support: Concepts
+      R"cpp(
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
+        concept $Concept_decl[[C]] = true;
+        template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]] requires $Concept[[C]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]]
+        class $Class_def[[Z]] {};
+        template $Bracket[[<]]typename, typename$Bracket[[>]]
+        concept $Concept_decl[[C2]] = true;
+        template $Bracket[[<]]C2$Bracket[[<]]int$Bracket[[>]] $TemplateParameter_def[[A]]$Bracket[[>]]
+        class $Class_def[[B]] {};
+      )cpp",
       // no crash
       R"cpp(
         struct $Class_def[[Foo]] {
           void $Method_decl[[foo]]();
         };
 
         void $Function_def[[s]]($Class[[Foo]] $Parameter_def[[f]]) {
           auto $LocalVariable_def[[k]] = $Operator[[&]]$Class[[Foo]]::$Method[[foo]];
           ($Parameter[[f]]$Operator[[.*]]$LocalVariable[[k]])(); // no crash on VisitCXXMemberCallExpr
         }
       )cpp",
       R"cpp(
-        template<typename>
+        template$Bracket[[<]]typename$Bracket[[>]]
         class $Class_def[[Foo]] {};
 
-        template<typename $TemplateParameter_def[[T]]>
+        template$Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
         void $Function_def[[k]]() {
-          auto $LocalVariable_def[[s]] = $Operator[[new]] $Class[[Foo]]<$TemplateParameter[[T]]>();
+          auto $LocalVariable_def[[s]] = $Operator[[new]] $Class[[Foo]]$Bracket[[<]]$TemplateParameter[[T]]$Bracket[[>]]();
           $Operator[[delete]] $LocalVariable[[s]];
         }
       )cpp"};
   for (const auto &TestCase : TestCases)
     // Mask off scope modifiers to keep the tests manageable.
     // They're tested separately.
     checkHighlightings(TestCase, {}, ~ScopeModifierMask);
 
const char *TestCases[] = {
         // Classes in functions are classes.
         void $Function_globalScope[[foo]]() {
           class $Class_functionScope[[X]] {
             int $Field_classScope[[x]];
           };
         };
       )cpp",
       R"cpp(
-        template <int $TemplateParameter_classScope[[T]]>
+        template $Bracket[[<]]int $TemplateParameter_classScope[[T]]$Bracket[[>]]
         class $Class_globalScope[[X]] {
         };
       )cpp",
       R"cpp(
         // No useful scope for template parameters of variable templates.
-        template <typename $TemplateParameter[[A]]>
+        template $Bracket[[<]]typename $TemplateParameter[[A]]$Bracket[[>]]
         unsigned $Variable_globalScope[[X]] =
           $TemplateParameter[[A]]::$Unknown_classScope[[x]];
       )cpp",
       R"cpp(
         #define $Macro_globalScope[[X]] 1
         int $Variable_globalScope[[Y]] = $Macro_globalScope[[X]];
       )cpp",
   };