[clangd] Improve handling of Objective-C protocols in types

[dgoldman]

Summary

Improve support for Objective-C protocols for types/type locs

[dgoldman]

clang-tools-extra/clangd/FindTarget.cpp

435–441

Let me know if I'm missing something here, not exactly sure what the old comment meant - is there a problem since this ObjCObjectType can refer to multiple protocols?

819

Let me know if you have something else in mind to handle the ObjC case here

917

Doesn't look like that's needed, but if we wanted to decorate the type parameters in ObjCObjectTypeLoc with typeParameter would that just go in SemanticHighlighting.cpp?

[dgoldman]

Friendly ping, not sure if there's something in here and https://reviews.llvm.org/D99975 that I'm missing to properly support the one decl/type loc to multiple references here

[sammccall]

LG apart from a few nits & reverting the whitespace changes to unrelated tests.

clang-tools-extra/clangd/FindTarget.cpp

435–441

Here's the way the AST should ideally look like (and what this comment is wishing for):

ObjCObjectTypeLoc C<Foo>
 - ObjCInterfaceTypeLoc C
 - ObjCProtocolLoc Foo // doesn't actually exist

And targetDecl() would work on the two children, but not the parent.

But there's no AST node for protocols. A piece of cleverness in this patch is getting go-to-definition to work on protocols by saying "if the cursor is on ObjCObjectType itself, then it must be on a protocol rather than the base (otherwise it'd be on the ObjCInterfaceType child)".

But it's a hack, as evidenced by the fact that operations that work on the *range* [[C<Foo>]] will still see the target as <Foo> (literally any of nothing, C, C+Foo would be better).

Nevertheless I think it's probably a net win.

---

Can you leave a comment here like

// There's no child node for just a protocol, so make all the protocols targets.
// But not the base type, which *does* have a child ObjCInterfaceTypeLoc.
// This structure is a hack, but it works well for go-to-definition.

825

this doesn't seem right: we now have a list, the Visit() call may have added things to the list, we need to adjust *all* the added things.

// Add qualifier for the newly-added refs.
for (unsigned I = InitialSize; I < Refs.size(); ++I) {
 // adjust Refs[I]
}

917

That's not something we want to do - ObjCObjectTypeLoc has type arguments, not parameters.
(Not trying to be pedantic with terminology, but the difference is critical here)

e.g. in the function call foo(42) we don't decorate 42 as a parameter, we decorate it as an integer.

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

960–971

can you add a second protocol so we can see the boundaries of this approach?

(I think C<[[Foo]], Bar> should resolve to both @protocol Foo and @protocol Bar)

1048

there are a ton of whitespace changes in this patch, because the version at HEAD isn't clang-format clean :-(

Feel free to format it first in a separate commit, but I'd prefer not to reformat all the tests mixed in with other changes.

[sammccall]

Oops, meant to approve with above comments.

[dgoldman]

Address review comments

[dgoldman]

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

1048

Will do if it hasn't been done already

[dgoldman]

rebase

[dgoldman]

Rebase on top of formatting changes

clang-tools-extra/clangd/FindTarget.cpp

