ckandeler updated this revision to Diff 489722. ckandeler marked 2 inline comments as done. ckandeler retitled this revision from "[clangd] Add semantic tokens for angle brackets" to "[clangd] Add semantic token for angle brackets". ckandeler added a comment.
Added test cases, merged the two HighlightingKinds. 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$AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] 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$AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] + struct $Class_def[[C]] : $Namespace[[abc]]::$Class[[A]]$AngleBracket[[<]]$TemplateParameter[[T]]$AngleBracket[[>]] { 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]]$AngleBracket[[<]]int$AngleBracket[[>]] $Variable_def[[AA]]; + typedef $Namespace[[abc]]::$Class[[A]]$AngleBracket[[<]]int$AngleBracket[[>]] $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$AngleBracket[[<]]typename $TemplateParameter_def[[T]], typename = void$AngleBracket[[>]] class $Class_def[[A]] { $TemplateParameter[[T]] $Field_decl[[AA]]; $TemplateParameter[[T]] $Method_decl[[foo]](); }; - template<class $TemplateParameter_def[[TT]]> + template$AngleBracket[[<]]class $TemplateParameter_def[[TT]]$AngleBracket[[>]] class $Class_def[[B]] { - $Class[[A]]<$TemplateParameter[[TT]]> $Field_decl[[AA]]; + $Class[[A]]$AngleBracket[[<]]$TemplateParameter[[TT]]$AngleBracket[[>]] $Field_decl[[AA]]; }; - template<class $TemplateParameter_def[[TT]], class $TemplateParameter_def[[GG]]> + template$AngleBracket[[<]]class $TemplateParameter_def[[TT]], class $TemplateParameter_def[[GG]]$AngleBracket[[>]] 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$AngleBracket[[<]]template$AngleBracket[[<]]class$AngleBracket[[>]] class $TemplateParameter_def[[T]], class $TemplateParameter_def[[C]]$AngleBracket[[>]] + $TemplateParameter[[T]]$AngleBracket[[<]]$TemplateParameter[[C]]$AngleBracket[[>]] $Function_decl[[f]](); - template<typename> + template$AngleBracket[[<]]typename$AngleBracket[[>]] class $Class_def[[Foo]] {}; - template<typename $TemplateParameter_def[[T]]> + template$AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] void $Function_decl[[foo]]($TemplateParameter[[T]] ...); )cpp", R"cpp( - template <class $TemplateParameter_def[[T]]> + template $AngleBracket[[<]]class $TemplateParameter_def[[T]]$AngleBracket[[>]] 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]]$AngleBracket[[<]]float$AngleBracket[[>]]; + template struct $Class_def[[Tmpl]]$AngleBracket[[<]]double$AngleBracket[[>]]; )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$AngleBracket[[<]]$Class[[G]] *$TemplateParameter_def_readonly[[U]]$AngleBracket[[>]] class $Class_def[[GP]] {}; - template<$Class[[G]] &$TemplateParameter_def_readonly[[U]]> + template$AngleBracket[[<]]$Class[[G]] &$TemplateParameter_def_readonly[[U]]$AngleBracket[[>]] class $Class_def[[GR]] {}; - template<int *$TemplateParameter_def_readonly[[U]]> + template$AngleBracket[[<]]int *$TemplateParameter_def_readonly[[U]]$AngleBracket[[>]] class $Class_def[[IP]] { void $Method_def[[f]]() { $Operator[[*]]$TemplateParameter_readonly[[U]] $Operator[[+=]] 5; } }; - template<unsigned $TemplateParameter_def_readonly[[U]] = 2> + template$AngleBracket[[<]]unsigned $TemplateParameter_def_readonly[[U]] = 2$AngleBracket[[>]] 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]]$AngleBracket[[<]]123$AngleBracket[[>]] $LocalVariable_def[[F]]; + $Class[[GP]]$AngleBracket[[<]]$Operator[[&]]$Variable[[L]]$AngleBracket[[>]] $LocalVariable_def[[LL]]; + $Class[[GR]]$AngleBracket[[<]]$Variable[[L]]$AngleBracket[[>]] $LocalVariable_def[[LLL]]; } )cpp", R"cpp( - template<typename $TemplateParameter_def[[T]], - void ($TemplateParameter[[T]]::*$TemplateParameter_def_readonly[[method]])(int)> + template$AngleBracket[[<]]typename $TemplateParameter_def[[T]], + void ($TemplateParameter[[T]]::*$TemplateParameter_def_readonly[[method]])(int)$AngleBracket[[>]] 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$AngleBracket[[<]]void (*$TemplateParameter_def_readonly[[Func]])()$AngleBracket[[>]] 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]]$AngleBracket[[<]]$Class[[F]], $Operator[[&]]$Class[[F]]::$Method[[f]]$AngleBracket[[>]] $LocalVariable_def[[GG]]; $LocalVariable[[GG]].$Method[[foo]]($Operator[[&]]$LocalVariable_usedAsMutablePointer[[FF]]); - $Class[[A]]<$Function[[foo]]> $LocalVariable_def[[AA]]; + $Class[[A]]$AngleBracket[[<]]$Function[[foo]]$AngleBracket[[>]] $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$AngleBracket[[<]]class $TemplateParameter_def[[T]]$AngleBracket[[>]] 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 $AngleBracket[[<]]class $TemplateParameter_def[[T]]$AngleBracket[[>]] void $Function_decl[[phase1]]($TemplateParameter[[T]]); - template <class $TemplateParameter_def[[T]]> + template $AngleBracket[[<]]class $TemplateParameter_def[[T]]$AngleBracket[[>]] 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 $AngleBracket[[<]]class $TemplateParameter_def[[T]]$AngleBracket[[>]] void $Method_decl[[bar]]($TemplateParameter[[T]]); }; - template <class $TemplateParameter_def[[U]]> + template $AngleBracket[[<]]class $TemplateParameter_def[[U]]$AngleBracket[[>]] 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 $AngleBracket[[<]]class $TemplateParameter_def[[T]]$AngleBracket[[>]] static void $StaticMethod_decl_static[[foo]]($TemplateParameter[[T]]); }; - template <class $TemplateParameter_def[[T]]> + template $AngleBracket[[<]]class $TemplateParameter_def[[T]]$AngleBracket[[>]] 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 $AngleBracket[[<]]class $TemplateParameter_def[[T]]$AngleBracket[[>]] void $Function_decl[[foo]](typename $TemplateParameter[[T]]::$Type_dependentName[[Type]] = $TemplateParameter[[T]]::$Unknown_dependentName[[val]]); )cpp", R"cpp( - template <class $TemplateParameter_def[[T]]> + template $AngleBracket[[<]]class $TemplateParameter_def[[T]]$AngleBracket[[>]] void $Function_def[[foo]]($TemplateParameter[[T]] $Parameter_def[[P]]) { $Parameter[[P]].$Unknown_dependentName[[Field]]; } )cpp", R"cpp( - template <class $TemplateParameter_def[[T]]> + template $AngleBracket[[<]]class $TemplateParameter_def[[T]]$AngleBracket[[>]] 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 $AngleBracket[[<]]template $AngleBracket[[<]]class$AngleBracket[[>]] class $TemplateParameter_def[[TT]], + template $AngleBracket[[<]]class$AngleBracket[[>]] class ...$TemplateParameter_def[[TTs]]$AngleBracket[[>]] struct $Class_def[[Foo]] { - $Class[[Foo]]<$TemplateParameter[[TT]], $TemplateParameter[[TTs]]...> + $Class[[Foo]]$AngleBracket[[<]]$TemplateParameter[[TT]], $TemplateParameter[[TTs]]...$AngleBracket[[>]] *$Field_decl[[t]]; }; )cpp", @@ -590,7 +590,7 @@ )cpp", // Argument to 'sizeof...' R"cpp( - template <typename... $TemplateParameter_def[[Elements]]> + template $AngleBracket[[<]]typename... $TemplateParameter_def[[Elements]]$AngleBracket[[>]] 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 $AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] 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 $AngleBracket[[<]]typename$AngleBracket[[>]] struct $Class_def[[Foo]] { int $Field_decl[[Waldo]]; void $Method_def[[bar]]() { $Class[[Foo]]().$Field_dependentName[[Waldo]]; } - template <typename $TemplateParameter_def[[U]]> + template $AngleBracket[[<]]typename $TemplateParameter_def[[U]]$AngleBracket[[>]] void $Method_def[[bar1]]() { - $Class[[Foo]]<$TemplateParameter[[U]]>().$Field_dependentName[[Waldo]]; + $Class[[Foo]]$AngleBracket[[<]]$TemplateParameter[[U]]$AngleBracket[[>]]().$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 $AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] + void $Function_def[[baz]]($Class[[Foo]]$AngleBracket[[<]]$TemplateParameter[[T]]$AngleBracket[[>]] $Parameter_def[[o]]) { $Parameter[[o]].$Method_readonly_dependentName[[Overload]](); } )cpp", // Concepts R"cpp( - template <typename $TemplateParameter_def[[T]]> + template $AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] concept $Concept_decl[[Fooable]] = requires($TemplateParameter[[T]] $Parameter_def[[F]]) { $Parameter[[F]].$Unknown_dependentName[[foo]](); }; - template <typename $TemplateParameter_def[[T]]> + template $AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] 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 $AngleBracket[[<]]template $AngleBracket[[<]]typename$AngleBracket[[>]] class$AngleBracket[[>]] struct $Class_def[[A]] {}; + template $AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] + using $Typedef_decl[[W]] = $Class[[A]]$AngleBracket[[<]] $TemplateParameter[[T]]::template $Class_dependentName[[Waldo]] - >; + $AngleBracket[[>]]; )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 $AngleBracket[[<]]typename$AngleBracket[[>]] 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 $AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] + struct $Class_def[[Derived]] : $Class[[Base]]$AngleBracket[[<]]$TemplateParameter[[T]]$AngleBracket[[>]] { + using $Class[[Base]]$AngleBracket[[<]]$TemplateParameter[[T]]$AngleBracket[[>]]::$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 $AngleBracket[[<]]typename $TemplateParameter_def[[X]]$AngleBracket[[>]] 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 $AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] 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 $AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] 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 $AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] struct $Class_def[[S]] : public $Class[[Base]] {}; template <> - struct $Class_def[[S]]<void> : public $Class[[Base]] {}; + struct $Class_def[[S]]$AngleBracket[[<]]void$AngleBracket[[>]] : public $Class[[Base]] {}; - template <typename $TemplateParameter_def[[T]]> + template $AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] $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$AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] 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,25 @@ $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$AngleBracket[[<]]int$AngleBracket[[>]](3.5); + void *$LocalVariable_def[[p]] = reinterpret_cast$AngleBracket[[<]]void *$AngleBracket[[>]](0); + $Class[[D]] &$LocalVariable_def[[d]] = dynamic_cast$AngleBracket[[<]]$Class[[D]] &$AngleBracket[[>]]($LocalVariable[[b]]); + } + )cpp", + R"cpp( + template$AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] struct $Class_def[[S]] {}; + void $Function_def[[f]]() { + $Class[[S]]$AngleBracket[[<]]$Class[[S]]$AngleBracket[[<]]int$AngleBracket[[>]]$AngleBracket[[>]] $LocalVariable_def[[s1]]; + $Class[[S]]<$Class[[S]]$AngleBracket[[<]]int$AngleBracket[[>]]\ +> $LocalVariable_def[[s2]]; + $Class[[S]]$AngleBracket[[<]]$Class[[S]]$AngleBracket[[<]]$Class[[S]]$AngleBracket[[<]]int$AngleBracket[[>]]$AngleBracket[[>]]$AngleBracket[[>]] $LocalVariable_def[[s3]]; + } + )cpp", // no crash R"cpp( struct $Class_def[[Foo]] { @@ -934,12 +953,12 @@ } )cpp", R"cpp( - template<typename> + template$AngleBracket[[<]]typename$AngleBracket[[>]] class $Class_def[[Foo]] {}; - template<typename $TemplateParameter_def[[T]]> + template$AngleBracket[[<]]typename $TemplateParameter_def[[T]]$AngleBracket[[>]] void $Function_def[[k]]() { - auto $LocalVariable_def[[s]] = $Operator[[new]] $Class[[Foo]]<$TemplateParameter[[T]]>(); + auto $LocalVariable_def[[s]] = $Operator[[new]] $Class[[Foo]]$AngleBracket[[<]]$TemplateParameter[[T]]$AngleBracket[[>]](); $Operator[[delete]] $LocalVariable[[s]]; } )cpp"}; @@ -1023,13 +1042,13 @@ }; )cpp", R"cpp( - template <int $TemplateParameter_classScope[[T]]> + template $AngleBracket[[<]]int $TemplateParameter_classScope[[T]]$AngleBracket[[>]] class $Class_globalScope[[X]] { }; )cpp", R"cpp( // No useful scope for template parameters of variable templates. - template <typename $TemplateParameter[[A]]> + template $AngleBracket[[<]]typename $TemplateParameter[[A]]$AngleBracket[[>]] 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, + AngleBracket, // 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::AngleBracket); + addToken(RRange, HighlightingKind::AngleBracket); + 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::AngleBracket); + addToken({Begin, End}, HighlightingKind::AngleBracket); + 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::AngleBracket); + addToken({Begin, End}, HighlightingKind::AngleBracket); + } + 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::AngleBracket: + return OS << "AngleBracket"; case HighlightingKind::InactiveCode: return OS << "InactiveCode"; } @@ -1212,6 +1290,8 @@ return "modifier"; case HighlightingKind::Operator: return "operator"; + case HighlightingKind::AngleBracket: + return "angleBracket"; case HighlightingKind::InactiveCode: return "comment"; }
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits