diff --git a/clang-tools-extra/clangd/SemanticHighlighting.h b/clang-tools-extra/clangd/SemanticHighlighting.h
--- a/clang-tools-extra/clangd/SemanticHighlighting.h
+++ b/clang-tools-extra/clangd/SemanticHighlighting.h
@@ -51,6 +51,8 @@
   Macro,
   Modifier,
   Operator,
+  AngleBracketOpen,
+  AngleBracketClose,
 
   // This one is different from the other kinds as it's a line style
   // rather than a token style.
diff --git a/clang-tools-extra/clangd/SemanticHighlighting.cpp b/clang-tools-extra/clangd/SemanticHighlighting.cpp
--- a/clang-tools-extra/clangd/SemanticHighlighting.cpp
+++ b/clang-tools-extra/clangd/SemanticHighlighting.cpp
@@ -368,6 +368,63 @@
     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;
+
+    // For the inner element of a nested template instantiation with no space
+    // between the '>' characters, TemplateSpecializationLocInfo::RAngleLoc has
+    // the MacroIDBit set, and the "expansion location" refers to the actual
+    // location in the code.
+    if (!RLoc.isFileID())
+      RLoc = SourceMgr.getExpansionLoc(RLoc);
+    if (!RLoc.isFileID())
+      return;
+
+    const auto *RTok = TB.spelledTokenAt(RLoc);
+
+    // The normal, non-nested case.
+    if (RTok && RTok->kind() != tok::greatergreater) {
+      auto RRange = halfOpenToRange(
+          SourceMgr, RTok->range(SourceMgr).toCharRange(SourceMgr));
+      addToken(*LRange, HighlightingKind::AngleBracketOpen);
+      addToken(RRange, HighlightingKind::AngleBracketClose);
+      return;
+    }
+
+    // This handles the inner element of a nested template instantiation.
+    // Our angle bracket is the first character of a mis-lexed ">>" construct,
+    // so we need to adjust the length of the clang token.
+    if (RTok) {
+      CharSourceRange TokRange = RTok->range(SourceMgr).toCharRange(SourceMgr);
+      Position Begin = sourceLocToPosition(SourceMgr, TokRange.getBegin());
+      Position End = Begin;
+      ++End.character;
+      addToken(*LRange, HighlightingKind::AngleBracketOpen);
+      addToken({Begin, End}, HighlightingKind::AngleBracketClose);
+      return;
+    }
+
+    // This handles the outer element of a nested template instantiation.
+    // Our angle bracket is the second character of a mis-lexed ">>" construct,
+    // so the clang token starts one character to the left of it.
+    RTok = TB.spelledTokenAt(RLoc.getLocWithOffset(-1));
+    if (!RTok || RTok->kind() != tok::greatergreater)
+      return;
+    CharSourceRange TokRange = RTok->range(SourceMgr).toCharRange(SourceMgr);
+    Position End = sourceLocToPosition(SourceMgr, TokRange.getEnd());
+    Position Begin = End;
+    --Begin.character;
+    addToken(*LRange, HighlightingKind::AngleBracketOpen);
+    addToken({Begin, End}, HighlightingKind::AngleBracketClose);
+  }
+
   HighlightingToken &addToken(Range R, HighlightingKind Kind) {
     HighlightingToken HT;
     HT.R = std::move(R);
@@ -566,6 +623,17 @@
     return true;
   }
 
+  bool VisitTemplateDecl(TemplateDecl *D) {
+    if (auto *TPL = D->getTemplateParameters())
+      H.addAngleBracketTokens(TPL->getLAngleLoc(), TPL->getRAngleLoc());
+    return true;
+  }
+
+  bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc L) {
+    H.addAngleBracketTokens(L.getLAngleLoc(), L.getRAngleLoc());
+    return true;
+  }
+
   bool VisitFunctionDecl(FunctionDecl *D) {
     if (D->isOverloadedOperator()) {
       const auto addOpDeclToken = [&](SourceLocation Loc) {
@@ -580,6 +648,8 @@
       if (Kind == OO_Call || Kind == OO_Subscript)
         addOpDeclToken(Range.getEnd());
     }
+    if (auto *Args = D->getTemplateSpecializationArgsAsWritten())
+      H.addAngleBracketTokens(Args->getLAngleLoc(), Args->getRAngleLoc());
     return true;
   }
 
@@ -631,6 +701,12 @@
     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...
@@ -1073,6 +1149,10 @@
     return OS << "Modifier";
   case HighlightingKind::Operator:
     return OS << "Operator";
+  case HighlightingKind::AngleBracketOpen:
+    return OS << "AngleBracketOpen";
+  case HighlightingKind::AngleBracketClose:
+    return OS << "AngleBracketClose";
   case HighlightingKind::InactiveCode:
     return OS << "InactiveCode";
   }
@@ -1211,6 +1291,10 @@
     return "modifier";
   case HighlightingKind::Operator:
     return "operator";
+  case HighlightingKind::AngleBracketOpen:
+    return "angleBracketOpen";
+  case HighlightingKind::AngleBracketClose:
+    return "angleBracketClose";
   case HighlightingKind::InactiveCode:
     return "comment";
   }
diff --git a/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp b/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
--- a/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
+++ b/clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
@@ -130,17 +130,17 @@
     )cpp",
       R"cpp(
       namespace $Namespace_decl[[abc]] {
-        template<typename $TemplateParameter_def[[T]]>
+        template$AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
         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$AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
+      struct $Class_def[[C]] : $Namespace[[abc]]::$Class[[A]]$AngleBracketOpen[[<]]$TemplateParameter[[T]]$AngleBracketClose[[>]] {
         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]]$AngleBracketOpen[[<]]int$AngleBracketClose[[>]] $Variable_def[[AA]];
+      typedef $Namespace[[abc]]::$Class[[A]]$AngleBracketOpen[[<]]int$AngleBracketClose[[>]] $Class_decl[[AAA]];
       struct $Class_def[[B]] {
         $Class_decl_constrDestr[[B]]();
         ~$Class_decl_constrDestr[[B]]();
@@ -243,36 +243,36 @@
       typedef float $Primitive_decl[[F]];
     )cpp",
       R"cpp(
-      template<typename $TemplateParameter_def[[T]], typename = void>
+      template$AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]], typename = void$AngleBracketClose[[>]]
       class $Class_def[[A]] {
         $TemplateParameter[[T]] $Field_decl[[AA]];
         $TemplateParameter[[T]] $Method_decl[[foo]]();
       };
-      template<class $TemplateParameter_def[[TT]]>
+      template$AngleBracketOpen[[<]]class $TemplateParameter_def[[TT]]$AngleBracketClose[[>]]
       class $Class_def[[B]] {
-        $Class[[A]]<$TemplateParameter[[TT]]> $Field_decl[[AA]];
+        $Class[[A]]$AngleBracketOpen[[<]]$TemplateParameter[[TT]]$AngleBracketClose[[>]] $Field_decl[[AA]];
       };
-      template<class $TemplateParameter_def[[TT]], class $TemplateParameter_def[[GG]]>
+      template$AngleBracketOpen[[<]]class $TemplateParameter_def[[TT]], class $TemplateParameter_def[[GG]]$AngleBracketClose[[>]]
       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<template<class> class $TemplateParameter_def[[T]], class $TemplateParameter_def[[C]]>
-      $TemplateParameter[[T]]<$TemplateParameter[[C]]> $Function_decl[[f]]();
+      template$AngleBracketOpen[[<]]template$AngleBracketOpen[[<]]class$AngleBracketClose[[>]] class $TemplateParameter_def[[T]], class $TemplateParameter_def[[C]]$AngleBracketClose[[>]]
+      $TemplateParameter[[T]]$AngleBracketOpen[[<]]$TemplateParameter[[C]]$AngleBracketClose[[>]] $Function_decl[[f]]();
 
-      template<typename>
+      template$AngleBracketOpen[[<]]typename$AngleBracketClose[[>]]
       class $Class_def[[Foo]] {};
 
-      template<typename $TemplateParameter_def[[T]]>
+      template$AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
       void $Function_decl[[foo]]($TemplateParameter[[T]] ...);
     )cpp",
       R"cpp(
