[clangd] Don't set the Underlying bit on targets of UsingDecls.

[hokein]

Summary

With this patch, we don't treat using ns::X as a first-class declaration like using Z = ns::Y, reference to X that goes through this using-decl is considered a direct reference (without the Underlying bit).

Fix the workaround in https://reviews.llvm.org/D87225 and https://reviews.llvm.org/D74054.

[hokein]

clang-tools-extra/clangd/FindTarget.h

112

The previous Alias vs Underlying were pretty nice, but they were not enough to support our non-renaming-alias-underlying case. Looking for the feedback on the API change here.

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

1120

this seems a small regression, I think it is fine.

1130

I think it is an improvement.

[sammccall]

We manage to get rid of a little code here, but we add complexity to an important API, and make... one test better and a few tests worse.
I'd like to get rid of the wart in the code, but the tradeoff doesn't seem completely compelling... going to think about the API here a bit.

clang-tools-extra/clangd/FindTarget.h

112

Inevitably this adds some noise, and the names are less clear (we certainly need to avoid using "alias" to mean two different things, and we should try to avoid negatives that confuse the boolean logic).
We could simplify this at least at query locations by defining Underlying = NonAliasUnderlying | AliasUnderlying, but unfortunately we can't put it in DeclRelation.

The other thing is this isn't complete either, because it doesn't distinguish between renaming and non-renaming Aliases. This is why we have the regression in the testcases.

That this is so verbose is a property of the original design: the idea was "mark this edge as alias->underlying, and apply a bit when that edge is traversed" but of course we decided to signal "the edge is not traversed" too. So if we introduce a new type of edge, we need *two* new bits - one at each end.

I'm trying to think of ideas for improvements without totally ditching the API...

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

1120

I can't follow why this is different from the second case of

TEST_F(TargetDeclTest, UsingDecl), where the usingdecl is not reported at all.

[hokein]

refine the patch based on the offline discussion:

• don't set the Underlying bits for using-declaration's underlying decl.

[hokein]

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

1120

I think you over-look it, the second case of TEST_F(TargetDeclTest, UsingDecl) does report the using-decl.

[sammccall]

LG, thanks for all the iterations here.

I do want to solve the regression but we can land without that.

clang-tools-extra/clangd/FindTarget.cpp

345

maybe a comment here "// no Underlying as this is a non-renaming alias"

357

and here

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

1120

I'd like to make a plan to solve this regression (we can do it here or in a followup patch, happy to hack on that).

What do you think about the following heuristic:

• if go-to-definition yields multiple results
• and a particular result touches the cursor*
• (optional) and that result is marked with Alias
• then drop it from the set

It means we still keep some special-case code, but it's not complex and fairly intuitive I think.

[hokein]

address comments.

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

1120

sounds good. I'd leave it as a follow-up. Added a FIXME.

clang-tools-extra/clangd/FindTarget.h

enum class DeclRelation : unsigned {
   TemplatePattern,
 
   // Alias options apply when the declaration is an alias.
   // e.g. namespace clang { [[StringRef]] S; }
 
