ckandeler updated this revision to Diff 436678.
ckandeler added a comment.
Objective-C improvements.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D127403/new/
https://reviews.llvm.org/D127403
Files:
clang-tools-extra/clangd/SemanticHighlighting.cpp
clang-tools-extra/clangd/SemanticHighlighting.h
clang-tools-extra/clangd/test/initialize-params.test
clang-tools-extra/clangd/test/semantic-tokens.test
clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
clang-tools-extra/clangd/unittests/tweaks/AnnotateHighlightingsTests.cpp
Index: clang-tools-extra/clangd/unittests/tweaks/AnnotateHighlightingsTests.cpp
===================================================================
--- clang-tools-extra/clangd/unittests/tweaks/AnnotateHighlightingsTests.cpp
+++ clang-tools-extra/clangd/unittests/tweaks/AnnotateHighlightingsTests.cpp
@@ -18,18 +18,18 @@
TEST_F(AnnotateHighlightingsTest, Test) {
EXPECT_AVAILABLE("^vo^id^ ^f(^) {^}^"); // available everywhere.
EXPECT_AVAILABLE("[[int a; int b;]]");
- EXPECT_EQ("void /* Function [decl] [globalScope] */f() {}",
+ EXPECT_EQ("void /* Function [decl] [def] [globalScope] */f() {}",
apply("void ^f() {}"));
EXPECT_EQ(apply("[[int f1(); const int x = f1();]]"),
"int /* Function [decl] [globalScope] */f1(); "
- "const int /* Variable [decl] [readonly] [fileScope] */x = "
+ "const int /* Variable [decl] [def] [readonly] [fileScope] */x = "
"/* Function [globalScope] */f1();");
// Only the targeted range is annotated.
EXPECT_EQ(apply("void f1(); void f2() {^}"),
"void f1(); "
- "void /* Function [decl] [globalScope] */f2() {}");
+ "void /* Function [decl] [def] [globalScope] */f2() {}");
}
} // namespace
Index: clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
===================================================================
--- clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
+++ clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp
@@ -97,52 +97,52 @@
TEST(SemanticHighlighting, GetsCorrectTokens) {
const char *TestCases[] = {
R"cpp(
- struct $Class_decl[[AS]] {
+ struct $Class_decl_def[[AS]] {
double $Field_decl[[SomeMember]];
};
struct {
- } $Variable_decl[[S]];
- void $Function_decl[[foo]](int $Parameter_decl[[A]], $Class[[AS]] $Parameter_decl[[As]]) {
- $Primitive_deduced_defaultLibrary[[auto]] $LocalVariable_decl[[VeryLongVariableName]] = 12312;
- $Class[[AS]] $LocalVariable_decl[[AA]];
- $Primitive_deduced_defaultLibrary[[auto]] $LocalVariable_decl[[L]] = $LocalVariable[[AA]].$Field[[SomeMember]] + $Parameter[[A]];
- auto $LocalVariable_decl[[FN]] = [ $LocalVariable[[AA]]](int $Parameter_decl[[A]]) -> void {};
+ } $Variable_decl_def[[S]];
+ void $Function_decl_def[[foo]](int $Parameter_decl[[A]], $Class[[AS]] $Parameter_decl[[As]]) {
+ $Primitive_deduced_defaultLibrary[[auto]] $LocalVariable_decl_def[[VeryLongVariableName]] = 12312;
+ $Class[[AS]] $LocalVariable_decl_def[[AA]];
+ $Primitive_deduced_defaultLibrary[[auto]] $LocalVariable_decl_def[[L]] = $LocalVariable[[AA]].$Field[[SomeMember]] + $Parameter[[A]];
+ auto $LocalVariable_decl_def[[FN]] = [ $LocalVariable[[AA]]](int $Parameter_decl[[A]]) -> void {};
$LocalVariable[[FN]](12312);
}
)cpp",
R"cpp(
void $Function_decl[[foo]](int);
void $Function_decl[[Gah]]();
- void $Function_decl[[foo]]() {
- auto $LocalVariable_decl[[Bou]] = $Function[[Gah]];
+ void $Function_decl_def[[foo]]() {
+ auto $LocalVariable_decl_def[[Bou]] = $Function[[Gah]];
}
- struct $Class_decl[[A]] {
+ struct $Class_decl_def[[A]] {
void $Method_decl[[abc]]();
};
)cpp",
R"cpp(
namespace $Namespace_decl[[abc]] {
template<typename $TemplateParameter_decl[[T]]>
- struct $Class_decl[[A]] {
+ struct $Class_decl_def[[A]] {
$TemplateParameter[[T]] $Field_decl[[t]];
};
}
template<typename $TemplateParameter_decl[[T]]>
- struct $Class_decl[[C]] : $Namespace[[abc]]::$Class[[A]]<$TemplateParameter[[T]]> {
+ struct $Class_decl_def[[C]] : $Namespace[[abc]]::$Class[[A]]<$TemplateParameter[[T]]> {
typename $TemplateParameter[[T]]::$Type_dependentName[[A]]* $Field_decl[[D]];
};
- $Namespace[[abc]]::$Class[[A]]<int> $Variable_decl[[AA]];
+ $Namespace[[abc]]::$Class[[A]]<int> $Variable_decl_def[[AA]];
typedef $Namespace[[abc]]::$Class[[A]]<int> $Class_decl[[AAA]];
- struct $Class_decl[[B]] {
+ struct $Class_decl_def[[B]] {
$Class_decl[[B]]();
~$Class[[B]](); // FIXME: inconsistent with constructor
void operator<<($Class[[B]]);
$Class[[AAA]] $Field_decl[[AA]];
};
- $Class[[B]]::$Class_decl[[B]]() {}
+ $Class[[B]]::$Class_decl_def[[B]]() {}
$Class[[B]]::~$Class[[B]]() {} // FIXME: inconsistent with constructor
- void $Function_decl[[f]] () {
- $Class[[B]] $LocalVariable_decl[[BB]] = $Class[[B]]();
+ void $Function_decl_def[[f]] () {
+ $Class[[B]] $LocalVariable_decl_def[[BB]] = $Class[[B]]();
$LocalVariable[[BB]].~$Class[[B]]();
$Class[[B]]();
}
@@ -155,20 +155,20 @@
enum $Enum_decl[[EE]] {
$EnumConstant_decl_readonly[[Hi]],
};
- struct $Class_decl[[A]] {
+ struct $Class_decl_def[[A]] {
$Enum[[E]] $Field_decl[[EEE]];
$Enum[[EE]] $Field_decl[[EEEE]];
};
- int $Variable_decl[[I]] = $EnumConstant_readonly[[Hi]];
- $Enum[[E]] $Variable_decl[[L]] = $Enum[[E]]::$EnumConstant_readonly[[B]];
+ int $Variable_decl_def[[I]] = $EnumConstant_readonly[[Hi]];
+ $Enum[[E]] $Variable_decl_def[[L]] = $Enum[[E]]::$EnumConstant_readonly[[B]];
)cpp",
R"cpp(
namespace $Namespace_decl[[abc]] {
namespace {}
namespace $Namespace_decl[[bcd]] {
- struct $Class_decl[[A]] {};
+ struct $Class_decl_def[[A]] {};
namespace $Namespace_decl[[cde]] {
- struct $Class_decl[[A]] {
+ struct $Class_decl_def[[A]] {
enum class $Enum_decl[[B]] {
$EnumConstant_decl_readonly[[Hi]],
};
@@ -179,22 +179,22 @@
using namespace $Namespace[[abc]]::$Namespace[[bcd]];
namespace $Namespace_decl[[vwz]] =
$Namespace[[abc]]::$Namespace[[bcd]]::$Namespace[[cde]];
- $Namespace[[abc]]::$Namespace[[bcd]]::$Class[[A]] $Variable_decl[[AA]];
- $Namespace[[vwz]]::$Class[[A]]::$Enum[[B]] $Variable_decl[[AAA]] =
+ $Namespace[[abc]]::$Namespace[[bcd]]::$Class[[A]] $Variable_decl_def[[AA]];
+ $Namespace[[vwz]]::$Class[[A]]::$Enum[[B]] $Variable_decl_def[[AAA]] =
$Namespace[[vwz]]::$Class[[A]]::$Enum[[B]]::$EnumConstant_readonly[[Hi]];
- ::$Namespace[[vwz]]::$Class[[A]] $Variable_decl[[B]];
- ::$Namespace[[abc]]::$Namespace[[bcd]]::$Class[[A]] $Variable_decl[[BB]];
+ ::$Namespace[[vwz]]::$Class[[A]] $Variable_decl_def[[B]];
+ ::$Namespace[[abc]]::$Namespace[[bcd]]::$Class[[A]] $Variable_decl_def[[BB]];
)cpp",
R"cpp(
- struct $Class_decl[[D]] {
+ struct $Class_decl_def[[D]] {
double $Field_decl[[C]];
};
- struct $Class_decl[[A]] {
+ struct $Class_decl_def[[A]] {
double $Field_decl[[B]];
$Class[[D]] $Field_decl[[E]];
static double $StaticField_decl_static[[S]];
- static void $StaticMethod_decl_static[[bar]]() {}
- void $Method_decl[[foo]]() {
+ static void $StaticMethod_decl_def_static[[bar]]() {}
+ void $Method_decl_def[[foo]]() {
$Field[[B]] = 123;
this->$Field[[B]] = 156;
this->$Method[[foo]]();
@@ -203,8 +203,8 @@
$StaticField_static[[S]] = 90.1;
}
};
- void $Function_decl[[foo]]() {
- $Class[[A]] $LocalVariable_decl[[AA]];
+ void $Function_decl_def[[foo]]() {
+ $Class[[A]] $LocalVariable_decl_def[[AA]];
$LocalVariable[[AA]].$Field[[B]] += 2;
$LocalVariable[[AA]].$Method[[foo]]();
$LocalVariable[[AA]].$Field[[E]].$Field[[C]];
@@ -212,15 +212,15 @@
}
)cpp",
R"cpp(
- struct $Class_decl[[AA]] {
+ struct $Class_decl_def[[AA]] {
int $Field_decl[[A]];
};
- int $Variable_decl[[B]];
- $Class[[AA]] $Variable_decl[[A]]{$Variable[[B]]};
+ int $Variable_decl_def[[B]];
+ $Class[[AA]] $Variable_decl_def[[A]]{$Variable[[B]]};
)cpp",
R"cpp(
namespace $Namespace_decl[[a]] {
- struct $Class_decl[[A]] {};
+ struct $Class_decl_def[[A]] {};
typedef char $Primitive_decl[[C]];
}
typedef $Namespace[[a]]::$Class[[A]] $Class_decl[[B]];
@@ -236,56 +236,56 @@
)cpp",
R"cpp(
template<typename $TemplateParameter_decl[[T]], typename = void>
- class $Class_decl[[A]] {
+ class $Class_decl_def[[A]] {
$TemplateParameter[[T]] $Field_decl[[AA]];
$TemplateParameter[[T]] $Method_decl[[foo]]();
};
template<class $TemplateParameter_decl[[TT]]>
- class $Class_decl[[B]] {
+ class $Class_decl_def[[B]] {
$Class[[A]]<$TemplateParameter[[TT]]> $Field_decl[[AA]];
};
template<class $TemplateParameter_decl[[TT]], class $TemplateParameter_decl[[GG]]>
- class $Class_decl[[BB]] {};
+ class $Class_decl_def[[BB]] {};
template<class $TemplateParameter_decl[[T]]>
- class $Class_decl[[BB]]<$TemplateParameter[[T]], int> {};
+ class $Class_decl_def[[BB]]<$TemplateParameter[[T]], int> {};
template<class $TemplateParameter_decl[[T]]>
- class $Class_decl[[BB]]<$TemplateParameter[[T]], $TemplateParameter[[T]]*> {};
+ class $Class_decl_def[[BB]]<$TemplateParameter[[T]], $TemplateParameter[[T]]*> {};
template<template<class> class $TemplateParameter_decl[[T]], class $TemplateParameter_decl[[C]]>
$TemplateParameter[[T]]<$TemplateParameter[[C]]> $Function_decl[[f]]();
template<typename>
- class $Class_decl[[Foo]] {};
+ class $Class_decl_def[[Foo]] {};
template<typename $TemplateParameter_decl[[T]]>
void $Function_decl[[foo]]($TemplateParameter[[T]] ...);
)cpp",
R"cpp(
template <class $TemplateParameter_decl[[T]]>
- struct $Class_decl[[Tmpl]] {$TemplateParameter[[T]] $Field_decl[[x]] = 0;};
- extern template struct $Class_decl[[Tmpl]]<float>;
- template struct $Class_decl[[Tmpl]]<double>;
+ struct $Class_decl_def[[Tmpl]] {$TemplateParameter[[T]] $Field_decl[[x]] = 0;};
+ extern template struct $Class_decl_def[[Tmpl]]<float>;
+ template struct $Class_decl_def[[Tmpl]]<double>;
)cpp",
// This test is to guard against highlightings disappearing when using
// conversion operators as their behaviour in the clang AST differ from
// other CXXMethodDecls.
R"cpp(
- class $Class_decl[[Foo]] {};
- struct $Class_decl[[Bar]] {
+ class $Class_decl_def[[Foo]] {};
+ struct $Class_decl_def[[Bar]] {
explicit operator $Class[[Foo]]*() const;
explicit operator int() const;
operator $Class[[Foo]]();
};
- void $Function_decl[[f]]() {
- $Class[[Bar]] $LocalVariable_decl[[B]];
- $Class[[Foo]] $LocalVariable_decl[[F]] = $LocalVariable[[B]];
- $Class[[Foo]] *$LocalVariable_decl[[FP]] = ($Class[[Foo]]*)$LocalVariable[[B]];
- int $LocalVariable_decl[[I]] = (int)$LocalVariable[[B]];
+ void $Function_decl_def[[f]]() {
+ $Class[[Bar]] $LocalVariable_decl_def[[B]];
+ $Class[[Foo]] $LocalVariable_decl_def[[F]] = $LocalVariable[[B]];
+ $Class[[Foo]] *$LocalVariable_decl_def[[FP]] = ($Class[[Foo]]*)$LocalVariable[[B]];
+ int $LocalVariable_decl_def[[I]] = (int)$LocalVariable[[B]];
}
)cpp",
R"cpp(
- struct $Class_decl[[B]] {};
- struct $Class_decl[[A]] {
+ struct $Class_decl_def[[B]] {};
+ struct $Class_decl_def[[A]] {
$Class[[B]] $Field_decl[[BB]];
$Class[[A]] &operator=($Class[[A]] &&$Parameter_decl[[O]]);
};
@@ -296,86 +296,86 @@
enum $Enum_decl[[En]] {
$EnumConstant_decl_readonly[[EC]],
};
- class $Class_decl[[Foo]] {};
- class $Class_decl[[Bar]] {
+ class $Class_decl_def[[Foo]] {};
+ class $Class_decl_def[[Bar]] {
public:
$Class[[Foo]] $Field_decl[[Fo]];
$Enum[[En]] $Field_decl[[E]];
int $Field_decl[[I]];
- $Class_decl[[Bar]] ($Class[[Foo]] $Parameter_decl[[F]],
+ $Class_decl_def[[Bar]] ($Class[[Foo]] $Parameter_decl[[F]],
$Enum[[En]] $Parameter_decl[[E]])
: $Field[[Fo]] ($Parameter[[F]]), $Field[[E]] ($Parameter[[E]]),
$Field[[I]] (123) {}
};
- class $Class_decl[[Bar2]] : public $Class[[Bar]] {
- $Class_decl[[Bar2]]() : $Class[[Bar]]($Class[[Foo]](), $EnumConstant_readonly[[EC]]) {}
+ class $Class_decl_def[[Bar2]] : public $Class[[Bar]] {
+ $Class_decl_def[[Bar2]]() : $Class[[Bar]]($Class[[Foo]](), $EnumConstant_readonly[[EC]]) {}
};
)cpp",
R"cpp(
enum $Enum_decl[[E]] {
$EnumConstant_decl_readonly[[E]],
};
- class $Class_decl[[Foo]] {};
- $Enum_deduced[[auto]] $Variable_decl[[AE]] = $Enum[[E]]::$EnumConstant_readonly[[E]];
- $Class_deduced[[auto]] $Variable_decl[[AF]] = $Class[[Foo]]();
- $Class_deduced[[decltype]](auto) $Variable_decl[[AF2]] = $Class[[Foo]]();
- $Class_deduced[[auto]] *$Variable_decl[[AFP]] = &$Variable[[AF]];
- $Enum_deduced[[auto]] &$Variable_decl[[AER]] = $Variable[[AE]];
- $Primitive_deduced_defaultLibrary[[auto]] $Variable_decl[[Form]] = 10.2 + 2 * 4;
- $Primitive_deduced_defaultLibrary[[decltype]]($Variable[[Form]]) $Variable_decl[[F]] = 10;
- auto $Variable_decl[[Fun]] = []()->void{};
+ class $Class_decl_def[[Foo]] {};
+ $Enum_deduced[[auto]] $Variable_decl_def[[AE]] = $Enum[[E]]::$EnumConstant_readonly[[E]];
+ $Class_deduced[[auto]] $Variable_decl_def[[AF]] = $Class[[Foo]]();
+ $Class_deduced[[decltype]](auto) $Variable_decl_def[[AF2]] = $Class[[Foo]]();
+ $Class_deduced[[auto]] *$Variable_decl_def[[AFP]] = &$Variable[[AF]];
+ $Enum_deduced[[auto]] &$Variable_decl_def[[AER]] = $Variable[[AE]];
+ $Primitive_deduced_defaultLibrary[[auto]] $Variable_decl_def[[Form]] = 10.2 + 2 * 4;
+ $Primitive_deduced_defaultLibrary[[decltype]]($Variable[[Form]]) $Variable_decl_def[[F]] = 10;
+ auto $Variable_decl_def[[Fun]] = []()->void{};
)cpp",
R"cpp(
- class $Class_decl[[G]] {};
+ class $Class_decl_def[[G]] {};
template<$Class[[G]] *$TemplateParameter_decl_readonly[[U]]>
- class $Class_decl[[GP]] {};
+ class $Class_decl_def[[GP]] {};
template<$Class[[G]] &$TemplateParameter_decl_readonly[[U]]>
- class $Class_decl[[GR]] {};
+ class $Class_decl_def[[GR]] {};
template<int *$TemplateParameter_decl_readonly[[U]]>
- class $Class_decl[[IP]] {
- void $Method_decl[[f]]() {
+ class $Class_decl_def[[IP]] {
+ void $Method_decl_def[[f]]() {
*$TemplateParameter_readonly[[U]] += 5;
}
};
template<unsigned $TemplateParameter_decl_readonly[[U]] = 2>
- class $Class_decl[[Foo]] {
- void $Method_decl[[f]]() {
- for(int $LocalVariable_decl[[I]] = 0;
+ class $Class_decl_def[[Foo]] {
+ void $Method_decl_def[[f]]() {
+ for(int $LocalVariable_decl_def[[I]] = 0;
$LocalVariable[[I]] < $TemplateParameter_readonly[[U]];) {}
}
};
- $Class[[G]] $Variable_decl[[L]];
- void $Function_decl[[f]]() {
- $Class[[Foo]]<123> $LocalVariable_decl[[F]];
- $Class[[GP]]<&$Variable[[L]]> $LocalVariable_decl[[LL]];
- $Class[[GR]]<$Variable[[L]]> $LocalVariable_decl[[LLL]];
+ $Class[[G]] $Variable_decl_def[[L]];
+ void $Function_decl_def[[f]]() {
+ $Class[[Foo]]<123> $LocalVariable_decl_def[[F]];
+ $Class[[GP]]<&$Variable[[L]]> $LocalVariable_decl_def[[LL]];
+ $Class[[GR]]<$Variable[[L]]> $LocalVariable_decl_def[[LLL]];
}
)cpp",
R"cpp(
template<typename $TemplateParameter_decl[[T]],
void ($TemplateParameter[[T]]::*$TemplateParameter_decl_readonly[[method]])(int)>
- struct $Class_decl[[G]] {
- void $Method_decl[[foo]](
+ struct $Class_decl_def[[G]] {
+ void $Method_decl_def[[foo]](
$TemplateParameter[[T]] *$Parameter_decl[[O]]) {
($Parameter[[O]]->*$TemplateParameter_readonly[[method]])(10);
}
};
- struct $Class_decl[[F]] {
+ struct $Class_decl_def[[F]] {
void $Method_decl[[f]](int);
};
template<void (*$TemplateParameter_decl_readonly[[Func]])()>
- struct $Class_decl[[A]] {
- void $Method_decl[[f]]() {
+ struct $Class_decl_def[[A]] {
+ void $Method_decl_def[[f]]() {
(*$TemplateParameter_readonly[[Func]])();
}
};
- void $Function_decl[[foo]]() {
- $Class[[F]] $LocalVariable_decl[[FF]];
- $Class[[G]]<$Class[[F]], &$Class[[F]]::$Method[[f]]> $LocalVariable_decl[[GG]];
+ void $Function_decl_def[[foo]]() {
+ $Class[[F]] $LocalVariable_decl_def[[FF]];
+ $Class[[G]]<$Class[[F]], &$Class[[F]]::$Method[[f]]> $LocalVariable_decl_def[[GG]];
$LocalVariable[[GG]].$Method[[foo]](&$LocalVariable[[FF]]);
- $Class[[A]]<$Function[[foo]]> $LocalVariable_decl[[AA]];
+ $Class[[A]]<$Function[[foo]]> $LocalVariable_decl_def[[AA]];
}
)cpp",
// Tokens that share a source range but have conflicting Kinds are not
@@ -386,7 +386,7 @@
// Preamble ends.
$Macro[[DEF_MULTIPLE]](XYZ);
$Macro[[DEF_MULTIPLE]](XYZW);
- $Macro[[DEF_CLASS]]($Class_decl[[A]])
+ $Macro[[DEF_CLASS]]($Class_decl_def[[A]])
#define $Macro_decl[[MACRO_CONCAT]](X, V, T) T foo##X = V
#define $Macro_decl[[DEF_VAR]](X, V) int X = V
#define $Macro_decl[[DEF_VAR_T]](T, X, V) T X = V
@@ -396,27 +396,27 @@
#define $Macro_decl[[SOME_NAME]] variable
#define $Macro_decl[[SOME_NAME_SET]] variable2 = 123
#define $Macro_decl[[INC_VAR]](X) X += 2
- void $Function_decl[[foo]]() {
- $Macro[[DEF_VAR]]($LocalVariable_decl[[X]], 123);
- $Macro[[DEF_VAR_REV]](908, $LocalVariable_decl[[XY]]);
- int $Macro[[CPY]]( $LocalVariable_decl[[XX]] );
- $Macro[[DEF_VAR_TYPE]]($Class[[A]], $LocalVariable_decl[[AA]]);
+ void $Function_decl_def[[foo]]() {
+ $Macro[[DEF_VAR]]($LocalVariable_decl_def[[X]], 123);
+ $Macro[[DEF_VAR_REV]](908, $LocalVariable_decl_def[[XY]]);
+ int $Macro[[CPY]]( $LocalVariable_decl_def[[XX]] );
+ $Macro[[DEF_VAR_TYPE]]($Class[[A]], $LocalVariable_decl_def[[AA]]);
double $Macro[[SOME_NAME]];
int $Macro[[SOME_NAME_SET]];
$LocalVariable[[variable]] = 20.1;
$Macro[[MACRO_CONCAT]](var, 2, float);
$Macro[[DEF_VAR_T]]($Class[[A]], $Macro[[CPY]](
- $Macro[[CPY]]($LocalVariable_decl[[Nested]])),
+ $Macro[[CPY]]($LocalVariable_decl_def[[Nested]])),
$Macro[[CPY]]($Class[[A]]()));
$Macro[[INC_VAR]]($LocalVariable[[variable]]);
}
void $Macro[[SOME_NAME]]();
- $Macro[[DEF_VAR]]($Variable_decl[[MMMMM]], 567);
- $Macro[[DEF_VAR_REV]](756, $Variable_decl[[AB]]);
+ $Macro[[DEF_VAR]]($Variable_decl_def[[MMMMM]], 567);
+ $Macro[[DEF_VAR_REV]](756, $Variable_decl_def[[AB]]);
#define $Macro_decl[[CALL_FN]](F) F();
#define $Macro_decl[[DEF_FN]](F) void F ()
- $Macro[[DEF_FN]]($Function_decl[[g]]) {
+ $Macro[[DEF_FN]]($Function_decl_def[[g]]) {
$Macro[[CALL_FN]]($Function[[foo]]);
}
)cpp",
@@ -424,10 +424,10 @@
#define $Macro_decl[[fail]](expr) expr
#define $Macro_decl[[assert]](COND) if (!(COND)) { fail("assertion failed" #COND); }
// Preamble ends.
- int $Variable_decl[[x]];
- int $Variable_decl[[y]];
+ int $Variable_decl_def[[x]];
+ int $Variable_decl_def[[y]];
int $Function_decl[[f]]();
- void $Function_decl[[foo]]() {
+ void $Function_decl_def[[foo]]() {
$Macro[[assert]]($Variable[[x]] != $Variable[[y]]);
$Macro[[assert]]($Variable[[x]] != $Function[[f]]());
}
@@ -447,14 +447,14 @@
$InactiveCode[[#endif]]
)cpp",
R"cpp(
- struct $Class_decl[[S]] {
+ struct $Class_decl_def[[S]] {
float $Field_decl[[Value]];
$Class[[S]] *$Field_decl[[Next]];
};
- $Class[[S]] $Variable_decl[[Global]][2] = {$Class[[S]](), $Class[[S]]()};
+ $Class[[S]] $Variable_decl_def[[Global]][2] = {$Class[[S]](), $Class[[S]]()};
auto [$Variable_decl[[G1]], $Variable_decl[[G2]]] = $Variable[[Global]];
- void $Function_decl[[f]]($Class[[S]] $Parameter_decl[[P]]) {
- int $LocalVariable_decl[[A]][2] = {1,2};
+ void $Function_decl_def[[f]]($Class[[S]] $Parameter_decl[[P]]) {
+ int $LocalVariable_decl_def[[A]][2] = {1,2};
auto [$LocalVariable_decl[[B1]], $LocalVariable_decl[[B2]]] = $LocalVariable[[A]];
auto [$LocalVariable_decl[[G1]], $LocalVariable_decl[[G2]]] = $Variable[[Global]];
$Class_deduced[[auto]] [$LocalVariable_decl[[P1]], $LocalVariable_decl[[P2]]] = $Parameter[[P]];
@@ -464,7 +464,7 @@
)cpp",
R"cpp(
template<class $TemplateParameter_decl[[T]]>
- class $Class_decl[[A]] {
+ class $Class_decl_def[[A]] {
using $TemplateParameter_decl[[TemplateParam1]] = $TemplateParameter[[T]];
typedef $TemplateParameter[[T]] $TemplateParameter_decl[[TemplateParam2]];
using $Primitive_decl[[IntType]] = int;
@@ -485,31 +485,31 @@
template <class $TemplateParameter_decl[[T]]>
void $Function_decl[[phase1]]($TemplateParameter[[T]]);
template <class $TemplateParameter_decl[[T]]>
- void $Function_decl[[foo]]($TemplateParameter[[T]] $Parameter_decl[[P]]) {
+ void $Function_decl_def[[foo]]($TemplateParameter[[T]] $Parameter_decl[[P]]) {
$Function[[phase1]]($Parameter[[P]]);
$Unknown_dependentName[[phase2]]($Parameter[[P]]);
}
)cpp",
R"cpp(
- class $Class_decl[[A]] {
+ class $Class_decl_def[[A]] {
template <class $TemplateParameter_decl[[T]]>
void $Method_decl[[bar]]($TemplateParameter[[T]]);
};
template <class $TemplateParameter_decl[[U]]>
- void $Function_decl[[foo]]($TemplateParameter[[U]] $Parameter_decl[[P]]) {
+ void $Function_decl_def[[foo]]($TemplateParameter[[U]] $Parameter_decl[[P]]) {
$Class[[A]]().$Method[[bar]]($Parameter[[P]]);
}
)cpp",
R"cpp(
- struct $Class_decl[[A]] {
+ struct $Class_decl_def[[A]] {
template <class $TemplateParameter_decl[[T]]>
static void $StaticMethod_decl_static[[foo]]($TemplateParameter[[T]]);
};
template <class $TemplateParameter_decl[[T]]>
- struct $Class_decl[[B]] {
- void $Method_decl[[bar]]() {
+ struct $Class_decl_def[[B]] {
+ void $Method_decl_def[[bar]]() {
$Class[[A]]::$StaticMethod_static[[foo]]($TemplateParameter[[T]]());
}
};
@@ -521,14 +521,14 @@
)cpp",
R"cpp(
template <class $TemplateParameter_decl[[T]]>
- void $Function_decl[[foo]]($TemplateParameter[[T]] $Parameter_decl[[P]]) {
+ void $Function_decl_def[[foo]]($TemplateParameter[[T]] $Parameter_decl[[P]]) {
$Parameter[[P]].$Unknown_dependentName[[Field]];
}
)cpp",
R"cpp(
template <class $TemplateParameter_decl[[T]]>
- class $Class_decl[[A]] {
- int $Method_decl[[foo]]() {
+ class $Class_decl_def[[A]] {
+ int $Method_decl_def[[foo]]() {
return $TemplateParameter[[T]]::$Unknown_dependentName[[Field]];
}
};
@@ -542,7 +542,7 @@
R"cpp(
template <template <class> class $TemplateParameter_decl[[TT]],
template <class> class ...$TemplateParameter_decl[[TTs]]>
- struct $Class_decl[[Foo]] {
+ struct $Class_decl_def[[Foo]] {
$Class[[Foo]]<$TemplateParameter[[TT]], $TemplateParameter[[TTs]]...>
*$Field_decl[[t]];
};
@@ -555,7 +555,7 @@
$InactiveCode[[#endif]]
// A declaration to cause the preamble to end.
- int $Variable_decl[[EndPreamble]];
+ int $Variable_decl_def[[EndPreamble]];
// Code after the preamble.
// Code inside inactive blocks does not get regular highlightings
@@ -564,25 +564,25 @@
$InactiveCode[[#if defined(test)]]
$InactiveCode[[int Inactive2;]]
$InactiveCode[[#elif defined(test2)]]
- int $Variable_decl[[Active1]];
+ int $Variable_decl_def[[Active1]];
$InactiveCode[[#else]]
$InactiveCode[[int Inactive3;]]
$InactiveCode[[#endif]]
#ifndef $Macro[[test]]
- int $Variable_decl[[Active2]];
+ int $Variable_decl_def[[Active2]];
#endif
$InactiveCode[[#ifdef test]]
$InactiveCode[[int Inactive4;]]
$InactiveCode[[#else]]
- int $Variable_decl[[Active3]];
+ int $Variable_decl_def[[Active3]];
#endif
)cpp",
// Argument to 'sizeof...'
R"cpp(
template <typename... $TemplateParameter_decl[[Elements]]>
- struct $Class_decl[[TupleSize]] {
+ struct $Class_decl_def[[TupleSize]] {
static const int $StaticField_decl_readonly_static[[size]] =
sizeof...($TemplateParameter[[Elements]]);
};
@@ -590,7 +590,7 @@
// More dependent types
R"cpp(
template <typename $TemplateParameter_decl[[T]]>
- struct $Class_decl[[Waldo]] {
+ struct $Class_decl_def[[Waldo]] {
using $Typedef_decl[[Location1]] = typename $TemplateParameter[[T]]
::$Type_dependentName[[Resolver]]::$Type_dependentName[[Location]];
using $Typedef_decl[[Location2]] = typename $TemplateParameter[[T]]
@@ -606,13 +606,13 @@
// Dependent name with heuristic target
R"cpp(
template <typename>
- struct $Class_decl[[Foo]] {
+ struct $Class_decl_def[[Foo]] {
int $Field_decl[[Waldo]];
- void $Method_decl[[bar]]() {
+ void $Method_decl_def[[bar]]() {
$Class[[Foo]]().$Field_dependentName[[Waldo]];
}
template <typename $TemplateParameter_decl[[U]]>
- void $Method_decl[[bar1]]() {
+ void $Method_decl_def[[bar1]]() {
$Class[[Foo]]<$TemplateParameter[[U]]>().$Field_dependentName[[Waldo]];
}
@@ -620,57 +620,57 @@
void $Method_decl_readonly[[Overload]]() const;
};
template <typename $TemplateParameter_decl[[T]]>
- void $Function_decl[[baz]]($Class[[Foo]]<$TemplateParameter[[T]]> $Parameter_decl[[o]]) {
+ void $Function_decl_def[[baz]]($Class[[Foo]]<$TemplateParameter[[T]]> $Parameter_decl[[o]]) {
$Parameter[[o]].$Method_readonly_dependentName[[Overload]]();
}
)cpp",
// Concepts
R"cpp(
template <typename $TemplateParameter_decl[[T]]>
- concept $Concept_decl[[Fooable]] =
+ concept $Concept_decl[[Fooable]] =
requires($TemplateParameter[[T]] $Parameter_decl[[F]]) {
$Parameter[[F]].$Unknown_dependentName[[foo]]();
};
template <typename $TemplateParameter_decl[[T]]>
requires $Concept[[Fooable]]<$TemplateParameter[[T]]>
- void $Function_decl[[bar]]($TemplateParameter[[T]] $Parameter_decl[[F]]) {
+ void $Function_decl_def[[bar]]($TemplateParameter[[T]] $Parameter_decl[[F]]) {
$Parameter[[F]].$Unknown_dependentName[[foo]]();
}
)cpp",
// Dependent template name
R"cpp(
- template <template <typename> class> struct $Class_decl[[A]] {};
+ template <template <typename> class> struct $Class_decl_def[[A]] {};
template <typename $TemplateParameter_decl[[T]]>
using $Typedef_decl[[W]] = $Class[[A]]<
$TemplateParameter[[T]]::template $Class_dependentName[[Waldo]]
>;
)cpp",
R"cpp(
- class $Class_decl_abstract[[Abstract]] {
+ class $Class_decl_def_abstract[[Abstract]] {
public:
virtual void $Method_decl_abstract_virtual[[pure]]() = 0;
virtual void $Method_decl_virtual[[impl]]();
};
- void $Function_decl[[foo]]($Class_abstract[[Abstract]]* $Parameter_decl[[A]]) {
+ void $Function_decl_def[[foo]]($Class_abstract[[Abstract]]* $Parameter_decl[[A]]) {
$Parameter[[A]]->$Method_abstract_virtual[[pure]]();
$Parameter[[A]]->$Method_virtual[[impl]]();
}
)cpp",
R"cpp(
- <:[deprecated]:> int $Variable_decl_deprecated[[x]];
+ <:[deprecated]:> int $Variable_decl_def_deprecated[[x]];
)cpp",
R"cpp(
// ObjC: Classes and methods
@class $Class_decl[[Forward]];
- @interface $Class_decl[[Foo]]
+ @interface $Class_decl_def[[Foo]]
@end
- @interface $Class_decl[[Bar]] : $Class[[Foo]]
+ @interface $Class_decl_def[[Bar]] : $Class[[Foo]]
-(id) $Method_decl[[x]]:(int)$Parameter_decl[[a]] $Method_decl[[y]]:(int)$Parameter_decl[[b]];
+(instancetype)$StaticMethod_decl_static[[sharedInstance]];
+(void) $StaticMethod_decl_static[[explode]];
@end
- @implementation $Class_decl[[Bar]]
+ @implementation $Class_decl_def[[Bar]]
-(id) $Method_decl[[x]]:(int)$Parameter_decl[[a]] $Method_decl[[y]]:(int)$Parameter_decl[[b]] {
return self;
}
@@ -678,39 +678,39 @@
+(void) $StaticMethod_decl_static[[explode]] {}
@end
- void $Function_decl[[m]]($Class[[Bar]] *$Parameter_decl[[b]]) {
+ void $Function_decl_def[[m]]($Class[[Bar]] *$Parameter_decl[[b]]) {
[$Parameter[[b]] $Method[[x]]:1 $Method[[y]]:2];
[$Class[[Bar]] $StaticMethod_static[[explode]]];
}
)cpp",
R"cpp(
// ObjC: Protocols
- @protocol $Interface_decl[[Protocol]]
+ @protocol $Interface_decl_def[[Protocol]]
@end
- @protocol $Interface_decl[[Protocol2]] <$Interface[[Protocol]]>
+ @protocol $Interface_decl_def[[Protocol2]] <$Interface[[Protocol]]>
@end
- @interface $Class_decl[[Klass]] <$Interface[[Protocol]]>
+ @interface $Class_decl_def[[Klass]] <$Interface[[Protocol]]>
@end
- id<$Interface[[Protocol]]> $Variable_decl[[x]];
+ id<$Interface[[Protocol]]> $Variable_decl_def[[x]];
)cpp",
R"cpp(
// ObjC: Categories
- @interface $Class_decl[[Foo]]
+ @interface $Class_decl_def[[Foo]]
@end
- @interface $Class[[Foo]]($Namespace_decl[[Bar]])
+ @interface $Class[[Foo]]($Namespace_decl_def[[Bar]])
@end
- @implementation $Class[[Foo]]($Namespace_decl[[Bar]])
+ @implementation $Class[[Foo]]($Namespace_decl_def[[Bar]])
@end
)cpp",
R"cpp(
// ObjC: Properties and Ivars.
- @interface $Class_decl[[Foo]] {
+ @interface $Class_decl_def[[Foo]] {
int $Field_decl[[_someProperty]];
}
@property(nonatomic, assign) int $Field_decl[[someProperty]];
@property(readonly, class) $Class[[Foo]] *$Field_decl_readonly_static[[sharedInstance]];
@end
- @implementation $Class_decl[[Foo]]
+ @implementation $Class_decl_def[[Foo]]
@synthesize someProperty = _someProperty;
- (int)$Method_decl[[otherMethod]] {
return 0;
@@ -724,65 +724,65 @@
)cpp",
// Member imported from dependent base
R"cpp(
- template <typename> struct $Class_decl[[Base]] {
+ template <typename> struct $Class_decl_def[[Base]] {
int $Field_decl[[member]];
};
template <typename $TemplateParameter_decl[[T]]>
- struct $Class_decl[[Derived]] : $Class[[Base]]<$TemplateParameter[[T]]> {
+ struct $Class_decl_def[[Derived]] : $Class[[Base]]<$TemplateParameter[[T]]> {
using $Class[[Base]]<$TemplateParameter[[T]]>::$Field_dependentName[[member]];
- void $Method_decl[[method]]() {
+ void $Method_decl_def[[method]]() {
(void)$Field_dependentName[[member]];
}
};
)cpp",
// Modifier for variables passed as non-const references
R"cpp(
- void $Function_decl[[fun]](int, const int,
+ void $Function_decl_def[[fun]](int, const int,
int*, const int*,
int&, const int&,
int*&, const int*&, const int* const &,
int**, int**&, int** const &,
int = 123) {
- int $LocalVariable_decl[[val]];
- int* $LocalVariable_decl[[ptr]];
- const int* $LocalVariable_decl_readonly[[constPtr]];
- int** $LocalVariable_decl[[array]];
- $Function[[fun]]($LocalVariable[[val]], $LocalVariable[[val]],
- $LocalVariable[[ptr]], $LocalVariable_readonly[[constPtr]],
- $LocalVariable_usedAsMutableReference[[val]], $LocalVariable[[val]],
+ int $LocalVariable_decl_def[[val]];
+ int* $LocalVariable_decl_def[[ptr]];
+ const int* $LocalVariable_decl_def_readonly[[constPtr]];
+ int** $LocalVariable_decl_def[[array]];
+ $Function[[fun]]($LocalVariable[[val]], $LocalVariable[[val]],
+ $LocalVariable[[ptr]], $LocalVariable_readonly[[constPtr]],
+ $LocalVariable_usedAsMutableReference[[val]], $LocalVariable[[val]],
$LocalVariable_usedAsMutableReference[[ptr]],
$LocalVariable_readonly_usedAsMutableReference[[constPtr]],
$LocalVariable_readonly[[constPtr]],
- $LocalVariable[[array]], $LocalVariable_usedAsMutableReference[[array]],
+ $LocalVariable[[array]], $LocalVariable_usedAsMutableReference[[array]],
$LocalVariable[[array]]
);
}
- struct $Class_decl[[S]] {
- $Class_decl[[S]](int&) {
- $Class[[S]] $LocalVariable_decl[[s1]]($Field_usedAsMutableReference[[field]]);
- $Class[[S]] $LocalVariable_decl[[s2]]($LocalVariable[[s1]].$Field_usedAsMutableReference[[field]]);
+ struct $Class_decl_def[[S]] {
+ $Class_decl_def[[S]](int&) {
+ $Class[[S]] $LocalVariable_decl_def[[s1]]($Field_usedAsMutableReference[[field]]);
+ $Class[[S]] $LocalVariable_decl_def[[s2]]($LocalVariable[[s1]].$Field_usedAsMutableReference[[field]]);
- $Class[[S]] $LocalVariable_decl[[s3]]($StaticField_static_usedAsMutableReference[[staticField]]);
- $Class[[S]] $LocalVariable_decl[[s4]]($Class[[S]]::$StaticField_static_usedAsMutableReference[[staticField]]);
+ $Class[[S]] $LocalVariable_decl_def[[s3]]($StaticField_static_usedAsMutableReference[[staticField]]);
+ $Class[[S]] $LocalVariable_decl_def[[s4]]($Class[[S]]::$StaticField_static_usedAsMutableReference[[staticField]]);
}
int $Field_decl[[field]];
static int $StaticField_decl_static[[staticField]];
};
template <typename $TemplateParameter_decl[[X]]>
- void $Function_decl[[foo]]($TemplateParameter[[X]]& $Parameter_decl[[x]]) {
+ void $Function_decl_def[[foo]]($TemplateParameter[[X]]& $Parameter_decl[[x]]) {
// We do not support dependent types, so this one should *not* get the modifier.
- $Function[[foo]]($Parameter[[x]]);
+ $Function[[foo]]($Parameter[[x]]);
}
)cpp",
// init-captures
R"cpp(
- void $Function_decl[[foo]]() {
- int $LocalVariable_decl[[a]], $LocalVariable_decl[[b]];
- [ $LocalVariable_decl[[c]] = $LocalVariable[[a]],
- $LocalVariable_decl[[d]]($LocalVariable[[b]]) ]() {}();
+ void $Function_decl_def[[foo]]() {
+ int $LocalVariable_decl_def[[a]], $LocalVariable_decl_def[[b]];
+ [ $LocalVariable_decl_def[[c]] = $LocalVariable[[a]],
+ $LocalVariable_decl_def[[d]]($LocalVariable[[b]]) ]() {}();
}
)cpp",
// Enum base specifier
@@ -802,24 +802,24 @@
<:<:deprecated:>:> void $Function_decl_deprecated[[Foo]](int* $Parameter_decl[[x]]);
void $Function_decl[[Foo]](int $Parameter_decl[[x]]);
template <typename $TemplateParameter_decl[[T]]>
- void $Function_decl[[Bar]]($TemplateParameter[[T]] $Parameter_decl[[x]]) {
- $Function_deprecated[[Foo]]($Parameter[[x]]);
- $Function_deprecated[[Foo]]($Parameter[[x]]);
- $Function_deprecated[[Foo]]($Parameter[[x]]);
+ void $Function_decl_def[[Bar]]($TemplateParameter[[T]] $Parameter_decl[[x]]) {
+ $Function_deprecated[[Foo]]($Parameter[[x]]);
+ $Function_deprecated[[Foo]]($Parameter[[x]]);
+ $Function_deprecated[[Foo]]($Parameter[[x]]);
}
)cpp",
// Explicit template specialization
R"cpp(
- struct $Class_decl[[Base]]{};
+ struct $Class_decl_def[[Base]]{};
template <typename $TemplateParameter_decl[[T]]>
- struct $Class_decl[[S]] : public $Class[[Base]] {};
- template <>
- struct $Class_decl[[S]]<void> : public $Class[[Base]] {};
+ struct $Class_decl_def[[S]] : public $Class[[Base]] {};
+ template <>
+ struct $Class_decl_def[[S]]<void> : public $Class[[Base]] {};
template <typename $TemplateParameter_decl[[T]]>
- $TemplateParameter[[T]] $Variable_decl[[x]] = {};
+ $TemplateParameter[[T]] $Variable_decl_def[[x]] = {};
template <>
- int $Variable_decl[[x]]<int> = (int)sizeof($Class[[Base]]);
+ int $Variable_decl_def[[x]]<int> = (int)sizeof($Class[[Base]]);
)cpp"};
for (const auto &TestCase : TestCases)
// Mask off scope modifiers to keep the tests manageable.
@@ -827,7 +827,7 @@
checkHighlightings(TestCase, {}, ~ScopeModifierMask);
checkHighlightings(R"cpp(
- class $Class_decl[[A]] {
+ class $Class_decl_def[[A]] {
#include "imp.h"
};
)cpp",
@@ -853,11 +853,11 @@
checkHighlightings(R"cpp(
#include "SYSObject.h"
- @interface $Class_defaultLibrary[[SYSObject]] ($Namespace_decl[[UserCategory]])
+ @interface $Class_defaultLibrary[[SYSObject]] ($Namespace_decl_def[[UserCategory]])
@property(nonatomic, readonly) int $Field_decl_readonly[[user_property]];
@end
- int $Function_decl[[somethingUsingSystemSymbols]]() {
- $Class_defaultLibrary[[SYSObject]] *$LocalVariable_decl[[obj]] = [$Class_defaultLibrary[[SYSObject]] $StaticMethod_static_defaultLibrary[[new]]];
+ int $Function_decl_def[[somethingUsingSystemSymbols]]() {
+ $Class_defaultLibrary[[SYSObject]] *$LocalVariable_decl_def[[obj]] = [$Class_defaultLibrary[[SYSObject]] $StaticMethod_static_defaultLibrary[[new]]];
return $LocalVariable[[obj]].$Field_defaultLibrary[[value]] + $LocalVariable[[obj]].$Field_readonly[[user_property]];
}
)cpp",
Index: clang-tools-extra/clangd/test/semantic-tokens.test
===================================================================
--- clang-tools-extra/clangd/test/semantic-tokens.test
+++ clang-tools-extra/clangd/test/semantic-tokens.test
@@ -23,7 +23,7 @@
# CHECK-NEXT: 4,
# CHECK-NEXT: 1,
# CHECK-NEXT: 0,
-# CHECK-NEXT: 8193
+# CHECK-NEXT: 16387
# CHECK-NEXT: ],
# CHECK-NEXT: "resultId": "1"
# CHECK-NEXT: }
@@ -49,7 +49,7 @@
# CHECK-NEXT: 4,
# CHECK-NEXT: 1,
# CHECK-NEXT: 0,
-# CHECK-NEXT: 8193
+# CHECK-NEXT: 16387
# CHECK-NEXT: ],
# Inserted at position 1
# CHECK-NEXT: "deleteCount": 0,
@@ -72,12 +72,12 @@
# CHECK-NEXT: 4,
# CHECK-NEXT: 1,
# CHECK-NEXT: 0,
-# CHECK-NEXT: 8193,
+# CHECK-NEXT: 16387,
# CHECK-NEXT: 1,
# CHECK-NEXT: 4,
# CHECK-NEXT: 1,
# CHECK-NEXT: 0,
-# CHECK-NEXT: 8193
+# CHECK-NEXT: 16387
# CHECK-NEXT: ],
# CHECK-NEXT: "resultId": "3"
# CHECK-NEXT: }
Index: clang-tools-extra/clangd/test/initialize-params.test
===================================================================
--- clang-tools-extra/clangd/test/initialize-params.test
+++ clang-tools-extra/clangd/test/initialize-params.test
@@ -86,6 +86,7 @@
# CHECK-NEXT: "legend": {
# CHECK-NEXT: "tokenModifiers": [
# CHECK-NEXT: "declaration",
+# CHECK-NEXT: "definition",
# CHECK-NEXT: "deprecated",
# CHECK-NEXT: "deduced",
# CHECK-NEXT: "readonly",
Index: clang-tools-extra/clangd/SemanticHighlighting.h
===================================================================
--- clang-tools-extra/clangd/SemanticHighlighting.h
+++ clang-tools-extra/clangd/SemanticHighlighting.h
@@ -60,7 +60,7 @@
enum class HighlightingModifier {
Declaration,
- // FIXME: Definition (needs findExplicitReferences support)
+ Definition,
Deprecated,
Deduced,
Readonly,
Index: clang-tools-extra/clangd/SemanticHighlighting.cpp
===================================================================
--- clang-tools-extra/clangd/SemanticHighlighting.cpp
+++ clang-tools-extra/clangd/SemanticHighlighting.cpp
@@ -831,8 +831,33 @@
// Do not treat an UnresolvedUsingValueDecl as a declaration.
// It's more common to think of it as a reference to the
// underlying declaration.
- if (R.IsDecl && !isa<UnresolvedUsingValueDecl>(Decl))
- Tok.addModifier(HighlightingModifier::Declaration);
+ if (R.IsDecl) {
+ if (!isa<UnresolvedUsingValueDecl>(Decl))
+ Tok.addModifier(HighlightingModifier::Declaration);
+ if (const auto Func = dyn_cast<FunctionDecl>(Decl)) {
+ if (Func->isThisDeclarationADefinition())
+ Tok.addModifier(HighlightingModifier::Definition);
+ } else if (const auto Method = dyn_cast<ObjCMethodDecl>(Decl)) {
+ if (Method->isThisDeclarationADefinition())
+ Tok.addModifier(HighlightingModifier::Definition);
+ } else if (const auto Klass = dyn_cast<CXXRecordDecl>(Decl)) {
+ if (Klass->isThisDeclarationADefinition())
+ Tok.addModifier(HighlightingModifier::Definition);
+ } else if (const auto Iface = dyn_cast<ObjCInterfaceDecl>(Decl)) {
+ if (Iface->isThisDeclarationADefinition())
+ Tok.addModifier(HighlightingModifier::Definition);
+ } else if (const auto Proto = dyn_cast<ObjCProtocolDecl>(Decl)) {
+ if (Proto->isThisDeclarationADefinition())
+ Tok.addModifier(HighlightingModifier::Definition);
+ } else if (isa<ObjCCategoryDecl>(Decl)) {
+ Tok.addModifier(HighlightingModifier::Definition);
+ } else if (isa<ObjCImplDecl>(Decl)) {
+ Tok.addModifier(HighlightingModifier::Definition);
+ } else if (const auto Var = dyn_cast<VarDecl>(Decl)) {
+ if (!isa<ParmVarDecl>(Var) && Var->isThisDeclarationADefinition())
+ Tok.addModifier(HighlightingModifier::Definition);
+ }
+ }
}
},
AST.getHeuristicResolver());
@@ -903,6 +928,8 @@
switch (K) {
case HighlightingModifier::Declaration:
return OS << "decl"; // abbrevation for common case
+ case HighlightingModifier::Definition:
+ return OS << "def"; // abbrevation for common case
default:
return OS << toSemanticTokenModifier(K);
}
@@ -998,6 +1025,8 @@
switch (Modifier) {
case HighlightingModifier::Declaration:
return "declaration";
+ case HighlightingModifier::Definition:
+ return "definition";
case HighlightingModifier::Deprecated:
return "deprecated";
case HighlightingModifier::Readonly:
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