-      template <class $TemplateParameter_def[[T]]>
+      template $AngleBracketOpen[[<]]class $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
       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]]$AngleBracketOpen[[<]]float$AngleBracketClose[[>]];
+      template struct $Class_def[[Tmpl]]$AngleBracketOpen[[<]]double$AngleBracketClose[[>]];
     )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 @@
     )cpp",
       R"cpp(
       class $Class_def[[G]] {};
-      template<$Class[[G]] *$TemplateParameter_def_readonly[[U]]>
+      template$AngleBracketOpen[[<]]$Class[[G]] *$TemplateParameter_def_readonly[[U]]$AngleBracketClose[[>]]
       class $Class_def[[GP]] {};
-      template<$Class[[G]] &$TemplateParameter_def_readonly[[U]]>
+      template$AngleBracketOpen[[<]]$Class[[G]] &$TemplateParameter_def_readonly[[U]]$AngleBracketClose[[>]]
       class $Class_def[[GR]] {};
-      template<int *$TemplateParameter_def_readonly[[U]]>
+      template$AngleBracketOpen[[<]]int *$TemplateParameter_def_readonly[[U]]$AngleBracketClose[[>]]
       class $Class_def[[IP]] {
         void $Method_def[[f]]() {
           $Operator[[*]]$TemplateParameter_readonly[[U]] $Operator[[+=]] 5;
         }
       };
-      template<unsigned $TemplateParameter_def_readonly[[U]] = 2>
+      template$AngleBracketOpen[[<]]unsigned $TemplateParameter_def_readonly[[U]] = 2$AngleBracketClose[[>]]
       class $Class_def[[Foo]] {
         void $Method_def[[f]]() {
           for(int $LocalVariable_def[[I]] = 0;
@@ -355,14 +355,14 @@
 
       $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]]$AngleBracketOpen[[<]]123$AngleBracketClose[[>]] $LocalVariable_def[[F]];
+        $Class[[GP]]$AngleBracketOpen[[<]]$Operator[[&]]$Variable[[L]]$AngleBracketClose[[>]] $LocalVariable_def[[LL]];
+        $Class[[GR]]$AngleBracketOpen[[<]]$Variable[[L]]$AngleBracketClose[[>]] $LocalVariable_def[[LLL]];
       }
     )cpp",
       R"cpp(
-      template<typename $TemplateParameter_def[[T]],
-        void ($TemplateParameter[[T]]::*$TemplateParameter_def_readonly[[method]])(int)>
+      template$AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]],
+        void ($TemplateParameter[[T]]::*$TemplateParameter_def_readonly[[method]])(int)$AngleBracketClose[[>]]
       struct $Class_def[[G]] {
         void $Method_def[[foo]](
             $TemplateParameter[[T]] *$Parameter_def[[O]]) {
@@ -373,7 +373,7 @@
       struct $Class_def[[F]] {
         void $Method_decl[[f]](int);
       };
-      template<void (*$TemplateParameter_def_readonly[[Func]])()>
+      template$AngleBracketOpen[[<]]void (*$TemplateParameter_def_readonly[[Func]])()$AngleBracketClose[[>]]
       struct $Class_def[[A]] {
         void $Method_def[[f]]() {
           ($Operator[[*]]$TemplateParameter_readonly[[Func]])();
@@ -382,9 +382,9 @@
 
       void $Function_def[[foo]]() {
         $Class[[F]] $LocalVariable_def[[FF]];
-        $Class[[G]]<$Class[[F]], $Operator[[&]]$Class[[F]]::$Method[[f]]> $LocalVariable_def[[GG]];
+        $Class[[G]]$AngleBracketOpen[[<]]$Class[[F]], $Operator[[&]]$Class[[F]]::$Method[[f]]$AngleBracketClose[[>]] $LocalVariable_def[[GG]];
         $LocalVariable[[GG]].$Method[[foo]]($Operator[[&]]$LocalVariable_usedAsMutablePointer[[FF]]);
-        $Class[[A]]<$Function[[foo]]> $LocalVariable_def[[AA]];
+        $Class[[A]]$AngleBracketOpen[[<]]$Function[[foo]]$AngleBracketClose[[>]] $LocalVariable_def[[AA]];
       }
     )cpp",
       // Tokens that share a source range but have conflicting Kinds are not
@@ -472,7 +472,7 @@
       }
     )cpp",
       R"cpp(
-      template<class $TemplateParameter_def[[T]]>
+      template$AngleBracketOpen[[<]]class $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
       class $Class_def[[A]] {
         using $TemplateParameter_decl[[TemplateParam1]] = $TemplateParameter[[T]];
         typedef $TemplateParameter[[T]] $TemplateParameter_decl[[TemplateParam2]];
@@ -491,9 +491,9 @@
       };
     )cpp",
       R"cpp(
