fix(semantic-tokens): filter ineligible highlight references

.gitignore

@@ -68,8 +68,7 @@ tests/unit/Local/
 .pixi/*
 !.pixi/config.toml
 
-.codex/
+.codex
 .claude/*
 !.claude/CLAUDE.md
 !.claude/commands/
-openspec/

src/feature/semantic_tokens.cpp

@@ -40,6 +40,34 @@ bool is_dependent(const clang::Decl* D) {
     return isa<clang::UnresolvedUsingValueDecl>(D);
 }
 
+/// Whether a declaration name is backed by source text that should be highlighted.
+bool can_highlight_name(clang::DeclarationName name) {
+    switch(name.getNameKind()) {
+        case clang::DeclarationName::Identifier: {
+            auto* info = name.getAsIdentifierInfo();
+            return info && !info->getName().empty();
+        }
+
+        case clang::DeclarationName::CXXConstructorName:
+        case clang::DeclarationName::CXXDestructorName: {
+            return true;
+        }
+
+        case clang::DeclarationName::CXXConversionFunctionName:
+        case clang::DeclarationName::CXXOperatorName:
+        case clang::DeclarationName::CXXDeductionGuideName:
+        case clang::DeclarationName::CXXLiteralOperatorName:
+        case clang::DeclarationName::CXXUsingDirective:
+        case clang::DeclarationName::ObjCZeroArgSelector:
+        case clang::DeclarationName::ObjCOneArgSelector:
+        case clang::DeclarationName::ObjCMultiArgSelector: {
+            return false;
+        }
+    }
+
+    std::unreachable();
+}
+
 /// Returns true if `decl` is considered to be from a default/system library.
 /// This currently checks the systemness of the file by include type, although
 /// different heuristics may be used in the future (e.g. sysroot paths).
@@ -177,6 +205,10 @@ class SemanticTokensCollector : public SemanticVisitor<SemanticTokensCollector>
     void handleDeclOccurrence(const clang::NamedDecl* decl,
                               RelationKind relation,
                               clang::SourceLocation location) {
+        if(relation.isReference() && !can_highlight_name(decl->getDeclName())) {
+            return;
+        }
+
         std::uint32_t modifiers = 0;
         if(relation.is_one_of(RelationKind::Definition)) {
             // todo: clangd add both Declaration and Definition modifiers for definitions.

tests/unit/feature/semantic_tokens_tests.cpp

@@ -138,6 +138,10 @@ void EXPECT_TOKEN(llvm::StringRef name,
     ASSERT_EQ(token->modifiers, expected_modifiers);
 }
 
+void EXPECT_NO_TOKEN(llvm::StringRef name) {
+    ASSERT_TRUE(find_by_range(name) == nullptr);
+}
+
 TEST_CASE(BasicLexicalKinds) {
     run_utf8(R"cpp(
 @d1[#define] @m0[FOO]
@@ -264,6 +268,44 @@ int main() {
     EXPECT_TOKEN("x3", SymbolKind::Variable, 0);
 }
 
+TEST_CASE(IneligibleOperatorReferenceIsSuppressed) {
+    run_utf8(R"cpp(
+struct S {};
+
+S operator+(S lhs, S rhs);
+
+void use(S lhs, S rhs) {
+    (void)(lhs @plus[+] rhs);
+}
+)cpp");
+
+    EXPECT_NO_TOKEN("plus");
+}
+
+TEST_CASE(ConstructorAndDestructorNamesRemainHighlighted) {
+    run_utf8(R"cpp(
+struct S {
+    @ctor_decl[S]();
+    @dtor_decl[~]S();
+};
+
+S::@ctor_def[S]() {}
+
+void use(S* value) {
+    value->@dtor_ref[~]S();
+}
+)cpp");
+
+    auto declaration = modifier_mask({SymbolModifiers::Declaration});
+    auto definition = modifier_mask({SymbolModifiers::Definition});
+    auto special_member = modifier_mask({SymbolModifiers::ConstructorOrDestructor});
+
+    EXPECT_TOKEN("ctor_decl", SymbolKind::Method, declaration | special_member);
+    EXPECT_TOKEN("dtor_decl", SymbolKind::Method, declaration | special_member);
+    EXPECT_TOKEN("ctor_def", SymbolKind::Method, definition | special_member);
+    EXPECT_TOKEN("dtor_ref", SymbolKind::Method, special_member);
+}
+
 TEST_CASE(LegacyVarDeclTemplates) {
     run_utf8(R"cpp(
 extern int @x1[x];