[clangd] ObjC fixes for semantic highlighting and xref highlights

[sammccall]

Summary

• highlight references to protocols in class/protocol/extension decls
• support multi-token selector highlights in semantic + xref highlights (method calls and declarations only)
• In @interface I(C), I now references the interface and C the category
• highlight uses of interfaces as types
• added semantic highlightings of protocol names (as "interface") and category names (as "namespace"). These are both standard kinds, maybe "extension" will be standardized...
• highlight auto as "class" when it resolves to an ObjC pointer
• don't highlight self as a variable even though the AST models it as one

Not fixed: uses of protocols in type names (needs some refactoring of
unrelated code first)

[sammccall]

(not really sure why this suddenly seemed important to me, but if you don't have semantic highlighting on, you're missing out!)

[dgoldman]

In D97617#2592424, @sammccall wrote:

(not really sure why this suddenly seemed important to me, but if you don't have semantic highlighting on, you're missing out!)

Thanks!

clang-tools-extra/clangd/FindTarget.cpp

657

Should this be isThisDeclarationADefinition()? Is it even needed (will the protocol list just be empty otherwise)?

659

Hmm, for what? might be better to say why/what it does

668

IIRC I think it's possible that these could be NULL if the code was invalid, is this NULL safe?

687–689

Same comments here as the interface code above

775

What is this location used for? I guess it's not possible to have multiple Locs here like we have for a selector and you specifically handle for semantic highlighting below?

clang-tools-extra/clangd/XRefs.cpp

927–930

Hmm, is this intentional? Not sure what else could reference it besides maybe a property?

[sammccall]

address comments

clang-tools-extra/clangd/FindTarget.cpp

657

Indeed it should be isThisDeclarationADefinition().
And I think this is why we need the check - otherwise if this is a forward decl, we'll still traverse the protocols at any visible definition.

(getReferencedProtocols() asserts, and I was calling that at some point, which is why I originially had this check).

659

Changed the comment.

(this walks back up the hierarchy, landing at VisitNamedDecl, which highlights the primary name token)

668

Good point. But checking for nulls is tedious, and guessing which cases can't ever be null is a fool's game. Made it null-safe in https://github.com/llvm/llvm-project/commit/7556abf82137b57be9e32475a1995f936a22cd16 instead.

775

Yup, the abstraction only lets us report one location/token, and it's not worth complicating for one case IMO, so we hack around it at the caller.

There are two ideas for the specific location

• it's a reasonable fallback behavior
• callers that do handle the multi-token case themselves can use this location to match up the overlapping data. (As SemanticTokens does here and DocumentHighlight does too albeit it uses IndexDataConsumer code rather than findExplicitReferences)

Added a comment noting the limitation.

clang-tools-extra/clangd/XRefs.cpp

927–930

I'm not sure either, but IME assuming we've covered every possible case in the AST tends to be a bad idea :-) This is mostly a defensive check (though now you mention it, I suppose property access might hit this.

Note that isa<ObjCMessageExpr>(OrigE) implies we're indexing a message expr, but isa<ObjCMethodDecl>(OrigD) *doesn't* imply we're indexing a method decl! (When indexing a message expr, OrigD is set to the target method, so the order of if/else is significant here).
This makes me feel like it would be quite plausible to go off the rails without this check.

I've tweaked the comments a bit here to reinforce this is a sanity check.

clang-tools-extra/clangd/FindTarget.cpp

 //===--- FindTarget.cpp - What does an AST node refer to? -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "FindTarget.h"
 #include "AST.h"
 #include "HeuristicResolver.h"
 #include "support/Logger.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Decl.h"
+#include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DeclVisitor.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprConcepts.h"
 #include "clang/AST/ExprObjC.h"
struct Visitor : ConstDeclVisitor<Visitor> {
     void VisitCXXDeductionGuideDecl(const CXXDeductionGuideDecl *DG) {
       // The class template name in a deduction guide targets the class
       // template.
       Refs.push_back(ReferenceLoc{DG->getQualifierLoc(),
                                   DG->getNameInfo().getLoc(),
                                   /*IsDecl=*/false,
                                   {DG->getDeducedTemplate()}});
     }
+
+    void VisitObjCMethodDecl(const ObjCMethodDecl *OMD) {
+      // The name may have several tokens, we can only report the first.
+      Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
+                                  OMD->getSelectorStartLoc(),
+                                  /*IsDecl=*/true,
+                                  {OMD}});
+    }
+
+    void visitProtocolList(
+        llvm::iterator_range<ObjCProtocolList::iterator> Protocols,
+        llvm::iterator_range<const SourceLocation *> Locations) {
+      for (const auto &P : llvm::zip(Protocols, Locations)) {
+        Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
+                                    std::get<1>(P),
+                                    /*IsDecl=*/false,
+                                    {std::get<0>(P)}});
+      }
+    }
+
+    void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *OID) {
+      if (OID->isThisDeclarationADefinition())
+        visitProtocolList(OID->protocols(), OID->protocol_locs());
+      Base::VisitObjCInterfaceDecl(OID); // Visit the interface's name.
+    }
+
+    void VisitObjCCategoryDecl(const ObjCCategoryDecl *OCD) {
+      visitProtocolList(OCD->protocols(), OCD->protocol_locs());
+      // getLocation is the extended class's location, not the category's.
+      Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
+                                  OCD->getLocation(),
+                                  /*IsDecl=*/false,
+                                  {OCD->getClassInterface()}});
+      Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
+                                  OCD->getCategoryNameLoc(),
+                                  /*IsDecl=*/true,
+                                  {OCD}});
+    }
+
+    void VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *OCID) {
+      Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
+                                  OCID->getLocation(),
+                                  /*IsDecl=*/false,
+                                  {OCID->getClassInterface()}});
+      Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
+                                  OCID->getCategoryNameLoc(),
+                                  /*IsDecl=*/true,
+                                  {OCID->getCategoryDecl()}});
+    }
+
+    void VisitObjCProtocolDecl(const ObjCProtocolDecl *OPD) {
+      if (OPD->isThisDeclarationADefinition())
+        visitProtocolList(OPD->protocols(), OPD->protocol_locs());
+      Base::VisitObjCProtocolDecl(OPD); // Visit the protocol's name.
+    }
   };
 
   Visitor V{Resolver};
   V.Visit(D);
   return V.Refs;
 }
 
 llvm::SmallVector<ReferenceLoc> refInStmt(const Stmt *S,
struct Visitor : ConstStmtVisitor<Visitor> {
     void VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *E) {
       Refs.push_back(ReferenceLoc{
           NestedNameSpecifierLoc(), E->getLocation(),
           /*IsDecl=*/false,
           // Select the getter, setter, or @property depending on the call.
           explicitReferenceTargets(DynTypedNode::create(*E), {}, Resolver)});
     }
 
+    void VisitObjCMessageExpr(const ObjCMessageExpr *E) {
+      // The name may have several tokens, we can only report the first.
+      Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
+                                  E->getSelectorStartLoc(),
+                                  /*IsDecl=*/false,
+                                  {E->getMethodDecl()}});
+    }
+
     void VisitDesignatedInitExpr(const DesignatedInitExpr *DIE) {
       for (const DesignatedInitExpr::Designator &D : DIE->designators()) {
         if (!D.isFieldDesignator())
           continue;
 
         Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
                                     D.getFieldLoc(),
                                     /*IsDecl=*/false,
struct Visitor : TypeLocVisitor<Visitor> {
     }
 
     void VisitTypedefTypeLoc(TypedefTypeLoc L) {
       Ref = ReferenceLoc{NestedNameSpecifierLoc(),
                          L.getNameLoc(),
                          /*IsDecl=*/false,
                          {L.getTypedefNameDecl()}};
     }
+
+    void VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc L) {
+      Ref = ReferenceLoc{NestedNameSpecifierLoc(),
+                         L.getNameLoc(),
+                         /*IsDecl=*/false,
+                         {L.getIFaceDecl()}};
+    }
+
+    // FIXME: add references to protocols in ObjCObjectTypeLoc and maybe
+    // ObjCObjectPointerTypeLoc.
   };
 
   Visitor V{Resolver};
   V.Visit(L.getUnqualifiedLoc());
   if (!V.Ref)
     return {};
   return {*V.Ref};
 }