-      template <class $TemplateParameter_def[[T]]>
+      template $AngleBracketOpen[[<]]class $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
       void $Function_decl[[phase1]]($TemplateParameter[[T]]);
-      template <class $TemplateParameter_def[[T]]>
+      template $AngleBracketOpen[[<]]class $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
       void $Function_def[[foo]]($TemplateParameter[[T]] $Parameter_def[[P]]) {
         $Function[[phase1]]($Parameter[[P]]);
         $Unknown_dependentName[[phase2]]($Parameter[[P]]);
@@ -501,22 +501,22 @@
     )cpp",
       R"cpp(
       class $Class_def[[A]] {
-        template <class $TemplateParameter_def[[T]]>
+        template $AngleBracketOpen[[<]]class $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
         void $Method_decl[[bar]]($TemplateParameter[[T]]);
       };
 
-      template <class $TemplateParameter_def[[U]]>
+      template $AngleBracketOpen[[<]]class $TemplateParameter_def[[U]]$AngleBracketClose[[>]]
       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 $AngleBracketOpen[[<]]class $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
         static void $StaticMethod_decl_static[[foo]]($TemplateParameter[[T]]);
       };
 
-      template <class $TemplateParameter_def[[T]]>
+      template $AngleBracketOpen[[<]]class $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
       struct $Class_def[[B]] {
         void $Method_def[[bar]]() {
           $Class[[A]]::$StaticMethod_static[[foo]]($TemplateParameter[[T]]());
@@ -524,18 +524,18 @@
       };
     )cpp",
       R"cpp(
-      template <class $TemplateParameter_def[[T]]>
+      template $AngleBracketOpen[[<]]class $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
       void $Function_decl[[foo]](typename $TemplateParameter[[T]]::$Type_dependentName[[Type]]
                                             = $TemplateParameter[[T]]::$Unknown_dependentName[[val]]);
     )cpp",
       R"cpp(
-      template <class $TemplateParameter_def[[T]]>
+      template $AngleBracketOpen[[<]]class $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
       void $Function_def[[foo]]($TemplateParameter[[T]] $Parameter_def[[P]]) {
         $Parameter[[P]].$Unknown_dependentName[[Field]];
       }
     )cpp",
       R"cpp(
-      template <class $TemplateParameter_def[[T]]>
+      template $AngleBracketOpen[[<]]class $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
       class $Class_def[[A]] {
         int $Method_def[[foo]]() {
           return $TemplateParameter[[T]]::$Unknown_dependentName[[Field]];
@@ -549,10 +549,10 @@
     )cpp",
       // Highlighting of template template arguments.
       R"cpp(
-      template <template <class> class $TemplateParameter_def[[TT]],
-                template <class> class ...$TemplateParameter_def[[TTs]]>
+      template $AngleBracketOpen[[<]]template $AngleBracketOpen[[<]]class$AngleBracketClose[[>]] class $TemplateParameter_def[[TT]],
+                template $AngleBracketOpen[[<]]class$AngleBracketClose[[>]] class ...$TemplateParameter_def[[TTs]]$AngleBracketClose[[>]]
       struct $Class_def[[Foo]] {
-        $Class[[Foo]]<$TemplateParameter[[TT]], $TemplateParameter[[TTs]]...>
+        $Class[[Foo]]$AngleBracketOpen[[<]]$TemplateParameter[[TT]], $TemplateParameter[[TTs]]...$AngleBracketClose[[>]]
           *$Field_decl[[t]];
       };
     )cpp",