struct Visitor : public TypeVisitor<Visitor> {
       }
       void VisitTemplateTypeParmType(const TemplateTypeParmType *TTPT) {
         Outer.add(TTPT->getDecl(), Flags);
       }
       void VisitObjCInterfaceType(const ObjCInterfaceType *OIT) {
         Outer.add(OIT->getDecl(), Flags);
       }
       void VisitObjCObjectType(const ObjCObjectType *OOT) {
-        // FIXME: ObjCObjectTypeLoc has no children for the protocol list, so
-        // there is no node in id<Foo> that refers to ObjCProtocolDecl Foo.
-        if (OOT->isObjCQualifiedId() && OOT->getNumProtocols() == 1)
-          Outer.add(OOT->getProtocol(0), Flags);
+        // Make all of the protocols targets since there's no child nodes for
+        // protocols. This isn't needed for the base type, which *does* have a
+        // child `ObjCInterfaceTypeLoc`. This structure is a hack, but it works
+        // well for go-to-definition.
+        unsigned NumProtocols = OOT->getNumProtocols();
+        for (unsigned I = 0; I < NumProtocols; I++)
+          Outer.add(OOT->getProtocol(I), Flags);
       }
     };
     Visitor(*this, Flags).Visit(T.getTypePtr());
   }
 
   void add(const NestedNameSpecifier *NNS, RelSet Flags) {
     if (!NNS)
       return;

 }
 
 llvm::SmallVector<ReferenceLoc>
 refInTypeLoc(TypeLoc L, const HeuristicResolver *Resolver) {
   struct Visitor : TypeLocVisitor<Visitor> {
     Visitor(const HeuristicResolver *Resolver) : Resolver(Resolver) {}
 
     const HeuristicResolver *Resolver;
-    llvm::Optional<ReferenceLoc> Ref;
+    llvm::SmallVector<ReferenceLoc> Refs;
 
     void VisitElaboratedTypeLoc(ElaboratedTypeLoc L) {
       // We only know about qualifier, rest if filled by inner locations.
+      size_t InitialSize = Refs.size();
       Visit(L.getNamedTypeLoc().getUnqualifiedLoc());
+      size_t NewSize = Refs.size();
+      // Add qualifier for the newly-added refs.
+      for (unsigned I = InitialSize; I < NewSize; ++I) {
+        ReferenceLoc *Ref = &Refs[I];
         // Fill in the qualifier.
-      if (!Ref)
-        return;
         assert(!Ref->Qualifier.hasQualifier() && "qualifier already set");
         Ref->Qualifier = L.getQualifierLoc();
       }
+    }
 
     void VisitTagTypeLoc(TagTypeLoc L) {
-      Ref = ReferenceLoc{NestedNameSpecifierLoc(),
+      Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
                                   L.getNameLoc(),
                                   /*IsDecl=*/false,
-                         {L.getDecl()}};
+                                  {L.getDecl()}});
     }
 
     void VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc L) {
-      Ref = ReferenceLoc{NestedNameSpecifierLoc(),
+      Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
                                   L.getNameLoc(),
                                   /*IsDecl=*/false,
-                         {L.getDecl()}};
+                                  {L.getDecl()}});
     }
 
     void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc L) {
       // We must ensure template type aliases are included in results if they
       // were written in the source code, e.g. in
       //    template <class T> using valias = vector<T>;
       //    ^valias<int> x;
       // 'explicitReferenceTargets' will return:
       //    1. valias with mask 'Alias'.
       //    2. 'vector<int>' with mask 'Underlying'.
       //  we want to return only #1 in this case.
-      Ref = ReferenceLoc{
+      Refs.push_back(ReferenceLoc{
           NestedNameSpecifierLoc(), L.getTemplateNameLoc(), /*IsDecl=*/false,
           explicitReferenceTargets(DynTypedNode::create(L.getType()),
-                                   DeclRelation::Alias, Resolver)};
+                                   DeclRelation::Alias, Resolver)});
     }
     void VisitDeducedTemplateSpecializationTypeLoc(
         DeducedTemplateSpecializationTypeLoc L) {
-      Ref = ReferenceLoc{
+      Refs.push_back(ReferenceLoc{
           NestedNameSpecifierLoc(), L.getNameLoc(), /*IsDecl=*/false,
           explicitReferenceTargets(DynTypedNode::create(L.getType()),
-                                   DeclRelation::Alias, Resolver)};
+                                   DeclRelation::Alias, Resolver)});
     }
 
     void VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
-      Ref = ReferenceLoc{NestedNameSpecifierLoc(),
+      Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
                                   TL.getNameLoc(),
                                   /*IsDecl=*/false,
-                         {TL.getDecl()}};
+                                  {TL.getDecl()}});
     }
 
     void VisitDependentTemplateSpecializationTypeLoc(
         DependentTemplateSpecializationTypeLoc L) {
-      Ref = ReferenceLoc{L.getQualifierLoc(), L.getTemplateNameLoc(),
-                         /*IsDecl=*/false,
-                         explicitReferenceTargets(
-                             DynTypedNode::create(L.getType()), {}, Resolver)};
+      Refs.push_back(
+          ReferenceLoc{L.getQualifierLoc(), L.getTemplateNameLoc(),
+                           DynTypedNode::create(L.getType()), {}, Resolver)});
     }
 
     void VisitDependentNameTypeLoc(DependentNameTypeLoc L) {
-      Ref = ReferenceLoc{L.getQualifierLoc(), L.getNameLoc(), /*IsDecl=*/false,
-                         explicitReferenceTargets(
-                             DynTypedNode::create(L.getType()), {}, Resolver)};
+      Refs.push_back(
+          ReferenceLoc{L.getQualifierLoc(), L.getNameLoc(),
+                       /*IsDecl=*/false,
+                           DynTypedNode::create(L.getType()), {}, Resolver)});
     }
 
     void VisitTypedefTypeLoc(TypedefTypeLoc L) {
-      Ref = ReferenceLoc{NestedNameSpecifierLoc(),
+      Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
                                   L.getNameLoc(),
                                   /*IsDecl=*/false,
-                         {L.getTypedefNameDecl()}};
+                                  {L.getTypedefNameDecl()}});
     }
 
     void VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc L) {
-      Ref = ReferenceLoc{NestedNameSpecifierLoc(),
+      Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
                                   L.getNameLoc(),
                                   /*IsDecl=*/false,
-                         {L.getIFaceDecl()}};
+                                  {L.getIFaceDecl()}});
     }
 