clang-tools-extra/clangd/SemanticHighlighting.h

enum class HighlightingKind {
   LocalVariable,
   Parameter,
   Function,
   Method,
   StaticMethod,
   Field,
   StaticField,
   Class,
+  Interface,
   Enum,
   EnumConstant,
   Typedef,
   Type,
   Unknown,
   Namespace,
   TemplateParameter,
   Concept,

clang-tools-extra/clangd/SemanticHighlighting.cpp

 
 namespace clang {
 namespace clangd {
 namespace {
 
 /// Some names are not written in the source code and cannot be highlighted,
 /// e.g. anonymous classes. This function detects those cases.
 bool canHighlightName(DeclarationName Name) {
-  if (Name.getNameKind() == DeclarationName::CXXConstructorName ||
-      Name.getNameKind() == DeclarationName::CXXUsingDirective)
-    return true;
+  switch (Name.getNameKind()) {
+  case DeclarationName::Identifier: {
     auto *II = Name.getAsIdentifierInfo();
     return II && !II->getName().empty();
   }
+  case DeclarationName::CXXConstructorName:
+  case DeclarationName::CXXDestructorName:
+    return true;
+  case DeclarationName::ObjCZeroArgSelector:
+  case DeclarationName::ObjCOneArgSelector:
+  case DeclarationName::ObjCMultiArgSelector:
+    // Multi-arg selectors need special handling, and we handle 0/1 arg
+    // selectors there too.
+    return false;
+  case DeclarationName::CXXConversionFunctionName:
+  case DeclarationName::CXXOperatorName:
+  case DeclarationName::CXXDeductionGuideName:
+  case DeclarationName::CXXLiteralOperatorName:
+  case DeclarationName::CXXUsingDirective:
+    return false;
+  }
+}
 