   /// This declaration is an alias that was referred to.
   /// e.g. using llvm::StringRef (the UsingDecl directly referenced).
   Alias,
-  /// This is the underlying declaration for an alias, decltype etc.
+
+  /// Underlying declarations for renaming alias (typedef decl, type alias decl)
+  AliasUnderlying,
+  /// Underlying declarations for non-renaming alias, decltype, etc.
   /// e.g. class llvm::StringRef (the underlying declaration referenced).
-  Underlying,
+  NonAliasUnderlying,
+
+  LastKind = NonAliasUnderlying,
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, DeclRelation);
 
 /// Information about a reference written in the source code, independent of the
 /// actual AST node that this reference lives in.
 /// Useful for tools that are source-aware, e.g. refactorings.
 struct ReferenceLoc {
   /// Contains qualifier written in the code, if any, e.g. 'ns::' for 'ns::foo'.

 /// \p Mask should not contain TemplatePattern or TemplateInstantiation.
 llvm::SmallVector<const NamedDecl *, 1>
 explicitReferenceTargets(ast_type_traits::DynTypedNode N,
                          DeclRelationSet Mask);
 
 // Boring implementation details of bitfield.
 
 class DeclRelationSet {
-  using Set = std::bitset<static_cast<unsigned>(DeclRelation::Underlying) + 1>;
+  using Set = std::bitset<static_cast<unsigned>(DeclRelation::LastKind) + 1>;
   Set S;
   DeclRelationSet(Set S) : S(S) {}
 
 public:
   DeclRelationSet() = default;
   DeclRelationSet(DeclRelation R) { S.set(static_cast<unsigned>(R)); }
 
   explicit operator bool() const { return S.any(); }

clang-tools-extra/clangd/FindTarget.cpp

void add(const Decl *Dcl, RelSet Flags) {
     const NamedDecl *D = llvm::dyn_cast_or_null<NamedDecl>(Dcl);
     if (!D)
       return;
     debug(*D, Flags);
     if (const UsingDirectiveDecl *UDD = llvm::dyn_cast<UsingDirectiveDecl>(D))
       D = UDD->getNominatedNamespaceAsWritten();
 
     if (const TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(D)) {
-      add(TND->getUnderlyingType(), Flags | Rel::Underlying);
+      add(TND->getUnderlyingType(), Flags | Rel::AliasUnderlying);
       Flags |= Rel::Alias; // continue with the alias.
     } else if (const UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
       for (const UsingShadowDecl *S : UD->shadows())
-        add(S->getUnderlyingDecl(), Flags | Rel::Underlying);
+        add(S->getUnderlyingDecl(), Flags | Rel::NonAliasUnderlying);
       Flags |= Rel::Alias; // continue with the alias.
     } else if (const auto *NAD = dyn_cast<NamespaceAliasDecl>(D)) {
-      add(NAD->getUnderlyingDecl(), Flags | Rel::Underlying);
+      add(NAD->getUnderlyingDecl(), Flags | Rel::AliasUnderlying);
       Flags |= Rel::Alias; // continue with the alias
     } else if (const UnresolvedUsingValueDecl *UUVD =
                    dyn_cast<UnresolvedUsingValueDecl>(D)) {
       for (const NamedDecl *Target : getMembersReferencedViaDependentName(
                UUVD->getQualifier()->getAsType(),
                [UUVD](ASTContext &) { return UUVD->getNameInfo().getName(); },
                ValueFilter)) {
-        add(Target, Flags | Rel::Underlying);
+        add(Target, Flags | Rel::NonAliasUnderlying);
       }
       Flags |= Rel::Alias; // continue with the alias
     } else if (const UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D)) {
       // Include the using decl, but don't traverse it. This may end up
       // including *all* shadows, which we don't want.
       report(USD->getUsingDecl(), Flags | Rel::Alias);
       // Shadow decls are synthetic and not themselves interesting.
       // Record the underlying decl instead, if allowed.
       D = USD->getTargetDecl();
-      Flags |= Rel::Underlying; // continue with the underlying decl.
+      Flags |= Rel::NonAliasUnderlying; // continue with the underlying decl.
     } else if (const auto *DG = dyn_cast<CXXDeductionGuideDecl>(D)) {
       D = DG->getDeducedTemplate();
     } else if (const ObjCImplementationDecl *IID =
                    dyn_cast<ObjCImplementationDecl>(D)) {
       // Treat ObjC{Interface,Implementation}Decl as if they were a decl/def
       // pair as long as the interface isn't implicit.
       if (const auto *CID = IID->getClassInterface())
         if (const auto *DD = CID->getDefinition())
struct Visitor : public TypeVisitor<Visitor> {
         Outer.add(ET->desugar(), Flags);
       }
 
       void VisitInjectedClassNameType(const InjectedClassNameType *ICNT) {
         Outer.add(ICNT->getDecl(), Flags);
       }
 
       void VisitDecltypeType(const DecltypeType *DTT) {
-        Outer.add(DTT->getUnderlyingType(), Flags | Rel::Underlying);
+        Outer.add(DTT->getUnderlyingType(), Flags | Rel::NonAliasUnderlying);
       }
       void VisitDeducedType(const DeducedType *DT) {
         // FIXME: In practice this doesn't work: the AutoType you find inside
         // TypeLoc never has a deduced type. https://llvm.org/PR42914
-        Outer.add(DT->getDeducedType(), Flags | Rel::Underlying);
+        Outer.add(DT->getDeducedType(), Flags | Rel::NonAliasUnderlying);
       }
       void VisitDeducedTemplateSpecializationType(
           const DeducedTemplateSpecializationType *DTST) {
         // FIXME: This is a workaround for https://llvm.org/PR42914,
         // which is causing DTST->getDeducedType() to be empty. We
         // fall back to the template pattern and miss the instantiation
         // even when it's known in principle. Once that bug is fixed,
         // this method can be removed (the existing handling in
         // VisitDeducedType() is sufficient).
         if (auto *TD = DTST->getTemplateName().getAsTemplateDecl())
           Outer.add(TD->getTemplatedDecl(), Flags | Rel::TemplatePattern);
       }
       void VisitTypedefType(const TypedefType *TT) {
         Outer.add(TT->getDecl(), Flags);
       }
       void
       VisitTemplateSpecializationType(const TemplateSpecializationType *TST) {
         // Have to handle these case-by-case.
 
         // templated type aliases: there's no specialized/instantiated using
         // decl to point to. So try to find a decl for the underlying type
         // (after substitution), and failing that point to the (templated) using
         // decl.
         if (TST->isTypeAlias()) {
-          Outer.add(TST->getAliasedType(), Flags | Rel::Underlying);
+          Outer.add(TST->getAliasedType(), Flags | Rel::AliasUnderlying);
           // Don't *traverse* the alias, which would result in traversing the
           // template of the underlying type.
           Outer.report(
               TST->getTemplateName().getAsTemplateDecl()->getTemplatedDecl(),
               Flags | Rel::Alias | Rel::TemplatePattern);
         }
         // specializations of template template parameters aren't instantiated
         // into decls, so they must refer to the parameter itself.
void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
       Refs.push_back(ReferenceLoc{D->getQualifierLoc(),
                                   D->getIdentLocation(),
                                   /*IsDecl=*/false,
                                   {D->getNominatedNamespaceAsWritten()}});
     }
 
     void VisitUsingDecl(const UsingDecl *D) {
       // "using ns::identifier;" is a non-declaration reference.
-      Refs.push_back(
-          ReferenceLoc{D->getQualifierLoc(), D->getLocation(), /*IsDecl=*/false,
-                       explicitReferenceTargets(DynTypedNode::create(*D),
-                                                DeclRelation::Underlying)});
+      Refs.push_back(ReferenceLoc{
+          D->getQualifierLoc(), D->getLocation(), /*IsDecl=*/false,
+                                   DeclRelation::NonAliasUnderlying)});
     }
 
     void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
       // For namespace alias, "namespace Foo = Target;", we add two references.
       // Add a declaration reference for Foo.
       VisitNamedDecl(D);
       // Add a non-declaration reference for Target.
       Refs.push_back(ReferenceLoc{D->getQualifierLoc(),

 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, DeclRelation R) {
   switch (R) {
 #define REL_CASE(X)                                                            \
   case DeclRelation::X:                                                        \
     return OS << #X;
     REL_CASE(Alias);
-    REL_CASE(Underlying);
+    REL_CASE(NonAliasUnderlying);
+    REL_CASE(AliasUnderlying);
     REL_CASE(TemplateInstantiation);
     REL_CASE(TemplatePattern);
 #undef REL_CASE
   }
   llvm_unreachable("Unhandled DeclRelation enum");
 }
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, DeclRelationSet RS) {
   const char *Sep = "";

clang-tools-extra/clangd/XRefs.cpp

if (const NamedDecl *Def = getDefinition(D))
           AST.getASTContext(), nameLocation(*Def, SM), MainFilePath);
 
     // Record SymbolID for index lookup later.
     if (auto ID = getSymbolID(D))
       ResultIndex[*ID] = Result.size() - 1;
   };
 
   // Emit all symbol locations (declaration or definition) from AST.
-  DeclRelationSet Relations =
-      DeclRelation::TemplatePattern | DeclRelation::Alias;
+  DeclRelationSet Relations = DeclRelation::TemplatePattern |
+                              DeclRelation::Alias |
+                              DeclRelation::NonAliasUnderlying;
   for (const NamedDecl *D :
        getDeclAtPosition(AST, CurLoc, Relations, NodeKind)) {
     // Special case: void foo() ^override: jump to the overridden method.
     if (const auto *CMD = llvm::dyn_cast<CXXMethodDecl>(D)) {
       const InheritableAttr *Attr = D->getAttr<OverrideAttr>();
       if (!Attr)
         Attr = D->getAttr<FinalAttr>();
       if (Attr && TouchedIdentifier &&
for (const NamedDecl *D :
     if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
       if (TouchedIdentifier &&
           D->getLocation() == TouchedIdentifier->location()) {
         AddResultDecl(CTSD->getSpecializedTemplate());
         continue;
       }
     }
 
-    // Give the underlying decl if navigation is triggered on a non-renaming
-    // alias.
-    if (llvm::isa<UsingDecl>(D) || llvm::isa<UnresolvedUsingValueDecl>(D)) {
-      // FIXME: address more complicated cases. TargetDecl(... Underlying) gives
-      // all overload candidates, we only want the targeted one if the cursor is
-      // on an using-alias usage, workround it with getDeclAtPosition.
-      llvm::for_each(
-          getDeclAtPosition(AST, CurLoc, DeclRelation::Underlying, NodeKind),
-          [&](const NamedDecl *UD) { AddResultDecl(UD); });
-      continue;
-    }
-
     // Special case: if the class name is selected, also map Objective-C
     // categories and category implementations back to their class interface.
     //
     // Since `TouchedIdentifier` might refer to the `ObjCCategoryImplDecl`
     // instead of the `ObjCCategoryDecl` we intentionally check the contents
     // of the locs when checking for class name equivalence.
     if (const auto *CD = dyn_cast<ObjCCategoryDecl>(D))
       if (const auto *ID = CD->getClassInterface())
if (auto MacroSID = getSymbolID(Macro->Name, Macro->Info, SM)) {
           Results.References.push_back(std::move(Result));
         }
       }
       Req.IDs.insert(*MacroSID);
     }
   } else {
     // Handle references to Decls.
 
-    DeclRelationSet Relations =
-        DeclRelation::TemplatePattern | DeclRelation::Alias;
-    std::vector<const NamedDecl *> Decls =
-        getDeclAtPosition(AST, *CurLoc, Relations);
-    std::vector<const NamedDecl *> NonrenamingAliasUnderlyingDecls;
-    // If the results include a *non-renaming* alias, get its
-    // underlying decls as well. (See similar logic in locateASTReferent()).
-    for (const NamedDecl *D : Decls) {
-      if (llvm::isa<UsingDecl>(D) || llvm::isa<UnresolvedUsingValueDecl>(D)) {
-        for (const NamedDecl *AD :
-             getDeclAtPosition(AST, *CurLoc, DeclRelation::Underlying))
-          NonrenamingAliasUnderlyingDecls.push_back(AD);
-      }
-    }
-    llvm::copy(NonrenamingAliasUnderlyingDecls, std::back_inserter(Decls));
+    DeclRelationSet Relations = DeclRelation::TemplatePattern |
+                                DeclRelation::Alias |
+                                DeclRelation::NonAliasUnderlying;
+    auto Decls = getDeclAtPosition(AST, *CurLoc, Relations);
 
     // We traverse the AST to find references in the main file.
     auto MainFileRefs = findRefs(Decls, AST);
     // 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,
if (!CurLoc) {
     llvm::consumeError(CurLoc.takeError());
     return {};
   }
 
   std::vector<SymbolDetails> Results;
 
   // We also want the targets of using-decls, so we include
   // DeclRelation::Underlying.
-  DeclRelationSet Relations = DeclRelation::TemplatePattern |
-                              DeclRelation::Alias | DeclRelation::Underlying;
+  DeclRelationSet Relations =
+      DeclRelation::TemplatePattern | DeclRelation::Alias |
+      DeclRelation::NonAliasUnderlying | DeclRelation::AliasUnderlying;
   for (const NamedDecl *D : getDeclAtPosition(AST, *CurLoc, Relations)) {
     SymbolDetails NewSymbol;
     std::string QName = printQualifiedName(*D);
     auto SplitQName = splitQualifiedName(QName);
     NewSymbol.containerName = std::string(SplitQName.first);
     NewSymbol.name = std::string(SplitQName.second);
 
     if (NewSymbol.containerName.empty()) {
auto RecordFromNode =
       [](const SelectionTree::Node *N) -> const CXXRecordDecl * {
     if (!N)
       return nullptr;
 
     // Note: explicitReferenceTargets() will search for both template
     // instantiations and template patterns, and prefer the former if available
     // (generally, one will be available for non-dependent specializations of a
     // class template).
-    auto Decls = explicitReferenceTargets(N->ASTNode, DeclRelation::Underlying);
+    auto Decls =
+        explicitReferenceTargets(N->ASTNode, DeclRelation::NonAliasUnderlying |
+                                                 DeclRelation::AliasUnderlying);
     if (Decls.empty())
       return nullptr;
 
     const NamedDecl *D = Decls[0];
 
     if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
       // If this is a variable, use the type of the variable.
       return VD->getType().getTypePtr()->getAsCXXRecordDecl();

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

namespace foo {
       int f(int);
       int f(char);
     }
     using foo::f;
     int x = [[f]](42);
   )cpp";
   // f(char) is not referenced!
   EXPECT_DECLS("DeclRefExpr", {"using foo::f", Rel::Alias},
-               {"int f(int)", Rel::Underlying});
+               {"int f(int)", Rel::NonAliasUnderlying});
 
   Code = R"cpp(
     namespace foo {
       int f(int);
       int f(char);
     }
     [[using foo::f]];
   )cpp";
   // All overloads are referenced.
   EXPECT_DECLS("UsingDecl", {"using foo::f", Rel::Alias},
-               {"int f(int)", Rel::Underlying},
-               {"int f(char)", Rel::Underlying});
+               {"int f(int)", Rel::NonAliasUnderlying},
+               {"int f(char)", Rel::NonAliasUnderlying});
 
   Code = R"cpp(
     struct X {
       int foo();
     };
     struct Y : X {
       using X::foo;
     };
     int x = Y().[[foo]]();
   )cpp";
   EXPECT_DECLS("MemberExpr", {"using X::foo", Rel::Alias},
-               {"int foo()", Rel::Underlying});
+               {"int foo()", Rel::NonAliasUnderlying});
 
   Code = R"cpp(
       template <typename T>
       struct Base {
         void waldo() {}
       };
       template <typename T>
       struct Derived : Base<T> {
         using Base<T>::[[waldo]];
       };
     )cpp";
   EXPECT_DECLS("UnresolvedUsingValueDecl", {"using Base<T>::waldo", Rel::Alias},
-               {"void waldo()", Rel::Underlying});
+               {"void waldo()", Rel::NonAliasUnderlying});
 }
 
 TEST_F(TargetDeclTest, ConstructorInitList) {
   Code = R"cpp(
     struct X {
       int a;
       X() : [[a]](42) {}
     };
TEST_F(TargetDeclTest, NestedNameSpecifier) {
   EXPECT_DECLS("NestedNameSpecifierLoc", "typename T");
 
   Code = R"cpp(
     namespace a { int x; }
     namespace b = a;
     int y = [[b]]::x;
   )cpp";
   EXPECT_DECLS("NestedNameSpecifierLoc", {"namespace b = a", Rel::Alias},
-               {"namespace a", Rel::Underlying});
+               {"namespace a", Rel::AliasUnderlying});
 }
 
 TEST_F(TargetDeclTest, Types) {
   Code = R"cpp(
     struct X{};
     [[X]] x;
   )cpp";
   EXPECT_DECLS("RecordTypeLoc", "struct X");
 
   Code = R"cpp(
     struct S{};
     typedef S X;
     [[X]] x;
   )cpp";
   EXPECT_DECLS("TypedefTypeLoc", {"typedef S X", Rel::Alias},
-               {"struct S", Rel::Underlying});
+               {"struct S", Rel::AliasUnderlying});
   Code = R"cpp(
     namespace ns { struct S{}; }
     typedef ns::S X;
     [[X]] x;
   )cpp";
   EXPECT_DECLS("TypedefTypeLoc", {"typedef ns::S X", Rel::Alias},
-               {"struct S", Rel::Underlying});
+               {"struct S", Rel::AliasUnderlying});
 
   // FIXME: Auto-completion in a template requires disabling delayed template
   // parsing.
   Flags = {"-fno-delayed-template-parsing"};
   Code = R"cpp(
     template<class T>
     void foo() { [[T]] x; }
   )cpp";