-    // FIXME: add references to protocols in ObjCObjectTypeLoc and maybe
-    // ObjCObjectPointerTypeLoc.
+    void VisitObjCObjectTypeLoc(ObjCObjectTypeLoc L) {
+      unsigned NumProtocols = L.getNumProtocols();
+      for (unsigned I = 0; I < NumProtocols; I++) {
+        Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
+                                    L.getProtocolLoc(I),
+                                    /*IsDecl=*/false,
+                                    {L.getProtocol(I)}});
+      }
+    }
   };
 
   Visitor V{Resolver};
   V.Visit(L.getUnqualifiedLoc());
-  if (!V.Ref)
-    return {};
-  return {*V.Ref};
+  return V.Refs;
 }
 
 class ExplicitReferenceCollector
     : public RecursiveASTVisitor<ExplicitReferenceCollector> {
 public:
   ExplicitReferenceCollector(llvm::function_ref<void(ReferenceLoc)> Out,
                              const HeuristicResolver *Resolver)
       : Out(Out), Resolver(Resolver) {

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

Code = R"cpp(
     void test([[id<Foo>]] p);
   )cpp";
   EXPECT_DECLS("ObjCObjectTypeLoc", "@protocol Foo");
 
   Code = R"cpp(
     @class C;
     @protocol Foo
     @end
+    void test([[C]]<Foo> *p);
+  )cpp";
+  EXPECT_DECLS("ObjCInterfaceTypeLoc", "@class C;");
+
+  Code = R"cpp(
+    @class C;
+    @protocol Foo
+    @end
     void test(C<[[Foo]]> *p);
   )cpp";
-  // FIXME: there's no AST node corresponding to 'Foo', so we're stuck.
-  EXPECT_DECLS("ObjCObjectTypeLoc");
+  EXPECT_DECLS("ObjCObjectTypeLoc", "@protocol Foo");
+
+  Code = R"cpp(
+    @class C;
+    @protocol Foo
+    @end
+    @protocol Bar
+    @end
+    void test(C<[[Foo]], Bar> *p);
+  )cpp";
+  // FIXME: We currently can't disambiguate between multiple protocols.
+  EXPECT_DECLS("ObjCObjectTypeLoc", "@protocol Foo", "@protocol Bar");
 }
 
 class FindExplicitReferencesTest : public ::testing::Test {
 protected:
   struct AllRefs {
     std::string AnnotatedCode;
     std::string DumpedReferences;
   };
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(
+      {// Simple expressions.
         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"},
-          {R"cpp(
          void foo() {
            $0^ten: // PRINT "HELLO WORLD!"
            goto $1^ten;
          }
        )cpp",
         "0: targets = {ten}, decl\n"
         "1: targets = {ten}\n"},
        // Simple templates.
        {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"
-           "9: targets = {Bar}\n"},
-          // Destructor.
-          {R"cpp(
              void foo() {
                class $0^Foo {
                public:
                  ~$1^Foo() {}
 
                  void $2^destructMe() {
                    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"
-           "7: targets = {Foo}\n"},
-          // cxx constructor initializer.
-          {R"cpp(
              class Base {};
              void foo() {
                // member initializer
                class $0^X {
                  int $1^abc;
                  $2^X(): $3^abc() {}
                };
                // base initializer
                class $4^Derived : public $5^Base {
                  $6^Base $7^B;
                  $8^Derived() : $9^Base() {}
                };
                // 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(
+       {// Objective-C: methods
             @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(
+        "1: targets = {I::a:b:}\n"},
+       {// Objective-C: protocols
             @interface I
             @end
             @protocol P
             @end
             void foo() {
-              // FIXME: should reference P
-              $0^I<P> *$1^x;
+              $0^I<$1^P> *$2^x;
             }
           )cpp",
-              "0: targets = {I}\n"
-              "1: targets = {x}, decl\n"
-          },
+        "1: targets = {P}\n"
+        "2: 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;
               };
               struct $2^Bar {
                 $3^Baz $4^Foo;
               };
               $5^Bar $6^bar { .$7^Foo.$8^Field = 42 };

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

)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]];
+        id<$Interface[[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]])