ckandeler updated this revision to Diff 490457.
ckandeler marked 2 inline comments as done.
ckandeler added a comment.
Made token name more generic, added test cases.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D139926/new/
https://reviews.llvm.org/D139926
Files:
clang-tools-extra/clangd/SemanticHighlighting.cpp
clang-tools-extra/clangd/SemanticHighlighting.h
clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
Index: clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
===================================================================
--- clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
+++ clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
@@ -130,17 +130,17 @@
)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 @@
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<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 @@
)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 @@
$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 @@
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 @@
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 @@
}
)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 @@
};
)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 @@
)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 @@
};
)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 @@
)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 @@
)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,7 +598,7 @@
)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]];
@@ -614,33 +614,33 @@
)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]]>
+ template $Bracket[[<]]typename $TemplateParameter_def[[T]]$Bracket[[>]]
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 $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 @@
)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 @@
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 @@
// 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 @@
)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 @@
// 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]] {};
+ 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]]);
)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,35 @@
$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$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",
+ 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]]<$Class[[S]]$Bracket[[<]]int$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]]<$Class[[S]]$Bracket[[<]]int$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]]<$Class[[S]]$Bracket[[<]]int$Bracket[[>]]\
+>$Bracket[[>]] $LocalVariable_def[[s6]];
+ $Class[[S]]$Bracket[[<]]$Class[[S]]$Bracket[[<]]$Class[[S]]$Bracket[[<]]int$Bracket[[>]]$Bracket[[>]]\
+ $Bracket[[>]] $LocalVariable_def[[s7]];
+ }
+ #define $Macro_decl[[LESS]] <
+ template $Macro[[LESS]] typename $TemplateParameter_def[[T]] > class $Class_def[[A]] {};
+ )cpp",
// no crash
R"cpp(
struct $Class_def[[Foo]] {
@@ -934,12 +963,12 @@
}
)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 +1052,13 @@
};
)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",
Index: clang-tools-extra/clangd/SemanticHighlighting.h
===================================================================
--- clang-tools-extra/clangd/SemanticHighlighting.h
+++ clang-tools-extra/clangd/SemanticHighlighting.h
@@ -51,6 +51,7 @@
Macro,
Modifier,
Operator,
+ Bracket,
// This one is different from the other kinds as it's a line style
// rather than a token style.
Index: clang-tools-extra/clangd/SemanticHighlighting.cpp
===================================================================
--- clang-tools-extra/clangd/SemanticHighlighting.cpp
+++ clang-tools-extra/clangd/SemanticHighlighting.cpp
@@ -369,6 +369,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::Bracket);
+ addToken(RRange, HighlightingKind::Bracket);
+ 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::Bracket);
+ addToken({Begin, End}, HighlightingKind::Bracket);
+ 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::Bracket);
+ addToken({Begin, End}, HighlightingKind::Bracket);
+ }
+
HighlightingToken &addToken(Range R, HighlightingKind Kind) {
HighlightingToken HT;
HT.R = std::move(R);
@@ -567,6 +624,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) {
@@ -581,6 +649,8 @@
if (Kind == OO_Call || Kind == OO_Subscript)
AddOpDeclToken(Range.getEnd());
}
+ if (auto *Args = D->getTemplateSpecializationArgsAsWritten())
+ H.addAngleBracketTokens(Args->getLAngleLoc(), Args->getRAngleLoc());
return true;
}
@@ -632,6 +702,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...
@@ -1074,6 +1150,8 @@
return OS << "Modifier";
case HighlightingKind::Operator:
return OS << "Operator";
+ case HighlightingKind::Bracket:
+ return OS << "Bracket";
case HighlightingKind::InactiveCode:
return OS << "InactiveCode";
}
@@ -1212,6 +1290,8 @@
return "modifier";
case HighlightingKind::Operator:
return "operator";
+ case HighlightingKind::Bracket:
+ return "bracket";
case HighlightingKind::InactiveCode:
return "comment";
}
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
