[clangd] Add semantic token for angle brackets

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.

Reviewed By: kadircet

Differential Revision: https://reviews.llvm.org/D139926

clang-tools-extra/clangd/SemanticHighlighting.cpp

@@ -369,6 +369,47 @@ public:
     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);
@@ -559,6 +600,12 @@ public:
     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)
@@ -567,6 +614,77 @@ public:
     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) {
@@ -581,6 +699,10 @@ public:
       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;
   }
 
@@ -632,6 +754,12 @@ public:
     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...
@@ -757,6 +885,10 @@ public:
   }
 
   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;
@@ -858,6 +990,7 @@ public:
   }
 
   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)
@@ -872,6 +1005,7 @@ public:
     H.addToken(E->getMemberNameInfo().getLoc(), HighlightingKind::Unknown)
         .addModifier(HighlightingModifier::DependentName)
         .addModifier(HighlightingModifier::ClassScope);
+    H.addAngleBracketTokens(E->getLAngleLoc(), E->getRAngleLoc());
     return true;
   }
 
@@ -879,6 +1013,7 @@ public:
     H.addToken(E->getNameInfo().getLoc(), HighlightingKind::Unknown)
         .addModifier(HighlightingModifier::DependentName)
         .addModifier(HighlightingModifier::ClassScope);
+    H.addAngleBracketTokens(E->getLAngleLoc(), E->getRAngleLoc());
     return true;
   }
 
@@ -906,6 +1041,7 @@ public:
     H.addToken(L.getTemplateNameLoc(), HighlightingKind::Type)
         .addModifier(HighlightingModifier::DependentName)
         .addModifier(HighlightingModifier::ClassScope);
+    H.addAngleBracketTokens(L.getLAngleLoc(), L.getRAngleLoc());
     return true;
   }
 
@@ -1074,6 +1210,8 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingKind K) {
     return OS << "Modifier";
   case HighlightingKind::Operator:
     return OS << "Operator";
+  case HighlightingKind::Bracket:
+    return OS << "Bracket";
   case HighlightingKind::InactiveCode:
     return OS << "InactiveCode";
   }
@@ -1212,6 +1350,8 @@ llvm::StringRef toSemanticTokenType(HighlightingKind Kind) {
     return "modifier";
   case HighlightingKind::Operator:
     return "operator";
+  case HighlightingKind::Bracket:
+    return "bracket";
   case HighlightingKind::InactiveCode:
     return "comment";
   }

clang-tools-extra/clangd/SemanticHighlighting.h

@@ -51,6 +51,7 @@ enum class HighlightingKind {
   Macro,
   Modifier,
   Operator,
+  Bracket,
 
   // This one is different from the other kinds as it's a line style
   // rather than a token style.

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

@@ -130,17 +130,17 @@ TEST(SemanticHighlighting, GetsCorrectTokens) {
     )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]]();
@@ -243,36 +243,36 @@ TEST(SemanticHighlighting, GetsCorrectTokens) {
       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
@@ -335,17 +335,17 @@ TEST(SemanticHighlighting, GetsCorrectTokens) {
     )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;
@@ -355,14 +355,14 @@ TEST(SemanticHighlighting, GetsCorrectTokens) {
 
       $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]]) {
@@ -373,7 +373,7 @@ TEST(SemanticHighlighting, GetsCorrectTokens) {
       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]])();
@@ -382,9 +382,9 @@ TEST(SemanticHighlighting, GetsCorrectTokens) {
 
       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
@@ -472,7 +472,7 @@ $InactiveCode[[#endif]]
       }
     )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]];
@@ -491,9 +491,9 @@ $InactiveCode[[#endif]]
       };
     )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]]);
@@ -501,22 +501,22 @@ $InactiveCode[[#endif]]
     )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]]());
@@ -524,18 +524,18 @@ $InactiveCode[[#endif]]
       };
     )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]];
@@ -549,10 +549,10 @@ $InactiveCode[[#endif]]
     )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",
@@ -590,7 +590,7 @@ $InactiveCode[[#else]]
     )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]]);
@@ -598,61 +598,61 @@ 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]] {
@@ -733,12 +733,12 @@ sizeof...($TemplateParameter[[Elements]]);
       )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]];
@@ -814,7 +814,7 @@ sizeof...($TemplateParameter[[Elements]]);
           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]]);
@@ -852,7 +852,7 @@ sizeof...($TemplateParameter[[Elements]]);
         // 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]]);
@@ -873,7 +873,7 @@ sizeof...($TemplateParameter[[Elements]]);
       )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]]) {
@@ -885,19 +885,19 @@ sizeof...($TemplateParameter[[Elements]]);
       // 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]]; }
         };
@@ -922,6 +922,109 @@ sizeof...($TemplateParameter[[Elements]]);
             $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]] {
@@ -934,12 +1037,12 @@ sizeof...($TemplateParameter[[Elements]]);
         }
       )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"};
@@ -1023,13 +1126,13 @@ TEST(SemanticHighlighting, ScopeModifiers) {
         };
       )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",