@@ -590,7 +590,7 @@
     )cpp",
       // Argument to 'sizeof...'
       R"cpp(
-      template <typename... $TemplateParameter_def[[Elements]]>
+      template $AngleBracketOpen[[<]]typename... $TemplateParameter_def[[Elements]]$AngleBracketClose[[>]]
       struct $Class_def[[TupleSize]] {
         static const int $StaticField_decl_readonly_static[[size]] =
 sizeof...($TemplateParameter[[Elements]]);
@@ -598,7 +598,7 @@
     )cpp",
       // More dependent types
       R"cpp(
-      template <typename $TemplateParameter_def[[T]]>
+      template $AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
       struct $Class_def[[Waldo]] {
         using $Typedef_decl[[Location1]] = typename $TemplateParameter[[T]]
             ::$Type_dependentName[[Resolver]]::$Type_dependentName[[Location]];
@@ -614,33 +614,33 @@
     )cpp",
       // Dependent name with heuristic target
       R"cpp(
-      template <typename>
+      template $AngleBracketOpen[[<]]typename$AngleBracketClose[[>]]
       struct $Class_def[[Foo]] {
         int $Field_decl[[Waldo]];
         void $Method_def[[bar]]() {
           $Class[[Foo]]().$Field_dependentName[[Waldo]];
         }
-        template <typename $TemplateParameter_def[[U]]>
+        template $AngleBracketOpen[[<]]typename $TemplateParameter_def[[U]]$AngleBracketClose[[>]]
         void $Method_def[[bar1]]() {
-          $Class[[Foo]]<$TemplateParameter[[U]]>().$Field_dependentName[[Waldo]];
+          $Class[[Foo]]$AngleBracketOpen[[<]]$TemplateParameter[[U]]$AngleBracketClose[[>]]().$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 $AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
+      void $Function_def[[baz]]($Class[[Foo]]$AngleBracketOpen[[<]]$TemplateParameter[[T]]$AngleBracketClose[[>]] $Parameter_def[[o]]) {
         $Parameter[[o]].$Method_readonly_dependentName[[Overload]]();
       }
     )cpp",
       // Concepts
       R"cpp(
-      template <typename $TemplateParameter_def[[T]]>
+      template $AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
       concept $Concept_decl[[Fooable]] =
           requires($TemplateParameter[[T]] $Parameter_def[[F]]) {
             $Parameter[[F]].$Unknown_dependentName[[foo]]();
           };
-      template <typename $TemplateParameter_def[[T]]>
+      template $AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
           requires $Concept[[Fooable]]<$TemplateParameter[[T]]>
       void $Function_def[[bar]]($TemplateParameter[[T]] $Parameter_def[[F]]) {
         $Parameter[[F]].$Unknown_dependentName[[foo]]();
@@ -648,11 +648,11 @@
     )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 $AngleBracketOpen[[<]]template $AngleBracketOpen[[<]]typename$AngleBracketClose[[>]] class$AngleBracketClose[[>]] struct $Class_def[[A]] {};
+      template $AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
+      using $Typedef_decl[[W]] = $Class[[A]]$AngleBracketOpen[[<]]
         $TemplateParameter[[T]]::template $Class_dependentName[[Waldo]]
-      >;
+      $AngleBracketClose[[>]];
     )cpp",
       R"cpp(
       class $Class_def_abstract[[Abstract]] {
@@ -733,12 +733,12 @@
       )cpp",
       // Member imported from dependent base
       R"cpp(