 llvm::Optional<HighlightingKind> kindForType(const Type *TP);
 llvm::Optional<HighlightingKind> kindForDecl(const NamedDecl *D) {
   if (auto *USD = dyn_cast<UsingShadowDecl>(D)) {
     if (auto *Target = USD->getTargetDecl())
       D = Target;
   }
   if (auto *TD = dyn_cast<TemplateDecl>(D)) {
llvm::Optional<HighlightingKind> kindForDecl(const NamedDecl *D) {
   // `Class` type. The destructor decls are handled in `VisitTagTypeLoc` (we
   // will visit a TypeLoc where the underlying Type is a CXXRecordDecl).
   if (auto *RD = llvm::dyn_cast<RecordDecl>(D)) {
     // We don't want to highlight lambdas like classes.
     if (RD->isLambda())
       return llvm::None;
     return HighlightingKind::Class;
   }
-  if (isa<ClassTemplateDecl>(D) || isa<RecordDecl>(D) ||
-      isa<CXXConstructorDecl>(D))
+  if (isa<ClassTemplateDecl, RecordDecl, CXXConstructorDecl, ObjCInterfaceDecl,
+          ObjCImplementationDecl>(D))
     return HighlightingKind::Class;
+  if (isa<ObjCProtocolDecl>(D))
+    return HighlightingKind::Interface;
+  if (isa<ObjCCategoryDecl>(D))
+    return HighlightingKind::Namespace;
   if (auto *MD = dyn_cast<CXXMethodDecl>(D))
     return MD->isStatic() ? HighlightingKind::StaticMethod
                           : HighlightingKind::Method;
-  if (isa<FieldDecl>(D))
+  if (auto *OMD = dyn_cast<ObjCMethodDecl>(D))
+    return OMD->isClassMethod() ? HighlightingKind::StaticMethod
+                                : HighlightingKind::Method;
+  if (isa<FieldDecl, ObjCPropertyDecl>(D))
     return HighlightingKind::Field;
   if (isa<EnumDecl>(D))
     return HighlightingKind::Enum;
   if (isa<EnumConstantDecl>(D))
     return HighlightingKind::EnumConstant;
   if (isa<ParmVarDecl>(D))
     return HighlightingKind::Parameter;
-  if (auto *VD = dyn_cast<VarDecl>(D))
+  if (auto *VD = dyn_cast<VarDecl>(D)) {
+    if (isa<ImplicitParamDecl>(VD)) // e.g. ObjC Self
+      return llvm::None;
     return VD->isStaticDataMember()
                ? HighlightingKind::StaticField
                : VD->isLocalVarDecl() ? HighlightingKind::LocalVariable
                                       : HighlightingKind::Variable;
+  }
   if (const auto *BD = dyn_cast<BindingDecl>(D))
     return BD->getDeclContext()->isFunctionOrMethod()
                ? HighlightingKind::LocalVariable
                : HighlightingKind::Variable;
   if (isa<FunctionDecl>(D))
     return HighlightingKind::Function;
   if (isa<NamespaceDecl>(D) || isa<NamespaceAliasDecl>(D) ||
       isa<UsingDirectiveDecl>(D))
     return HighlightingKind::Namespace;
   if (isa<TemplateTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
       isa<NonTypeTemplateParmDecl>(D))
     return HighlightingKind::TemplateParameter;
   if (isa<ConceptDecl>(D))
     return HighlightingKind::Concept;
   return llvm::None;
 }
 llvm::Optional<HighlightingKind> kindForType(const Type *TP) {
   if (!TP)
     return llvm::None;
   if (TP->isBuiltinType()) // Builtins are special, they do not have decls.
     return HighlightingKind::Primitive;
   if (auto *TD = dyn_cast<TemplateTypeParmType>(TP))
     return kindForDecl(TD->getDecl());
+  if (isa<ObjCObjectPointerType>(TP))
+    return HighlightingKind::Class;
   if (auto *TD = TP->getAsTagDecl())
     return kindForDecl(TD);
   return llvm::None;
 }
 
 // Whether T is const in a loose sense - is a variable with this type readonly?
 bool isConst(QualType T) {
   if (T.isNull() || T->isDependentType())
if (auto K = kindForType(AT->getDeducedType().getTypePtrOrNull())) {
       auto &Tok = H.addToken(D->getTypeSpecStartLoc(), *K)
                       .addModifier(HighlightingModifier::Deduced);
       if (auto Mod = scopeModifier(AT->getDeducedType().getTypePtrOrNull()))
         Tok.addModifier(*Mod);
     }
     return true;
   }
 
+  // We handle objective-C selectors specially, because one reference can
+  // cover several non-contiguous tokens.
+  void highlightObjCSelector(const ArrayRef<SourceLocation> &Locs, bool Decl,
+                             bool Class) {
+    HighlightingKind Kind =
+        Class ? HighlightingKind::StaticMethod : HighlightingKind::Method;
+    for (SourceLocation Part : Locs) {
+      auto &Tok =
+          H.addToken(Part, Kind).addModifier(HighlightingModifier::ClassScope);
+      if (Decl)
+        Tok.addModifier(HighlightingModifier::Declaration);
+      if (Class)
+        Tok.addModifier(HighlightingModifier::Static);
+    }
+  }
+
+  bool VisitObjCMethodDecl(ObjCMethodDecl *OMD) {
+    llvm::SmallVector<SourceLocation> Locs;
+    OMD->getSelectorLocs(Locs);
+    highlightObjCSelector(Locs, /*Decl=*/true, OMD->isClassMethod());
+    return true;
+  }
+
+  bool VisitObjCMessageExpr(ObjCMessageExpr *OME) {
+    llvm::SmallVector<SourceLocation> Locs;
+    OME->getSelectorLocs(Locs);
+    highlightObjCSelector(Locs, /*Decl=*/false, OME->isClassMessage());
+    return true;
+  }
+
   bool VisitOverloadExpr(OverloadExpr *E) {
     if (!E->decls().empty())
       return true; // handled by findExplicitReferences.
     auto &Tok = H.addToken(E->getNameLoc(), HighlightingKind::Unknown)
                     .addModifier(HighlightingModifier::DependentName);
     if (llvm::isa<UnresolvedMemberExpr>(E))
       Tok.addModifier(HighlightingModifier::ClassScope);
     // other case is UnresolvedLookupExpr, scope is unknown.
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingKind K) {
   case HighlightingKind::StaticMethod:
     return OS << "StaticMethod";
   case HighlightingKind::Field:
     return OS << "Field";
   case HighlightingKind::StaticField:
     return OS << "StaticField";
   case HighlightingKind::Class:
     return OS << "Class";
+  case HighlightingKind::Interface:
+    return OS << "Interface";
   case HighlightingKind::Enum:
     return OS << "Enum";
   case HighlightingKind::EnumConstant:
     return OS << "EnumConstant";
   case HighlightingKind::Typedef:
     return OS << "Typedef";
   case HighlightingKind::Type:
     return OS << "Type";
case HighlightingKind::Method:
     return "method";
   case HighlightingKind::StaticMethod:
     // FIXME: better method with static modifier?
     return "function";
   case HighlightingKind::Field:
     return "property";
   case HighlightingKind::Class:
     return "class";
+  case HighlightingKind::Interface:
+    return "interface";
   case HighlightingKind::Enum:
     return "enum";
   case HighlightingKind::EnumConstant:
     return "enumMember";
   case HighlightingKind::Typedef:
   case HighlightingKind::Type:
     return "type";
   case HighlightingKind::Unknown:

clang-tools-extra/clangd/XRefs.cpp

struct Reference {
     SymbolID Target;
 
     Range range(const SourceManager &SM) const {
       return halfOpenToRange(SM, SpelledTok.range(SM).toCharRange(SM));
     }
   };
 
   ReferenceFinder(const ParsedAST &AST,
-                  const llvm::DenseSet<SymbolID> &TargetIDs)
-      : AST(AST), TargetIDs(TargetIDs) {}
+                  const llvm::DenseSet<SymbolID> &TargetIDs, bool PerToken)
+      : PerToken(PerToken), AST(AST), TargetIDs(TargetIDs) {}
 
   std::vector<Reference> take() && {
     llvm::sort(References, [](const Reference &L, const Reference &R) {
       auto LTok = L.SpelledTok.location();
       auto RTok = R.SpelledTok.location();
       return std::tie(LTok, L.Role) < std::tie(RTok, R.Role);
     });
     // We sometimes see duplicates when parts of the AST get traversed twice.
handleDeclOccurrence(const Decl *D, index::SymbolRoleSet Roles,
                        index::IndexDataConsumer::ASTNodeInfo ASTNode) override {
     const SourceManager &SM = AST.getSourceManager();
     if (!isInsideMainFile(Loc, SM))
       return true;
     SymbolID ID = getSymbolID(D);
     if (!TargetIDs.contains(ID))
       return true;
     const auto &TB = AST.getTokens();
-    Loc = SM.getFileLoc(Loc);
-    if (const auto *Tok = TB.spelledTokenAt(Loc))
+
+    llvm::SmallVector<SourceLocation, 1> Locs;
+    if (PerToken) {
+      // Check whether this is one of the few constructs where the reference
+      // can be split over several tokens.
+      if (auto *OME = llvm::dyn_cast_or_null<ObjCMessageExpr>(ASTNode.OrigE)) {
+        OME->getSelectorLocs(Locs);
+      } else if (auto *OMD =
+                     llvm::dyn_cast_or_null<ObjCMethodDecl>(ASTNode.OrigD)) {
+        OMD->getSelectorLocs(Locs);
+      }
+      // Sanity check: we expect the *first* token to match the reported loc.
+      // Otherwise, maybe it was e.g. some other kind of reference to a Decl.
+      if (!Locs.empty() && Locs.front() != Loc)
+        Locs.clear(); // First token doesn't match, assume our guess was wrong.
+    }
+    if (Locs.empty())
+      Locs.push_back(Loc);
+
+    for (SourceLocation L : Locs) {
+      L = SM.getFileLoc(L);
+      if (const auto *Tok = TB.spelledTokenAt(L))
         References.push_back({*Tok, Roles, ID});
+    }
     return true;
   }
 
 private:
+  bool PerToken; // If true, report 3 references for split ObjC selector names.
   std::vector<Reference> References;
   const ParsedAST &AST;
   const llvm::DenseSet<SymbolID> &TargetIDs;
 };
 
 std::vector<ReferenceFinder::Reference>
-findRefs(const llvm::DenseSet<SymbolID> &IDs, ParsedAST &AST) {
-  ReferenceFinder RefFinder(AST, IDs);
+findRefs(const llvm::DenseSet<SymbolID> &IDs, ParsedAST &AST, bool PerToken) {
+  ReferenceFinder RefFinder(AST, IDs, PerToken);
   index::IndexingOptions IndexOpts;
   IndexOpts.SystemSymbolFilter =
       index::IndexingOptions::SystemSymbolFilterKind::All;
   IndexOpts.IndexFunctionLocals = true;
   IndexOpts.IndexParametersInDeclarations = true;
   IndexOpts.IndexTemplateParameters = true;
   indexTopLevelDecls(AST.getASTContext(), AST.getPreprocessor(),
                      AST.getLocalTopLevelDecls(), RefFinder, IndexOpts);
if (const SelectionTree::Node *N = ST.commonAncestor()) {
           targetDecl(N->ASTNode, Relations, AST.getHeuristicResolver());
       if (!Decls.empty()) {
         // FIXME: we may get multiple DocumentHighlights with the same location
         // and different kinds, deduplicate them.
         llvm::DenseSet<SymbolID> Targets;
         for (const NamedDecl *ND : Decls)
           if (auto ID = getSymbolID(ND))
             Targets.insert(ID);
-        for (const auto &Ref : findRefs(Targets, AST))
+        for (const auto &Ref : findRefs(Targets, AST, /*PerToken=*/true))
           Result.push_back(toHighlight(Ref, SM));
         return true;
       }
       auto ControlFlow = relatedControlFlow(*N);
       if (!ControlFlow.empty()) {
         for (SourceLocation Loc : ControlFlow)
           if (auto Highlight = toHighlight(Loc, AST.getTokens()))
             Result.push_back(std::move(*Highlight));
if (Index) {
                 OverriddenBy.Subjects.insert(ID);
               getOverriddenMethods(CMD, OverriddenMethods);
             }
         }
       }
     }
 
     // We traverse the AST to find references in the main file.
-    auto MainFileRefs = findRefs(Targets, AST);
+    auto MainFileRefs = findRefs(Targets, AST, /*PerToken=*/false);
     // We may get multiple refs with the same location and different Roles, as
     // cross-reference is only interested in locations, we deduplicate them
     // by the location to avoid emitting duplicated locations.
     MainFileRefs.erase(std::unique(MainFileRefs.begin(), MainFileRefs.end(),
                                    [](const ReferenceFinder::Reference &L,
                                       const ReferenceFinder::Reference &R) {
                                      return L.SpelledTok.location() ==
                                             R.SpelledTok.location();

clang-tools-extra/clangd/unittests/FindTargetTests.cpp

for (unsigned I = 0; I < Refs.size(); ++I)
       DumpedReferences += std::string(llvm::formatv("{0}: {1}\n", I, Refs[I]));
 
     return AllRefs{std::move(AnnotatedCode), std::move(DumpedReferences)};
   }
 };
 
 TEST_F(FindExplicitReferencesTest, All) {
   std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
       {
           // Simple expressions.
           {R"cpp(
         int global;
         int func();
         void foo(int param) {
           $0^global = $1^param + $2^func();
         }
         )cpp",
            "0: targets = {global}\n"
            "1: targets = {param}\n"
            "2: targets = {func}\n"},
           {R"cpp(
         struct X { int a; };
         void foo(X x) {
           $0^x.$1^a = 10;
         }
         )cpp",
            "0: targets = {x}\n"
            "1: targets = {X::a}\n"},
           {R"cpp(
         // error-ok: testing with broken code
         int bar();
         int foo() {
           return $0^bar() + $1^bar(42);
         }
         )cpp",
            "0: targets = {bar}\n"
            "1: targets = {bar}\n"},
           // Namespaces and aliases.
           {R"cpp(
           namespace ns {}
           namespace alias = ns;
           void foo() {
             using namespace $0^ns;
             using namespace $1^alias;
           }
         )cpp",
            "0: targets = {ns}\n"
            "1: targets = {alias}\n"},
           // Using declarations.
           {R"cpp(
           namespace ns { int global; }
           void foo() {
             using $0^ns::$1^global;
           }
         )cpp",
            "0: targets = {ns}\n"
            "1: targets = {ns::global}, qualifier = 'ns::'\n"},
           // Simple types.
           {R"cpp(
          struct Struct { int a; };
          using Typedef = int;
          void foo() {
            $0^Struct $1^x;
            $2^Typedef $3^y;
            static_cast<$4^Struct*>(0);
          }
        )cpp",
            "0: targets = {Struct}\n"
            "1: targets = {x}, decl\n"
            "2: targets = {Typedef}\n"
            "3: targets = {y}, decl\n"
            "4: targets = {Struct}\n"},
           // Name qualifiers.
           {R"cpp(
          namespace a { namespace b { struct S { typedef int type; }; } }
          void foo() {
            $0^a::$1^b::$2^S $3^x;
            using namespace $4^a::$5^b;
            $6^S::$7^type $8^y;
          }
         )cpp",
            "0: targets = {a}\n"
            "1: targets = {a::b}, qualifier = 'a::'\n"
            "2: targets = {a::b::S}, qualifier = 'a::b::'\n"
            "3: targets = {x}, decl\n"
            "4: targets = {a}\n"
            "5: targets = {a::b}, qualifier = 'a::'\n"
            "6: targets = {a::b::S}\n"
            "7: targets = {a::b::S::type}, qualifier = 'struct S::'\n"
            "8: targets = {y}, decl\n"},
std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
        {R"cpp(
           template <class T> struct vector { using value_type = T; };
           template <> struct vector<bool> { using value_type = bool; };
           void foo() {
             $0^vector<int> $1^vi;
             $2^vector<bool> $3^vb;
           }
         )cpp",
            "0: targets = {vector<int>}\n"
            "1: targets = {vi}, decl\n"
            "2: targets = {vector<bool>}\n"
            "3: targets = {vb}, decl\n"},
           // Template type aliases.
           {R"cpp(
             template <class T> struct vector { using value_type = T; };
             template <> struct vector<bool> { using value_type = bool; };
             template <class T> using valias = vector<T>;
             void foo() {
               $0^valias<int> $1^vi;
               $2^valias<bool> $3^vb;
             }
           )cpp",
            "0: targets = {valias}\n"
            "1: targets = {vi}, decl\n"
            "2: targets = {valias}\n"
            "3: targets = {vb}, decl\n"},
           // Injected class name.
           {R"cpp(
             namespace foo {
               template <typename $0^T>
               class $1^Bar {
                 ~$2^Bar();
                 void $3^f($4^Bar);
               };
             }
           )cpp",
            "0: targets = {foo::Bar::T}, decl\n"
            "1: targets = {foo::Bar}, decl\n"
            "2: targets = {foo::Bar}\n"
            "3: targets = {foo::Bar::f}, decl\n"
            "4: targets = {foo::Bar}\n"},
           // MemberExpr should know their using declaration.
           {R"cpp(
             struct X { void func(int); };
             struct Y : X {
               using X::func;
             };
             void foo(Y y) {
               $0^y.$1^func(1);
             }
         )cpp",
            "0: targets = {y}\n"
            "1: targets = {Y::func}\n"},
           // DeclRefExpr should know their using declaration.
           {R"cpp(
             namespace ns { void bar(int); }
             using ns::bar;
 
             void foo() {
               $0^bar(10);
             }
         )cpp",
            "0: targets = {bar}\n"},
           // References from a macro.
           {R"cpp(
             #define FOO a
             #define BAR b
 
             void foo(int a, int b) {
               $0^FOO+$1^BAR;
             }
         )cpp",
            "0: targets = {a}\n"
            "1: targets = {b}\n"},
           // No references from implicit nodes.
           {R"cpp(
             struct vector {
               int *begin();
               int *end();
             };
 
             void foo() {
               for (int $0^x : $1^vector()) {
                 $2^x = 10;
               }
             }
         )cpp",
            "0: targets = {x}, decl\n"
            "1: targets = {vector}\n"
            "2: targets = {x}\n"},
 // Handle UnresolvedLookupExpr.
 // FIXME
 // This case fails when expensive checks are enabled.
 // Seems like the order of ns1::func and ns2::func isn't defined.
 #ifndef EXPENSIVE_CHECKS
           {R"cpp(
             namespace ns1 { void func(char*); }
             namespace ns2 { void func(int*); }
             using namespace ns1;
             using namespace ns2;
 
             template <class T>
             void foo(T t) {
               $0^func($1^t);
             }
         )cpp",
            "0: targets = {ns1::func, ns2::func}\n"
            "1: targets = {t}\n"},
 #endif
           // Handle UnresolvedMemberExpr.
           {R"cpp(
             struct X {
               void func(char*);
               void func(int*);
             };
 
             template <class T>
             void foo(X x, T t) {
               $0^x.$1^func($2^t);
             }
         )cpp",
            "0: targets = {x}\n"
            "1: targets = {X::func, X::func}\n"
            "2: targets = {t}\n"},
           // Handle DependentScopeDeclRefExpr.
           {R"cpp(
             template <class T>
             struct S {
               static int value;
             };
 
             template <class T>
             void foo() {
               $0^S<$1^T>::$2^value;
             }
        )cpp",
            "0: targets = {S}\n"
            "1: targets = {T}\n"
            "2: targets = {S::value}, qualifier = 'S<T>::'\n"},
           // Handle CXXDependentScopeMemberExpr.
           {R"cpp(
             template <class T>
             struct S {
               int value;
             };
 
             template <class T>
             void foo(S<T> t) {
               $0^t.$1^value;
             }
        )cpp",
            "0: targets = {t}\n"
            "1: targets = {S::value}\n"},
           // Type template parameters.
           {R"cpp(
             template <class T>
             void foo() {
               static_cast<$0^T>(0);
               $1^T();
               $2^T $3^t;
             }
         )cpp",
            "0: targets = {T}\n"
            "1: targets = {T}\n"
            "2: targets = {T}\n"
            "3: targets = {t}, decl\n"},
           // Non-type template parameters.
           {R"cpp(
             template <int I>
             void foo() {
               int $0^x = $1^I;
             }
         )cpp",
            "0: targets = {x}, decl\n"
            "1: targets = {I}\n"},
           // Template template parameters.
           {R"cpp(
             template <class T> struct vector {};
 
             template <template<class> class TT, template<class> class ...TP>
             void foo() {
               $0^TT<int> $1^x;
               $2^foo<$3^TT>();
               $4^foo<$5^vector>();
               $6^foo<$7^TP...>();
             }
         )cpp",
            "0: targets = {TT}\n"
            "1: targets = {x}, decl\n"
            "2: targets = {foo}\n"
            "3: targets = {TT}\n"
            "4: targets = {foo}\n"
            "5: targets = {vector}\n"
            "6: targets = {foo}\n"
            "7: targets = {TP}\n"},
           // Non-type template parameters with declarations.
           {R"cpp(
             int func();
             template <int(*)()> struct wrapper {};
 
             template <int(*FuncParam)()>
             void foo() {
               $0^wrapper<$1^func> $2^w;
               $3^FuncParam();
             }
         )cpp",
            "0: targets = {wrapper<&func>}\n"
            "1: targets = {func}\n"
            "2: targets = {w}, decl\n"
            "3: targets = {FuncParam}\n"},
           // declaration references.
           {R"cpp(
              namespace ns {}
              class S {};
              void foo() {
                class $0^Foo { $1^Foo(); ~$2^Foo(); int $3^field; };
                int $4^Var;
                enum $5^E { $6^ABC };
                typedef int $7^INT;
                using $8^INT2 = int;
                namespace $9^NS = $10^ns;
              }
            )cpp",
            "0: targets = {Foo}, decl\n"
            "1: targets = {foo()::Foo::Foo}, decl\n"
            "2: targets = {Foo}\n"
            "3: targets = {foo()::Foo::field}, decl\n"
            "4: targets = {Var}, decl\n"
            "5: targets = {E}, decl\n"
            "6: targets = {foo()::ABC}, decl\n"
            "7: targets = {INT}, decl\n"
            "8: targets = {INT2}, decl\n"
            "9: targets = {NS}, decl\n"
            "10: targets = {ns}\n"},
           // User-defined conversion operator.
           {R"cpp(
             void foo() {
                class $0^Bar {};
                class $1^Foo {
                public:
                  // FIXME: This should have only one reference to Bar.
                  $2^operator $3^$4^Bar();
                };
 
                $5^Foo $6^f;
                $7^f.$8^operator $9^Bar();
             }
         )cpp",
            "0: targets = {Bar}, decl\n"
            "1: targets = {Foo}, decl\n"
            "2: targets = {foo()::Foo::operator Bar}, decl\n"
            "3: targets = {Bar}\n"
            "4: targets = {Bar}\n"
            "5: targets = {Foo}\n"
            "6: targets = {f}, decl\n"
            "7: targets = {f}\n"
            "8: targets = {foo()::Foo::operator Bar}\n"