TEST_F(TargetDeclTest, Types) {
   EXPECT_DECLS("TemplateSpecializationTypeLoc", "template <typename> class T");
   Flags.clear();
 
   Code = R"cpp(
     struct S{};
     S X;
     [[decltype]](X) Y;
   )cpp";
-  EXPECT_DECLS("DecltypeTypeLoc", {"struct S", Rel::Underlying});
+  EXPECT_DECLS("DecltypeTypeLoc", {"struct S", Rel::NonAliasUnderlying});
 
   Code = R"cpp(
     struct S{};
     [[auto]] X = S{};
   )cpp";
   // FIXME: deduced type missing in AST. https://llvm.org/PR42914
   EXPECT_DECLS("AutoTypeLoc");
 

 TEST_F(TargetDeclTest, TypeAliasTemplate) {
   Code = R"cpp(
     template<typename T, int X> class SmallVector {};
     template<typename U> using TinyVector = SmallVector<U, 1>;
     [[TinyVector<int>]] X;
   )cpp";
   EXPECT_DECLS("TemplateSpecializationTypeLoc",
                {"template<> class SmallVector<int, 1>",
-                Rel::TemplateInstantiation | Rel::Underlying},
-               {"class SmallVector", Rel::TemplatePattern | Rel::Underlying},
+                Rel::TemplateInstantiation | DeclRelation::AliasUnderlying},
+               {"class SmallVector",
+                Rel::TemplatePattern | DeclRelation::AliasUnderlying},
                {"using TinyVector = SmallVector<U, 1>",
                 Rel::Alias | Rel::TemplatePattern});
 }
 
 TEST_F(TargetDeclTest, MemberOfTemplate) {
   Code = R"cpp(
     template <typename T> struct Foo {
       int x(T);

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

EXPECT_THAT(Results,
                   Sym("uniqueMethodName", Header.range("BarLoc"), llvm::None)));
 }
 
 TEST(LocateSymbol, Alias) {
   const char *Tests[] = {
       R"cpp(
       template <class T> struct function {};
       template <class T> using [[callback]] = function<T()>;
-
       c^allback<int> foo;
     )cpp",
 
       // triggered on non-definition of a renaming alias: should not give any
       // underlying decls.
       R"cpp(
       class Foo {};
       typedef Foo [[Bar]];
)cpp",
       class [[Foo]];
       using Bar = Fo^o;
     )cpp",
 
       // triggered on definition of a non-renaming alias: should give underlying
       // decls.
       R"cpp(
       namespace ns { class [[Foo]] {}; }
-      using ns::F^oo;
+      using ns::[[F^oo]];
     )cpp",
 
       R"cpp(
       namespace ns { int [[x]](char); int [[x]](double); }
-      using ns::^x;
+      using ns::[[^x]];
     )cpp",
 
       R"cpp(
       namespace ns { int [[x]](char); int x(double); }
-      using ns::x;
+      using ns::[[x]];
       int y = ^x('a');
     )cpp",
 
       R"cpp(
       namespace ns { class [[Foo]] {}; }
       using ns::Foo;
       F^oo f;
     )cpp",
)cpp",
       // Member of dependent base
       R"cpp(
       template <typename T>
       struct Base {
         void [[waldo]]() {}
       };
       template <typename T>
       struct Derived : Base<T> {
-        using Base<T>::w^aldo;
+        using Base<T>::[[w^aldo]];
       };
     )cpp",
   };
 
   for (const auto* Case : Tests) {
     SCOPED_TRACE(Case);
     auto T = Annotations(Case);
     auto AST = TestTU::withCode(T.code()).build();