-        template <typename> struct $Class_def[[Base]] {
+        template $AngleBracketOpen[[<]]typename$AngleBracketClose[[>]] 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 $AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
+        struct $Class_def[[Derived]] : $Class[[Base]]$AngleBracketOpen[[<]]$TemplateParameter[[T]]$AngleBracketClose[[>]] {
+          using $Class[[Base]]$AngleBracketOpen[[<]]$TemplateParameter[[T]]$AngleBracketClose[[>]]::$Field_dependentName[[member]];
 
           void $Method_def[[method]]() {
             (void)$Field_dependentName[[member]];
@@ -814,7 +814,7 @@
           int $Field_decl[[field]];
           static int $StaticField_decl_static[[staticField]];
         };
-        template <typename $TemplateParameter_def[[X]]>
+        template $AngleBracketOpen[[<]]typename $TemplateParameter_def[[X]]$AngleBracketClose[[>]]
         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 @@
         // 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 $AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
         void $Function_def[[Bar]]($TemplateParameter[[T]] $Parameter_def[[x]]) {
             $Function_deprecated[[Foo]]($Parameter[[x]]);
             $Function_deprecated[[Foo]]($Parameter[[x]]);
@@ -873,7 +873,7 @@
       )cpp",
       // Issue 1222: readonly modifier for generic parameter
       R"cpp(
-        template <typename $TemplateParameter_def[[T]]>
+        template $AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
         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 @@
       // Explicit template specialization
       R"cpp(
         struct $Class_def[[Base]]{};
-        template <typename $TemplateParameter_def[[T]]>
+        template $AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
         struct $Class_def[[S]] : public $Class[[Base]] {};
         template <>
-        struct $Class_def[[S]]<void> : public $Class[[Base]] {};
+        struct $Class_def[[S]]$AngleBracketOpen[[<]]void$AngleBracketClose[[>]] : public $Class[[Base]] {};
 
-        template <typename $TemplateParameter_def[[T]]>
+        template $AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
         $TemplateParameter[[T]] $Variable_def[[x]] = {};
         template <>
         int $Variable_def[[x]]<int> = (int)sizeof($Class[[Base]]);
       )cpp",
       // operator calls in template
       R"cpp(
-        template<typename $TemplateParameter_def[[T]]> class $Class_def[[C]] {
+        template$AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]] 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,16 @@
             $Class[[S]] $LocalVariable_def[[s2]] = $LocalVariable[[s]].operator$Operator_userDefined[[+]]($LocalVariable[[s]]);
         }
       )cpp",
+      R"cpp(
+        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$AngleBracketOpen[[<]]int$AngleBracketClose[[>]](3.5);
+          void *$LocalVariable_def[[p]] = reinterpret_cast$AngleBracketOpen[[<]]void *$AngleBracketClose[[>]](0);
+          $Class[[D]] &$LocalVariable_def[[d]] = dynamic_cast$AngleBracketOpen[[<]]$Class[[D]] &$AngleBracketClose[[>]]($LocalVariable[[b]]);
+        }
+      )cpp",
       // no crash
       R"cpp(
         struct $Class_def[[Foo]] {
@@ -934,12 +944,12 @@
         }
       )cpp",
       R"cpp(
-        template<typename>
+        template$AngleBracketOpen[[<]]typename$AngleBracketClose[[>]]
         class $Class_def[[Foo]] {};
 
-        template<typename $TemplateParameter_def[[T]]>
+        template$AngleBracketOpen[[<]]typename $TemplateParameter_def[[T]]$AngleBracketClose[[>]]
         void $Function_def[[k]]() {
-          auto $LocalVariable_def[[s]] = $Operator[[new]] $Class[[Foo]]<$TemplateParameter[[T]]>();
+          auto $LocalVariable_def[[s]] = $Operator[[new]] $Class[[Foo]]$AngleBracketOpen[[<]]$TemplateParameter[[T]]$AngleBracketClose[[>]]();
           $Operator[[delete]] $LocalVariable[[s]];
         }
       )cpp"};
@@ -1023,13 +1033,13 @@
         };
       )cpp",
       R"cpp(
-        template <int $TemplateParameter_classScope[[T]]>
+        template $AngleBracketOpen[[<]]int $TemplateParameter_classScope[[T]]$AngleBracketClose[[>]]
         class $Class_globalScope[[X]] {
         };
       )cpp",
       R"cpp(
         // No useful scope for template parameters of variable templates.
-        template <typename $TemplateParameter[[A]]>
+        template $AngleBracketOpen[[<]]typename $TemplateParameter[[A]]$AngleBracketClose[[>]]
         unsigned $Variable_globalScope[[X]] =
           $TemplateParameter[[A]]::$Unknown_classScope[[x]];
       )cpp",