#endif
                    this->~$3^Foo();
                  }
                };
 
                $4^Foo $5^f;
                $6^f.~ /*...*/ $7^Foo();
              }
            )cpp",
            "0: targets = {Foo}, decl\n"
            // FIXME: It's better to target destructor's FunctionDecl instead of
            // the type itself (similar to constructor).
            "1: targets = {Foo}\n"
            "2: targets = {foo()::Foo::destructMe}, decl\n"
            "3: targets = {Foo}\n"
            "4: targets = {Foo}\n"
            "5: targets = {f}, decl\n"
            "6: targets = {f}\n"
#endif
                };
                // delegating initializer
                class $10^Foo {
                  $11^Foo(int);
                  $12^Foo(): $13^Foo(111) {}
                };
              }
            )cpp",
            "0: targets = {X}, decl\n"
            "1: targets = {foo()::X::abc}, decl\n"
            "2: targets = {foo()::X::X}, decl\n"
            "3: targets = {foo()::X::abc}\n"
            "4: targets = {Derived}, decl\n"
            "5: targets = {Base}\n"
            "6: targets = {Base}\n"
            "7: targets = {foo()::Derived::B}, decl\n"
            "8: targets = {foo()::Derived::Derived}, decl\n"
            "9: targets = {Base}\n"
            "10: targets = {Foo}, decl\n"
            "11: targets = {foo()::Foo::Foo}, decl\n"
            "12: targets = {foo()::Foo::Foo}, decl\n"
            "13: targets = {Foo}\n"},
           // Anonymous entities should not be reported.
           {
               R"cpp(
              void foo() {
               class {} $0^x;
               int (*$1^fptr)(int $2^a, int) = nullptr;
              }
            )cpp",
               "0: targets = {x}, decl\n"
               "1: targets = {fptr}, decl\n"
               "2: targets = {a}, decl\n"},
           // Namespace aliases should be handled properly.
           {
               R"cpp(
                 namespace ns { struct Type {}; }
                 namespace alias = ns;
                 namespace rec_alias = alias;
 
                 void foo() {
                   $0^ns::$1^Type $2^a;
                   $3^alias::$4^Type $5^b;
                   $6^rec_alias::$7^Type $8^c;
                 }
            )cpp",
               "0: targets = {ns}\n"
               "1: targets = {ns::Type}, qualifier = 'ns::'\n"
               "2: targets = {a}, decl\n"
               "3: targets = {alias}\n"
               "4: targets = {ns::Type}, qualifier = 'alias::'\n"
               "5: targets = {b}, decl\n"
               "6: targets = {rec_alias}\n"
               "7: targets = {ns::Type}, qualifier = 'rec_alias::'\n"
               "8: targets = {c}, decl\n"},
           // Handle SizeOfPackExpr.
           {
               R"cpp(
                 template <typename... E>
                 void foo() {
                   constexpr int $0^size = sizeof...($1^E);
                 };
             )cpp",
               "0: targets = {size}, decl\n"
               "1: targets = {E}\n"},
           // Class template argument deduction
           {
               R"cpp(
                 template <typename T>
                 struct Test {
                 Test(T);
               };
               void foo() {
                 $0^Test $1^a(5);
               }
             )cpp",
               "0: targets = {Test}\n"
               "1: targets = {a}, decl\n"},
           // Templates
           {R"cpp(
             namespace foo {
               template <typename $0^T>
               class $1^Bar {};
             }
           )cpp",
            "0: targets = {foo::Bar::T}, decl\n"
            "1: targets = {foo::Bar}, decl\n"},
           // Templates
           {R"cpp(
             namespace foo {
               template <typename $0^T>
               void $1^func();
             }
           )cpp",
            "0: targets = {T}, decl\n"
            "1: targets = {foo::func}, decl\n"},
           // Templates
           {R"cpp(
             namespace foo {
               template <typename $0^T>
               $1^T $2^x;
             }
           )cpp",
            "0: targets = {foo::T}, decl\n"
            "1: targets = {foo::T}\n"
            "2: targets = {foo::x}, decl\n"},
           // Templates
           {R"cpp(
             template<typename T> class vector {};
             namespace foo {
               template <typename $0^T>
               using $1^V = $2^vector<$3^T>;
             }
           )cpp",
            "0: targets = {foo::T}, decl\n"
            "1: targets = {foo::V}, decl\n"
            "2: targets = {vector}\n"
            "3: targets = {foo::T}\n"},
           // Concept
           {
               R"cpp(
               template <typename T>
               concept Drawable = requires (T t) { t.draw(); };
 
               namespace foo {
                 template <typename $0^T> requires $1^Drawable<$2^T>
                 void $3^bar($4^T $5^t) {
                   $6^t.$7^draw();
                 }
               }
           )cpp",
               "0: targets = {T}, decl\n"
               "1: targets = {Drawable}\n"
               "2: targets = {T}\n"
               "3: targets = {foo::bar}, decl\n"
               "4: targets = {T}\n"
               "5: targets = {t}, decl\n"
               "6: targets = {t}\n"
               "7: targets = {}\n"},
           // Objective-C: properties
           {
               R"cpp(
             @interface I {}
             @property(retain) I* x;
             @property(retain) I* y;
             @end
             I *f;
             void foo() {
               $0^f.$1^x.$2^y = 0;
             }
           )cpp",
               "0: targets = {f}\n"
               "1: targets = {I::x}\n"
               "2: targets = {I::y}\n"},
           // Objective-C: implicit properties
           {
               R"cpp(
             @interface I {}
             -(I*)x;
             -(void)setY:(I*)y;
             @end
             I *f;
             void foo() {
               $0^f.$1^x.$2^y = 0;
             }
           )cpp",
               "0: targets = {f}\n"
               "1: targets = {I::x}\n"
               "2: targets = {I::setY:}\n"},
+          {
+          // Objective-C: methods
+              R"cpp(
+            @interface I
+              -(void) a:(int)x b:(int)y;
+            @end
+            void foo(I *i) {
+              [$0^i $1^a:1 b:2];
+            }
+          )cpp",
+              "0: targets = {i}\n"
+              "1: targets = {I::a:b:}\n"
+          },
+          {
+          // Objective-C: protocols
+              R"cpp(
+            @interface I
+            @end
+            @protocol P
+            @end
+            void foo() {
+              // FIXME: should reference P
+              $0^I<P> *$1^x;
+            }
+          )cpp",
+              "0: targets = {I}\n"
+              "1: targets = {x}, decl\n"
+          },
+
           // Designated initializers.
           {R"cpp(
             void foo() {
               struct $0^Foo {
                 int $1^Bar;
               };
               $2^Foo $3^f { .$4^Bar = 42 };
             }
         )cpp",
            "0: targets = {Foo}, decl\n"
            "1: targets = {foo()::Foo::Bar}, decl\n"
            "2: targets = {Foo}\n"
            "3: targets = {f}, decl\n"
            "4: targets = {foo()::Foo::Bar}\n"},
           {R"cpp(
             void foo() {
               struct $0^Baz {
                 int $1^Field;

clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp

void checkHighlightings(llvm::StringRef Code,
                                               /*FileContent*/ llvm::StringRef>>
                             AdditionalFiles = {},
                         uint32_t ModifierMask = -1) {
   Annotations Test(Code);
   TestTU TU;
   TU.Code = std::string(Test.code());
 
   TU.ExtraArgs.push_back("-std=c++20");
+  TU.ExtraArgs.push_back("-xobjective-c++");
 
   for (auto File : AdditionalFiles)
     TU.AdditionalFiles.insert({File.first, std::string(File.second)});
   auto AST = TU.build();
   auto Actual = getSemanticHighlightings(AST);
   for (auto &Token : Actual)
     Token.Modifiers &= ModifierMask;
 
)cpp",
       class $Class_decl_abstract[[Abstract]] {
         virtual void $Method_decl_abstract[[pure]]() = 0;
         virtual void $Method_decl[[impl]]();
       };
       )cpp",
       R"cpp(
       <:[deprecated]:> int $Variable_decl_deprecated[[x]];
       )cpp",
+      R"cpp(
+        // ObjC: Classes and methods
+        @class $Class_decl[[Forward]];
+
+        @interface $Class_decl[[Foo]]
+        @end
+        @interface $Class_decl[[Bar]] : $Class[[Foo]]
+        -($Class[[id]]) $Method_decl[[x]]:(int)$Parameter_decl[[a]] $Method_decl[[y]]:(int)$Parameter_decl[[b]];
+        +(void) $StaticMethod_decl_static[[explode]];
+        @end
+        @implementation $Class_decl[[Bar]]
+        -($Class[[id]]) $Method_decl[[x]]:(int)$Parameter_decl[[a]] $Method_decl[[y]]:(int)$Parameter_decl[[b]] {
+          return self;
+        }
+        +(void) $StaticMethod_decl_static[[explode]] {}
+        @end
+
+        void $Function_decl[[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]]
+        @end
+        @protocol $Interface_decl[[Protocol2]] <$Interface[[Protocol]]>
+        @end
+        @interface $Class_decl[[Klass]] <$Interface[[Protocol]]>
+        @end
+        // FIXME: protocol list in ObjCObjectType should be highlighted.
+        id<Protocol> $Variable_decl[[x]];
+      )cpp",
+      R"cpp(
+        // ObjC: Categories
+        @interface $Class_decl[[Foo]]
+        @end
+        @interface $Class[[Foo]]($Namespace_decl[[Bar]])
+        @end
+        @implementation $Class[[Foo]]($Namespace_decl[[Bar]])
+        @end
+      )cpp",
   };
   for (const auto &TestCase : TestCases)
     // Mask off scope modifiers to keep the tests manageable.
     // They're tested separately.
     checkHighlightings(TestCase, {}, ~ScopeModifierMask);
 
   checkHighlightings(R"cpp(
     class $Class_decl[[A]] {

clang-tools-extra/clangd/unittests/XRefsTests.cpp

const char *Tests[] = {
         struct Foo {
           [[~]]Foo() {};
         };
         void foo() {
           Foo f;
           f.[[^~]]Foo();
         }
       )cpp",
+      R"cpp(// ObjC methods with split selectors.
+        @interface Foo
+          +(void) [[x]]:(int)a [[y]]:(int)b;
+        @end
+        @implementation Foo
+          +(void) [[x]]:(int)a [[y]]:(int)b {}
+        @end
+        void go() {
+          [Foo [[x]]:2 [[^y]]:4];
+        }
+      )cpp",
   };
   for (const char *Test : Tests) {
     Annotations T(Test);
-    auto AST = TestTU::withCode(T.code()).build();
+    auto TU = TestTU::withCode(T.code());
+    TU.ExtraArgs.push_back("-xobjective-c++");
+    auto AST = TU.build();
     EXPECT_THAT(findDocumentHighlights(AST, T.point()), HighlightsFrom(T))
         << Test;
   }
 }
 
 TEST(HighlightsTest, ControlFlow) {
   const char *Tests[] = {
       R"cpp(