[clang] p1099 1/5: [NFC] Break out BaseUsingDecl from UsingDecl

[urnathan]

Summary

this is a pre-patch for adding using-enum support (https://reviews.llvm.org/D101370) On the ML https://lists.llvm.org/pipermail/cfe-dev/2021-April/068074.html, David Rector suggested breaking out the shadow decl handling of UsingDecl to a new intermediate base class. that's what this patch does, altering the decl hierarchy to:

def ShadowIntroducing : DeclNode<Named, "shadow introducer", 1>;
  def Using : DeclNode<ShadowIntroducing>;
def UsingPack : DeclNode<Named>;
def UsingShadow : DeclNode<Named>;
  def ConstructorUsingShadow : DeclNode<UsingShadow>;

I'll add UsingEnumDecl as a sibling of UsingDecl.

I'm not totally enamoured of the 'ShadowIntroducingDecl' name, but couldn't think of a better one right now.

Have I added this new class correctly? (for avoidance of doubt, I don't intend to commit an approved version of this until the using-enum patch is ready to go).

[davrec]

clang/include/clang/AST/DeclCXX.h

3156–3175

While we're here it would be nice to clarify this documentation, in particular to suggest some ways by which multiple shadows can be introduced by a single using declaration. I suggest:

/// Represents a shadow declaration implicitly introduced into a scope by a
/// (resolved) using-declaration or using-enum-declaration to achieve 
/// the desired lookup semantics.
///
/// For example:
/// \code
/// namespace A {
///   void foo();
///   void foo(int);
///   struct foo {};
///   enum bar { bar1, bar2 };
/// }
/// namespace B {
///   using A::foo; // adds a UsingDecl and three UsingShadowDecls to B.
///   using enum A::bar; // adds UsingEnumDecl and two UsingShadowDecls to B.
/// }
/// \endcode

3253–3256

I agree the names ShadowIntroducingDecl and getShadowIntroducingDecl() feel a bit odd on second thought -- these are always some kind of using declaration, so it would be nice to get the word Using in there. Also the documentation could be improved while we're here.

I would suggest renaming ShadowIntroducingDecl to something like BaseUsingDecl, and either a) leaving this method named getUsingDecl() (which would minimize churn, but could be a bit confusing) or b) rename it to getIntroducer() (which would be more suggestive).

And I would suggest this documentation:

/// Gets the written or instantiated using declaration which introduced this shadow.
BaseUsingDecl *getUsingDecl() const; // or getIntroducer()

[urnathan]

thanks for the feedback. This version uses the different naming and updates documentation.

[bruno]

The approach looks good. There are some test failures - you need to update some bits in clangd and probably anywhere else in the repo that you see uses of getUsingDecl().

[bruno]

You should also update the title with [NFC] or similar.

[urnathan]

Address the build failure --thanks for explaining, it wasn;t clear what else I should try and build. Grepping showed no other getUsingDecl calls. Let's see ...

[urnathan]

I stupidly tested that on the stack, not just the first diff. This removes the reference to bits from a later patch

[urnathan]

unbreaking bot testing of D102241

[urnathan]

rebased onto 3cdd05e519dd, (trying to fix patch 4's precommit failure)

[shafik]

clang/lib/AST/ASTImporter.cpp

4623–4625

It would nice to expand upon the ImportUsingShadowDecl in ASTImporterTest.cpp as we expand this change to make sure the ASTImporter is importing all the cases correctly. Right now we just have a very basic test there.

[urnathan]

clang/lib/AST/ASTImporter.cpp

4623–4625

Please clarify what you are requiring of this patch series. What you describe sounds like an orthogonal desire.

[shafik]

clang/lib/AST/ASTImporter.cpp

4623–4625

Sure, happy to clarify. As the functionality is complete, tests should be added to verify that the ASTImporter correctly deals with the new functionality but it would be nice as we add that new test to also expand the tests further but that would be optional but probably not too much more work.

[urnathan]

clang/lib/AST/ASTImporter.cpp

4623–4625

I've added unit tests for UsingEnumDecl into patch 4, and extended the UsingDecl tests a bit further

[bruno]

LGTM

[davrec]

Sorry for the delay.
Richard should probably weigh in before absolutely committing to

1. BaseUsingDecl/UsingEnumDecl/UsingDecl (as implemented here) vs. single UsingDecl (Nathan's original approach) and
2. Renaming getUsingDecl() to getIntroducer() (if it is to return a BaseUsingDecl).

(Main rationale for separating UsingEnumDecl vs. UsingDecl: parallels the naming distinction in P1099 between a "using-declaration" and a "using-enum-declaration". Cons: churn, adds to quite a collection of Using*-named AST nodes already. Nonetheless I favor distinguishing them.)

clang/include/clang/AST/DeclCXX.h

3390

BaseUsingDecl here should remain UsingDecl.
Additionally, I would add a UsingDecl *getIntroducer() { return cast<UsingDecl>(UsingShadowDecl::getIntroducer()); } method here.

clang/lib/AST/DeclCXX.cpp

3026

With the additional ConstructorUsingShadowDecl::getIntroducer() method suggested elsewhere, the cast won't be necessary here.

[urnathan]

Addressing Davrec's comments

[urnathan]

clang/include/clang/AST/DeclCXX.h

3390

Done, this required a further reordering of class definitions, so that UsingDecl is complete at this point.

[davrec]

Looks good, thanks for doing this!

[yaxunl]

It seems this patch caused build failure:

FAILED: tools/clang/lib/Sema/CMakeFiles/obj.clangSema.dir/SemaDeclCXX.cpp.o
/usr/bin/c++ -DCLANG_ROUND_TRIP_CC1_ARGS=ON -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -DSTDC_CONSTANT_MACROS -DSTDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/clang/lib/Sema -I/buildbot/llvm-project/clang/lib/Sema -I/buildbot/llvm-project/clang/include -Itools/clang/include -Iinclude -I/buildbot/llvm-project/llvm/include -fPIC -fno-semantic-interposition -fvisibility-inlines-hidden -Werror=date-time -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wno-maybe-uninitialized -Wno-noexcept-type -Wdelete-non-virtual-dtor -Wno-comment -Wmisleading-indentation -fdiagnostics-color -ffunction-sections -fdata-sections -fno-common -Woverloaded-virtual -fno-strict-aliasing -O3 -DNDEBUG -fno-exceptions -fno-rtti -UNDEBUG -std=c++14 -MD -MT tools/clang/lib/Sema/CMakeFiles/obj.clangSema.dir/SemaDeclCXX.cpp.o -MF tools/clang/lib/Sema/CMakeFiles/obj.clangSema.dir/SemaDeclCXX.cpp.o.d -o tools/clang/lib/Sema/CMakeFiles/obj.clangSema.dir/SemaDeclCXX.cpp.o -c /buildbot/llvm-project/clang/lib/Sema/SemaDeclCXX.cpp
/buildbot/llvm-project/clang/lib/Sema/SemaDeclCXX.cpp: In member function ‘bool clang::Sema::CheckUsingShadowDecl(clang::BaseUsingDecl*, clang::NamedDecl*, const clang::LookupResult&, clang::UsingShadowDecl*&)’:
/buildbot/llvm-project/clang/lib/Sema/SemaDeclCXX.cpp:11754:10: error: ‘Using’ was not declared in this scope

Diag(Using->getLocation(), diag::err_using_decl_conflict);
     ^~~~~

/buildbot/llvm-project/clang/lib/Sema/SemaDeclCXX.cpp:11754:10: note: suggested alternative: ‘sinl’

Diag(Using->getLocation(), diag::err_using_decl_conflict);
     ^~~~~
     sinl

https://lab.llvm.org/buildbot/#/builders/165/builds/1401

[urnathan]

In D101777#2802669, @yaxunl wrote:

It seems this patch caused build failure:

Yeah, I've pushed a fix -- I'd attached the fix to the wrong diff in the stack :( Should be good now.

clang-tools-extra/clangd/FindTarget.cpp

void add(const Decl *Dcl, RelSet Flags) {
     if (const TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(D)) {
       add(TND->getUnderlyingType(), Flags | Rel::Underlying);
       Flags |= Rel::Alias; // continue with the alias.
     } else if (const UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
       // no Underlying as this is a non-renaming alias.
       for (const UsingShadowDecl *S : UD->shadows())
         add(S->getUnderlyingDecl(), Flags);
       Flags |= Rel::Alias; // continue with the alias.
+    } else if (const UsingEnumDecl *UED = dyn_cast<UsingEnumDecl>(D)) {
+      add(UED->getEnumDecl(), Flags);
+      Flags |= Rel::Alias; // continue with the alias.
     } else if (const auto *NAD = dyn_cast<NamespaceAliasDecl>(D)) {
       add(NAD->getUnderlyingDecl(), Flags | Rel::Underlying);
       Flags |= Rel::Alias; // continue with the alias
     } else if (const UnresolvedUsingValueDecl *UUVD =
                    dyn_cast<UnresolvedUsingValueDecl>(D)) {
       if (Resolver) {
         for (const NamedDecl *Target : Resolver->resolveUsingValueDecl(UUVD)) {
           add(Target, Flags); // no Underlying as this is a non-renaming alias
         }
       }
       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
+      // Include the Introducing decl, but don't traverse it. This may end up
       // including *all* shadows, which we don't want.
-      report(USD->getUsingDecl(), Flags | Rel::Alias);
+      report(USD->getIntroducer(), Flags | Rel::Alias);
       // Shadow decls are synthetic and not themselves interesting.
       // Record the underlying decl instead, if allowed.
       D = USD->getTargetDecl();
     } 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

clang/include/clang/AST/DeclCXX.h

 class CXXIndirectPrimaryBaseSet;
 class CXXMethodDecl;
 class DecompositionDecl;
 class DiagnosticBuilder;
 class FriendDecl;
 class FunctionTemplateDecl;
 class IdentifierInfo;
 class MemberSpecializationInfo;
+class BaseUsingDecl;
 class TemplateDecl;
 class TemplateParameterList;
 class UsingDecl;
 
 /// Represents an access specifier followed by colon ':'.
 ///
 /// An objects of this class represents sugar for the syntactic occurrence
 /// of an access specifier followed by a colon in the list of member
Stmt::const_child_range childrenExpr() const {
     return Stmt::const_child_range(&ExprWithTemporary, &ExprWithTemporary + 1);
   }
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) {
     return K == Decl::LifetimeExtendedTemporary;
   }
 };
 
-/// Represents a shadow declaration introduced into a scope by a
-/// (resolved) using declaration.
+/// Represents a shadow declaration implicitly introduced into a scope by a
+/// (resolved) using-declaration or using-enum-declaration to achieve
+/// the desired lookup semantics.
 ///
-/// For example,
+/// For example:
 /// \code
 /// namespace A {
 ///   void foo();
+///   void foo(int);
+///   struct foo {};
+///   enum bar { bar1, bar2 };
 /// }
 /// namespace B {
-///   using A::foo; // <- a UsingDecl
-///                 // Also creates a UsingShadowDecl for A::foo() in B
+///   // add a UsingDecl and three UsingShadowDecls (named foo) to B.
+///   using A::foo;
+///   // adds UsingEnumDecl and two UsingShadowDecls (named bar1 and bar2) to B.
+///   using enum A::bar;
 /// }
 /// \endcode
 class UsingShadowDecl : public NamedDecl, public Redeclarable<UsingShadowDecl> {
-  friend class UsingDecl;
+  friend class BaseUsingDecl;
 
   /// The referenced declaration.
   NamedDecl *Underlying = nullptr;
 
   /// The using declaration which introduced this decl or the next using
   /// shadow declaration contained in the aforementioned using declaration.
   NamedDecl *UsingOrNextShadow = nullptr;
 
class UsingShadowDecl : public NamedDecl, public Redeclarable<UsingShadowDecl> {
   }
 
   UsingShadowDecl *getMostRecentDeclImpl() override {
     return getMostRecentDecl();
   }
 
 protected:
   UsingShadowDecl(Kind K, ASTContext &C, DeclContext *DC, SourceLocation Loc,
-                  UsingDecl *Using, NamedDecl *Target);
+                  DeclarationName Name, BaseUsingDecl *Introducer,
+                  NamedDecl *Target);
   UsingShadowDecl(Kind K, ASTContext &C, EmptyShell);
 
 public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
   static UsingShadowDecl *Create(ASTContext &C, DeclContext *DC,
-                                 SourceLocation Loc, UsingDecl *Using,
-                                 NamedDecl *Target) {
-    return new (C, DC) UsingShadowDecl(UsingShadow, C, DC, Loc, Using, Target);
+                                 SourceLocation Loc, DeclarationName Name,
+                                 BaseUsingDecl *Introducer, NamedDecl *Target) {
+    return new (C, DC)
+        UsingShadowDecl(UsingShadow, C, DC, Loc, Name, Introducer, Target);
   }
 
   static UsingShadowDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   using redecl_range = redeclarable_base::redecl_range;
   using redecl_iterator = redeclarable_base::redecl_iterator;
 
   using redeclarable_base::redecls_begin;
void setTargetDecl(NamedDecl *ND) {
     assert(ND && "Target decl is null!");
     Underlying = ND;
     // A UsingShadowDecl is never a friend or local extern declaration, even
     // if it is a shadow declaration for one.
     IdentifierNamespace =
         ND->getIdentifierNamespace() &
         ~(IDNS_OrdinaryFriend | IDNS_TagFriend | IDNS_LocalExtern);
   }
 
-  /// Gets the using declaration to which this declaration is tied.
-  UsingDecl *getUsingDecl() const;
+  /// Gets the (written or instantiated) using declaration that introduced this
+  /// declaration.
+  BaseUsingDecl *getIntroducer() const;
 
   /// The next using shadow declaration contained in the shadow decl
   /// chain of the using declaration which introduced this decl.
   UsingShadowDecl *getNextUsingShadowDecl() const {
     return dyn_cast_or_null<UsingShadowDecl>(UsingOrNextShadow);
   }
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) {
     return K == Decl::UsingShadow || K == Decl::ConstructorUsingShadow;
   }
 };
 
+/// Represents a C++ declaration that introduces decls from somewhere else. It
+/// provides a set of the shadow decls so introduced.
+
+class BaseUsingDecl : public NamedDecl {
+  /// The first shadow declaration of the shadow decl chain associated
+  /// with this using declaration.
+  ///
+  /// The bool member of the pair is a bool flag a derived type may use
+  /// (UsingDecl makes use of it).
+  llvm::PointerIntPair<UsingShadowDecl *, 1, bool> FirstUsingShadow;
+
+protected:
+  BaseUsingDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N)
+      : NamedDecl(DK, DC, L, N), FirstUsingShadow(nullptr, 0) {}
+
+private:
+  void anchor() override;
+
+protected:
+  /// A bool flag for use by a derived type
+  bool getShadowFlag() const { return FirstUsingShadow.getInt(); }
+
+  /// A bool flag a derived type may set
+  void setShadowFlag(bool V) { FirstUsingShadow.setInt(V); }
+
+public:
+  friend class ASTDeclReader;
+  friend class ASTDeclWriter;
+
+  /// Iterates through the using shadow declarations associated with
+  /// this using declaration.
+  class shadow_iterator {
+    /// The current using shadow declaration.
+    UsingShadowDecl *Current = nullptr;
+
+  public:
+    using value_type = UsingShadowDecl *;
+    using reference = UsingShadowDecl *;
+    using pointer = UsingShadowDecl *;
+    using iterator_category = std::forward_iterator_tag;
+    using difference_type = std::ptrdiff_t;
+
+    shadow_iterator() = default;
+    explicit shadow_iterator(UsingShadowDecl *C) : Current(C) {}
+
+    reference operator*() const { return Current; }
+    pointer operator->() const { return Current; }
+
+    shadow_iterator &operator++() {
+      Current = Current->getNextUsingShadowDecl();
+      return *this;
+    }
+
+    shadow_iterator operator++(int) {
+      shadow_iterator tmp(*this);
+      ++(*this);
+      return tmp;
+    }
+
+    friend bool operator==(shadow_iterator x, shadow_iterator y) {
+      return x.Current == y.Current;
+    }
+    friend bool operator!=(shadow_iterator x, shadow_iterator y) {
+      return x.Current != y.Current;
+    }
+  };
+
+  using shadow_range = llvm::iterator_range<shadow_iterator>;
+
+  shadow_range shadows() const {
+    return shadow_range(shadow_begin(), shadow_end());
+  }
+
+  shadow_iterator shadow_begin() const {
+    return shadow_iterator(FirstUsingShadow.getPointer());
+  }
+
+  shadow_iterator shadow_end() const { return shadow_iterator(); }
+
+  /// Return the number of shadowed declarations associated with this
+  /// using declaration.
+  unsigned shadow_size() const {
+    return std::distance(shadow_begin(), shadow_end());
+  }
+
+  void addShadowDecl(UsingShadowDecl *S);
+  void removeShadowDecl(UsingShadowDecl *S);
+
+  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
+  static bool classofKind(Kind K) { return K == Using; }
+};
+
 /// Represents a shadow constructor declaration introduced into a
 /// class by a C++11 using-declaration that names a constructor.
 ///
 /// For example:
 /// \code
 /// struct Base { Base(int); };
 /// struct Derived {
 ///    using Base::Base; // creates a UsingDecl and a ConstructorUsingShadowDecl
class ConstructorUsingShadowDecl final : public UsingShadowDecl {
   ConstructorUsingShadowDecl *ConstructedBaseClassShadowDecl = nullptr;
 
   /// \c true if the constructor ultimately named by this using shadow
   /// declaration is within a virtual base class subobject of the class that
   /// contains this declaration.
   unsigned IsVirtual : 1;
 
   ConstructorUsingShadowDecl(ASTContext &C, DeclContext *DC, SourceLocation Loc,
-                             UsingDecl *Using, NamedDecl *Target,
+                             BaseUsingDecl *Using, NamedDecl *Target,
                              bool TargetInVirtualBase)
-      : UsingShadowDecl(ConstructorUsingShadow, C, DC, Loc, Using,
+      : UsingShadowDecl(ConstructorUsingShadow, C, DC, Loc,
+                        Using->getDeclName(), Using,
                         Target->getUnderlyingDecl()),
         NominatedBaseClassShadowDecl(
             dyn_cast<ConstructorUsingShadowDecl>(Target)),
         ConstructedBaseClassShadowDecl(NominatedBaseClassShadowDecl),
         IsVirtual(TargetInVirtualBase) {
     // If we found a constructor that chains to a constructor for a virtual
     // base, we should directly call that virtual base constructor instead.
     // FIXME: This logic belongs in Sema.

 };
 
 /// Represents a C++ using-declaration.
 ///
 /// For example:
 /// \code
 ///    using someNameSpace::someIdentifier;
 /// \endcode
-class UsingDecl : public NamedDecl, public Mergeable<UsingDecl> {
+class UsingDecl : public BaseUsingDecl, public Mergeable<UsingDecl> {
   /// The source location of the 'using' keyword itself.
   SourceLocation UsingLocation;
 
   /// The nested-name-specifier that precedes the name.
   NestedNameSpecifierLoc QualifierLoc;
 
   /// Provides source/type location info for the declaration name
   /// embedded in the ValueDecl base class.
   DeclarationNameLoc DNLoc;
 
-  /// The first shadow declaration of the shadow decl chain associated
-  /// with this using declaration.
-  ///
-  /// The bool member of the pair store whether this decl has the \c typename
-  /// keyword.
-  llvm::PointerIntPair<UsingShadowDecl *, 1, bool> FirstUsingShadow;
-
   UsingDecl(DeclContext *DC, SourceLocation UL,
             NestedNameSpecifierLoc QualifierLoc,
             const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
-    : NamedDecl(Using, DC, NameInfo.getLoc(), NameInfo.getName()),
+      : BaseUsingDecl(Using, DC, NameInfo.getLoc(), NameInfo.getName()),
         UsingLocation(UL), QualifierLoc(QualifierLoc),
-      DNLoc(NameInfo.getInfo()), FirstUsingShadow(nullptr, HasTypenameKeyword) {
+        DNLoc(NameInfo.getInfo()) {
+    setShadowFlag(HasTypenameKeyword);
   }
 
   void anchor() override;
 
 public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
public:
   DeclarationNameInfo getNameInfo() const {
     return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
   }
 
   /// Return true if it is a C++03 access declaration (no 'using').
   bool isAccessDeclaration() const { return UsingLocation.isInvalid(); }
 
   /// Return true if the using declaration has 'typename'.
-  bool hasTypename() const { return FirstUsingShadow.getInt(); }
+  bool hasTypename() const { return getShadowFlag(); }
 
   /// Sets whether the using declaration has 'typename'.
-  void setTypename(bool TN) { FirstUsingShadow.setInt(TN); }
-
-  /// Iterates through the using shadow declarations associated with
-  /// this using declaration.
-  class shadow_iterator {
-    /// The current using shadow declaration.
-    UsingShadowDecl *Current = nullptr;
-
-  public:
-    using value_type = UsingShadowDecl *;
-    using reference = UsingShadowDecl *;
-    using pointer = UsingShadowDecl *;
-    using iterator_category = std::forward_iterator_tag;
-    using difference_type = std::ptrdiff_t;
-
-    shadow_iterator() = default;
-    explicit shadow_iterator(UsingShadowDecl *C) : Current(C) {}
-
-    reference operator*() const { return Current; }
-    pointer operator->() const { return Current; }
-
-    shadow_iterator& operator++() {
-      Current = Current->getNextUsingShadowDecl();
-      return *this;
-    }
-
-    shadow_iterator operator++(int) {
-      shadow_iterator tmp(*this);
-      ++(*this);
-      return tmp;
-    }
-
-    friend bool operator==(shadow_iterator x, shadow_iterator y) {
-      return x.Current == y.Current;
-    }
-    friend bool operator!=(shadow_iterator x, shadow_iterator y) {
-      return x.Current != y.Current;
-    }
-  };
-
-  using shadow_range = llvm::iterator_range<shadow_iterator>;
-
-  shadow_range shadows() const {
-    return shadow_range(shadow_begin(), shadow_end());
-  }
-
-  shadow_iterator shadow_begin() const {
-    return shadow_iterator(FirstUsingShadow.getPointer());
-  }
-
-  shadow_iterator shadow_end() const { return shadow_iterator(); }
-
-  /// Return the number of shadowed declarations associated with this
-  /// using declaration.
-  unsigned shadow_size() const {
-    return std::distance(shadow_begin(), shadow_end());
-  }
-
-  void addShadowDecl(UsingShadowDecl *S);
-  void removeShadowDecl(UsingShadowDecl *S);
+  void setTypename(bool TN) { setShadowFlag(TN); }
 
   static UsingDecl *Create(ASTContext &C, DeclContext *DC,
                            SourceLocation UsingL,
                            NestedNameSpecifierLoc QualifierLoc,
                            const DeclarationNameInfo &NameInfo,
                            bool HasTypenameKeyword);
 
   static UsingDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   SourceRange getSourceRange() const override LLVM_READONLY;
 
   /// Retrieves the canonical declaration of this declaration.
-  UsingDecl *getCanonicalDecl() override { return getFirstDecl(); }
-  const UsingDecl *getCanonicalDecl() const { return getFirstDecl(); }
+  UsingDecl *getCanonicalDecl() override {
+    return cast<UsingDecl>(getFirstDecl());
+  }
+  const UsingDecl *getCanonicalDecl() const {
+    return cast<UsingDecl>(getFirstDecl());
+  }
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == Using; }
 };
 
 /// Represents a pack of using declarations that a single
 /// using-declarator pack-expanded into.
 ///

clang/include/clang/Basic/DeclNodes.td

def Template : DeclNode<Named, "templates", 1>;
     def RedeclarableTemplate : DeclNode<Template, "redeclarable templates", 1>;
       def FunctionTemplate : DeclNode<RedeclarableTemplate>;
       def ClassTemplate : DeclNode<RedeclarableTemplate>;
       def VarTemplate : DeclNode<RedeclarableTemplate>;
       def TypeAliasTemplate : DeclNode<RedeclarableTemplate>;
     def TemplateTemplateParm : DeclNode<Template>;
     def BuiltinTemplate : DeclNode<Template>;
     def Concept : DeclNode<Template>;
-  def Using : DeclNode<Named>;
+  def BaseUsing : DeclNode<Named, "", 1>;
+    def Using : DeclNode<BaseUsing>;
   def UsingPack : DeclNode<Named>;
   def UsingShadow : DeclNode<Named>;
     def ConstructorUsingShadow : DeclNode<UsingShadow>;
   def ObjCMethod : DeclNode<Named, "Objective-C methods">, DeclContext;
   def ObjCContainer : DeclNode<Named, "Objective-C containers", 1>, DeclContext;
     def ObjCCategory : DeclNode<ObjCContainer>;
     def ObjCProtocol : DeclNode<ObjCContainer, "Objective-C protocols">;
     def ObjCInterface : DeclNode<ObjCContainer, "Objective-C interfaces">;

clang/include/clang/Sema/Sema.h

Decl *ActOnNamespaceAliasDef(Scope *CurScope,
                                SourceLocation NamespaceLoc,
                                SourceLocation AliasLoc,
                                IdentifierInfo *Alias,
                                CXXScopeSpec &SS,
                                SourceLocation IdentLoc,
                                IdentifierInfo *Ident);
 
   void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow);
-  bool CheckUsingShadowDecl(UsingDecl *UD, NamedDecl *Target,
+  bool CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Target,
                             const LookupResult &PreviousDecls,
                             UsingShadowDecl *&PrevShadow);
-  UsingShadowDecl *BuildUsingShadowDecl(Scope *S, UsingDecl *UD,
+  UsingShadowDecl *BuildUsingShadowDecl(Scope *S, BaseUsingDecl *BUD,
                                         NamedDecl *Target,
                                         UsingShadowDecl *PrevDecl);
 
   bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
                                    bool HasTypenameKeyword,
                                    const CXXScopeSpec &SS,
                                    SourceLocation NameLoc,
                                    const LookupResult &Previous);

clang/lib/AST/ASTImporter.cpp

ExpectedDecl ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD = nullptr;
   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
     return std::move(Err);
   if (ToD)
     return ToD;
 
-  Expected<UsingDecl *> ToUsingOrErr = import(D->getUsingDecl());
-  if (!ToUsingOrErr)
-    return ToUsingOrErr.takeError();
+  Expected<BaseUsingDecl *> ToIntroducerOrErr = import(D->getIntroducer());
+  if (!ToIntroducerOrErr)
+    return ToIntroducerOrErr.takeError();
 
   Expected<NamedDecl *> ToTargetOrErr = import(D->getTargetDecl());
   if (!ToTargetOrErr)
     return ToTargetOrErr.takeError();
 
   UsingShadowDecl *ToShadow;
   if (GetImportedOrCreateDecl(ToShadow, D, Importer.getToContext(), DC, Loc,
-                              *ToUsingOrErr, *ToTargetOrErr))
+                              Name, *ToIntroducerOrErr, *ToTargetOrErr))
     return ToShadow;
 
   ToShadow->setLexicalDeclContext(LexicalDC);
   ToShadow->setAccess(D->getAccess());
 
   if (UsingShadowDecl *FromPattern =
       Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
     if (Expected<UsingShadowDecl *> ToPatternOrErr = import(FromPattern))

clang/lib/AST/DeclCXX.cpp

APValue *LifetimeExtendedTemporaryDecl::getOrCreateValue(bool MayCreate) const {
   }
   assert(Value && "may not be null");
   return Value;
 }
 
 void UsingShadowDecl::anchor() {}
 
 UsingShadowDecl::UsingShadowDecl(Kind K, ASTContext &C, DeclContext *DC,
-                                 SourceLocation Loc, UsingDecl *Using,
-                                 NamedDecl *Target)
-    : NamedDecl(K, DC, Loc, Using ? Using->getDeclName() : DeclarationName()),
-      redeclarable_base(C), UsingOrNextShadow(cast<NamedDecl>(Using)) {
+                                 SourceLocation Loc, DeclarationName Name,
+                                 BaseUsingDecl *Introducer, NamedDecl *Target)
+    : NamedDecl(K, DC, Loc, Name), redeclarable_base(C),
+      UsingOrNextShadow(Introducer) {
   if (Target)
     setTargetDecl(Target);
   setImplicit();
 }
 
 UsingShadowDecl::UsingShadowDecl(Kind K, ASTContext &C, EmptyShell Empty)
     : NamedDecl(K, nullptr, SourceLocation(), DeclarationName()),
       redeclarable_base(C) {}
 
 UsingShadowDecl *
 UsingShadowDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID) UsingShadowDecl(UsingShadow, C, EmptyShell());
 }
 
-UsingDecl *UsingShadowDecl::getUsingDecl() const {
+BaseUsingDecl *UsingShadowDecl::getIntroducer() const {
   const UsingShadowDecl *Shadow = this;
   while (const auto *NextShadow =
              dyn_cast<UsingShadowDecl>(Shadow->UsingOrNextShadow))
     Shadow = NextShadow;
-  return cast<UsingDecl>(Shadow->UsingOrNextShadow);
+  return cast<BaseUsingDecl>(Shadow->UsingOrNextShadow);
 }
 
 void ConstructorUsingShadowDecl::anchor() {}
 
 ConstructorUsingShadowDecl *
 ConstructorUsingShadowDecl::Create(ASTContext &C, DeclContext *DC,
                                    SourceLocation Loc, UsingDecl *Using,
                                    NamedDecl *Target, bool IsVirtual) {
   return new (C, DC) ConstructorUsingShadowDecl(C, DC, Loc, Using, Target,
                                                 IsVirtual);
 }
 
 ConstructorUsingShadowDecl *
 ConstructorUsingShadowDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID) ConstructorUsingShadowDecl(C, EmptyShell());
 }
 
 CXXRecordDecl *ConstructorUsingShadowDecl::getNominatedBaseClass() const {
-  return getUsingDecl()->getQualifier()->getAsRecordDecl();
+  return cast<UsingDecl>(getIntroducer())->getQualifier()->getAsRecordDecl();
 }
 
-void UsingDecl::anchor() {}
+void BaseUsingDecl::anchor() {}
 
-void UsingDecl::addShadowDecl(UsingShadowDecl *S) {
+void BaseUsingDecl::addShadowDecl(UsingShadowDecl *S) {
   assert(std::find(shadow_begin(), shadow_end(), S) == shadow_end() &&
          "declaration already in set");
-  assert(S->getUsingDecl() == this);
+  assert(S->getIntroducer() == this);
 
   if (FirstUsingShadow.getPointer())
     S->UsingOrNextShadow = FirstUsingShadow.getPointer();
   FirstUsingShadow.setPointer(S);
 }
 
-void UsingDecl::removeShadowDecl(UsingShadowDecl *S) {
+void BaseUsingDecl::removeShadowDecl(UsingShadowDecl *S) {
   assert(std::find(shadow_begin(), shadow_end(), S) != shadow_end() &&
          "declaration not in set");
-  assert(S->getUsingDecl() == this);
+  assert(S->getIntroducer() == this);
 
   // Remove S from the shadow decl chain. This is O(n) but hopefully rare.
 
   if (FirstUsingShadow.getPointer() == S) {
     FirstUsingShadow.setPointer(
       dyn_cast<UsingShadowDecl>(S->UsingOrNextShadow));
     S->UsingOrNextShadow = this;
     return;
   }
 
   UsingShadowDecl *Prev = FirstUsingShadow.getPointer();
   while (Prev->UsingOrNextShadow != S)
     Prev = cast<UsingShadowDecl>(Prev->UsingOrNextShadow);
   Prev->UsingOrNextShadow = S->UsingOrNextShadow;
   S->UsingOrNextShadow = this;
 }
 
+void UsingDecl::anchor() {}
+
 UsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation UL,
                              NestedNameSpecifierLoc QualifierLoc,
                              const DeclarationNameInfo &NameInfo,
                              bool HasTypename) {
   return new (C, DC) UsingDecl(DC, UL, QualifierLoc, NameInfo, HasTypename);
 }
 
 UsingDecl *UsingDecl::CreateDeserialized(ASTContext &C, unsigned ID) {

clang/lib/CodeGen/CGDebugInfo.h

public:
   void EmitUsingDirective(const UsingDirectiveDecl &UD);
 
   /// Emit the type explicitly casted to.
   void EmitExplicitCastType(QualType Ty);
 
   /// Emit the type even if it might not be used.
   void EmitAndRetainType(QualType Ty);
 
+  /// Emit a shadow decl brought in by a using or using-enum
+  void EmitUsingShadowDecl(const UsingShadowDecl &USD);
+
   /// Emit C++ using declaration.
   void EmitUsingDecl(const UsingDecl &UD);
 
   /// Emit an @import declaration.
   void EmitImportDecl(const ImportDecl &ID);
 
   /// Emit C++ namespace alias.
   llvm::DIImportedEntity *EmitNamespaceAlias(const NamespaceAliasDecl &NA);

clang/lib/CodeGen/CGDebugInfo.cpp

if (!NSDecl->isAnonymousNamespace() ||
     if (!Loc.isValid())
       Loc = CurLoc;
     DBuilder.createImportedModule(
         getCurrentContextDescriptor(cast<Decl>(UD.getDeclContext())),
         getOrCreateNamespace(NSDecl), getOrCreateFile(Loc), getLineNumber(Loc));
   }
 }
 
+void CGDebugInfo::EmitUsingShadowDecl(const UsingShadowDecl &USD) {
+  if (llvm::DINode *Target =
+          getDeclarationOrDefinition(USD.getUnderlyingDecl())) {
+    auto Loc = USD.getLocation();
+    DBuilder.createImportedDeclaration(
+        getCurrentContextDescriptor(cast<Decl>(USD.getDeclContext())), Target,
+        getOrCreateFile(Loc), getLineNumber(Loc));
+  }
+}
+
 void CGDebugInfo::EmitUsingDecl(const UsingDecl &UD) {
   if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
     return;
   assert(UD.shadow_size() &&
          "We shouldn't be codegening an invalid UsingDecl containing no decls");
-  // Emitting one decl is sufficient - debuggers can detect that this is an
-  // overloaded name & provide lookup for all the overloads.
-  const UsingShadowDecl &USD = **UD.shadow_begin();
 
+  for (const auto *USD : UD.shadows()) {
     // FIXME: Skip functions with undeduced auto return type for now since we
     // don't currently have the plumbing for separate declarations & definitions
     // of free functions and mismatched types (auto in the declaration, concrete
     // return type in the definition)
-  if (const auto *FD = dyn_cast<FunctionDecl>(USD.getUnderlyingDecl()))
-    if (const auto *AT =
-            FD->getType()->castAs<FunctionProtoType>()->getContainedAutoType())
+    if (const auto *FD = dyn_cast<FunctionDecl>(USD->getUnderlyingDecl()))
+      if (const auto *AT = FD->getType()
+                               ->castAs<FunctionProtoType>()
+                               ->getContainedAutoType())
         if (AT->getDeducedType().isNull())
-        return;
-  if (llvm::DINode *Target =
-          getDeclarationOrDefinition(USD.getUnderlyingDecl())) {
-    auto Loc = USD.getLocation();
-    DBuilder.createImportedDeclaration(
-        getCurrentContextDescriptor(cast<Decl>(USD.getDeclContext())), Target,
-        getOrCreateFile(Loc), getLineNumber(Loc));
+          continue;
+
+    EmitUsingShadowDecl(*USD);
+    // Emitting one decl is sufficient - debuggers can detect that this is an
+    // overloaded name & provide lookup for all the overloads.
+    break;
   }
 }
 
 void CGDebugInfo::EmitImportDecl(const ImportDecl &ID) {
   if (CGM.getCodeGenOpts().getDebuggerTuning() != llvm::DebuggerKind::LLDB)
     return;
   if (Module *M = ID.getImportedModule()) {
     auto Info = ASTSourceDescriptor(*M);

clang/lib/Sema/SemaAccess.cpp

 ///   };
 ///
 /// Here, B::f is private so this should fail in Standard C++, but
 /// because B::f refers to A::f which is public MSVC accepts it.
 static bool IsMicrosoftUsingDeclarationAccessBug(Sema& S,
                                                  SourceLocation AccessLoc,
                                                  AccessTarget &Entity) {
   if (UsingShadowDecl *Shadow =
-                         dyn_cast<UsingShadowDecl>(Entity.getTargetDecl())) {
+          dyn_cast<UsingShadowDecl>(Entity.getTargetDecl()))
+    if (UsingDecl *UD = dyn_cast<UsingDecl>(Shadow->getIntroducer())) {
       const NamedDecl *OrigDecl = Entity.getTargetDecl()->getUnderlyingDecl();
       if (Entity.getTargetDecl()->getAccess() == AS_private &&
           (OrigDecl->getAccess() == AS_public ||
            OrigDecl->getAccess() == AS_protected)) {
         S.Diag(AccessLoc, diag::ext_ms_using_declaration_inaccessible)
-        << Shadow->getUsingDecl()->getQualifiedNameAsString()
+            << UD->getQualifiedNameAsString()
             << OrigDecl->getQualifiedNameAsString();
         return true;
       }
     }
   return false;
 }
 
 /// Determines whether the accessed entity is accessible.  Public members
 /// have been weeded out by this point.
 static AccessResult IsAccessible(Sema &S,
                                  const EffectiveContext &EC,
                                  AccessTarget &Entity) {

clang/lib/Sema/SemaDecl.cpp

if (Old &&
       !Old->getDeclContext()->getRedeclContext()->Equals(
           New->getDeclContext()->getRedeclContext()) &&
       !(isExternC(Old) && isExternC(New)))
     Old = nullptr;
 
   if (!Old) {
     S.Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
     S.Diag(OldS->getTargetDecl()->getLocation(), diag::note_using_decl_target);
-    S.Diag(OldS->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
+    S.Diag(OldS->getIntroducer()->getLocation(), diag::note_using_decl) << 0;
     return true;
   }
   return false;
 }
 
 static bool hasIdenticalPassObjectSizeAttrs(const FunctionDecl *A,
                                             const FunctionDecl *B) {
   assert(A->getNumParams() == B->getNumParams());
bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD,
   // Verify the old decl was also a function.
   FunctionDecl *Old = OldD->getAsFunction();
   if (!Old) {
     if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
       if (New->getFriendObjectKind()) {
         Diag(New->getLocation(), diag::err_using_decl_friend);
         Diag(Shadow->getTargetDecl()->getLocation(),
              diag::note_using_decl_target);
-        Diag(Shadow->getUsingDecl()->getLocation(),
-             diag::note_using_decl) << 0;
+        Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
+            << 0;
         return true;
       }
 
       // Check whether the two declarations might declare the same function.
       if (checkUsingShadowRedecl<FunctionDecl>(*this, Shadow, New))
         return true;
       OldD = Old = cast<FunctionDecl>(Shadow->getTargetDecl());
     } else {
if (auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
       auto *OldTag = dyn_cast<TagDecl>(PrevDecl);
       if (SS.isEmpty() && TUK != TUK_Reference && TUK != TUK_Friend &&
           isDeclInScope(Shadow, SearchDC, S, isMemberSpecialization) &&
           !(OldTag && isAcceptableTagRedeclContext(
                           *this, OldTag->getDeclContext(), SearchDC))) {
         Diag(KWLoc, diag::err_using_decl_conflict_reverse);
         Diag(Shadow->getTargetDecl()->getLocation(),
              diag::note_using_decl_target);
-        Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl)
+        Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl)
             << 0;
         // Recover by ignoring the old declaration.
         Previous.clear();
         goto CreateNewDecl;
       }
     }
 
     if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {

clang/lib/Sema/SemaDeclCXX.cpp

llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>
       InheritedFromBases;
 
 public:
   InheritedConstructorInfo(Sema &S, SourceLocation UseLoc,
                            ConstructorUsingShadowDecl *Shadow)
       : S(S), UseLoc(UseLoc) {
     bool DiagnosedMultipleConstructedBases = false;
     CXXRecordDecl *ConstructedBase = nullptr;
-    UsingDecl *ConstructedBaseUsing = nullptr;
+    BaseUsingDecl *ConstructedBaseIntroducer = nullptr;
 
     // Find the set of such base class subobjects and check that there's a
     // unique constructed subobject.
     for (auto *D : Shadow->redecls()) {
       auto *DShadow = cast<ConstructorUsingShadowDecl>(D);
       auto *DNominatedBase = DShadow->getNominatedBaseClass();
       auto *DConstructedBase = DShadow->getConstructedBaseClass();
 
       InheritedFromBases.insert(
           std::make_pair(DNominatedBase->getCanonicalDecl(),
                          DShadow->getNominatedBaseClassShadowDecl()));
       if (DShadow->constructsVirtualBase())
         InheritedFromBases.insert(
             std::make_pair(DConstructedBase->getCanonicalDecl(),
                            DShadow->getConstructedBaseClassShadowDecl()));
       else
         assert(DNominatedBase == DConstructedBase);
 
       // [class.inhctor.init]p2:
       //   If the constructor was inherited from multiple base class subobjects
       //   of type B, the program is ill-formed.
       if (!ConstructedBase) {
         ConstructedBase = DConstructedBase;
-        ConstructedBaseUsing = D->getUsingDecl();
+        ConstructedBaseIntroducer = D->getIntroducer();
       } else if (ConstructedBase != DConstructedBase &&
                  !Shadow->isInvalidDecl()) {
         if (!DiagnosedMultipleConstructedBases) {
           S.Diag(UseLoc, diag::err_ambiguous_inherited_constructor)
               << Shadow->getTargetDecl();
-          S.Diag(ConstructedBaseUsing->getLocation(),
+          S.Diag(ConstructedBaseIntroducer->getLocation(),
                  diag::note_ambiguous_inherited_constructor_using)
               << ConstructedBase;
           DiagnosedMultipleConstructedBases = true;
         }
-        S.Diag(D->getUsingDecl()->getLocation(),
+        S.Diag(D->getIntroducer()->getLocation(),
                diag::note_ambiguous_inherited_constructor_using)
             << DConstructedBase;
       }
     }
 
     if (DiagnosedMultipleConstructedBases)
       Shadow->setInvalidDecl();
   }
if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(D2))
                                  TD2->getUnderlyingType());
 
   return false;
 }
 
 
 /// Determines whether to create a using shadow decl for a particular
 /// decl, given the set of decls existing prior to this using lookup.
-bool Sema::CheckUsingShadowDecl(UsingDecl *Using, NamedDecl *Orig,
+bool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig,
                                 const LookupResult &Previous,
                                 UsingShadowDecl *&PrevShadow) {
   // Diagnose finding a decl which is not from a base class of the
   // current class.  We do this now because there are cases where this
   // function will silently decide not to build a shadow decl, which
   // will pre-empt further diagnostics.
   //
   // We don't need to do this in C++11 because we do the check once on
   // the qualifier.
   //
   // FIXME: diagnose the following if we care enough:
   //   struct A { int foo; };
   //   struct B : A { using A::foo; };
   //   template <class T> struct C : A {};
   //   template <class T> struct D : C<T> { using B::foo; } // <---
   // This is invalid (during instantiation) in C++03 because B::foo
   // resolves to the using decl in B, which is not a base class of D<T>.
   // We can't diagnose it immediately because C<T> is an unknown
   // specialization.  The UsingShadowDecl in D<T> then points directly
   // to A::foo, which will look well-formed when we instantiate.
   // The right solution is to not collapse the shadow-decl chain.
-  if (!getLangOpts().CPlusPlus11 && CurContext->isRecord()) {
+  if (!getLangOpts().CPlusPlus11 && CurContext->isRecord())
+    if (auto *Using = dyn_cast<UsingDecl>(BUD)) {
       DeclContext *OrigDC = Orig->getDeclContext();
 
       // Handle enums and anonymous structs.
-    if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent();
+      if (isa<EnumDecl>(OrigDC))
+        OrigDC = OrigDC->getParent();
       CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
       while (OrigRec->isAnonymousStructOrUnion())
         OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
 
       if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
         if (OrigDC == CurContext) {
           Diag(Using->getLocation(),
                diag::err_using_decl_nested_name_specifier_is_current_class)
               << Using->getQualifierLoc().getSourceRange();
           Diag(Orig->getLocation(), diag::note_using_decl_target);
           Using->setInvalidDecl();
           return true;
         }
 
         Diag(Using->getQualifierLoc().getBeginLoc(),
              diag::err_using_decl_nested_name_specifier_is_not_base_class)
-        << Using->getQualifier()
-        << cast<CXXRecordDecl>(CurContext)
+            << Using->getQualifier() << cast<CXXRecordDecl>(CurContext)
             << Using->getQualifierLoc().getSourceRange();
         Diag(Orig->getLocation(), diag::note_using_decl_target);
         Using->setInvalidDecl();
         return true;
       }
     }
 
   if (Previous.empty()) return false;
 
   NamedDecl *Target = Orig;
   if (isa<UsingShadowDecl>(Target))
     Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
 
   // If the target happens to be one of the previous declarations, we
if (auto *RD = dyn_cast<CXXRecordDecl>(D)) {
       // C++ [class.mem]p19:
       //   If T is the name of a class, then [every named member other than
       //   a non-static data member] shall have a name different from T
       if (RD->isInjectedClassName() && !isa<FieldDecl>(Target) &&
           !isa<IndirectFieldDecl>(Target) &&
           !isa<UnresolvedUsingValueDecl>(Target) &&
           DiagnoseClassNameShadow(
               CurContext,
-              DeclarationNameInfo(Using->getDeclName(), Using->getLocation())))
+              DeclarationNameInfo(BUD->getDeclName(), BUD->getLocation())))
         return true;
     }
 
     if (IsEquivalentForUsingDecl(Context, D, Target)) {
       if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(*I))
         PrevShadow = Shadow;
       FoundEquivalentDecl = true;
     } else if (isEquivalentInternalLinkageDeclaration(D, Target)) {
bool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig,
   if (FunctionDecl *FD = Target->getAsFunction()) {
     NamedDecl *OldDecl = nullptr;
     switch (CheckOverload(nullptr, FD, Previous, OldDecl,
                           /*IsForUsingDecl*/ true)) {
     case Ovl_Overload:
       return false;
 
     case Ovl_NonFunction:
-      Diag(Using->getLocation(), diag::err_using_decl_conflict);
+      Diag(BUD->getLocation(), diag::err_using_decl_conflict);
       break;
 
     // We found a decl with the exact signature.
     case Ovl_Match:
       // If we're in a record, we want to hide the target, so we
       // return true (without a diagnostic) to tell the caller not to
       // build a shadow decl.
       if (CurContext->isRecord())
         return true;
 
       // If we're not in a record, this is an error.
-      Diag(Using->getLocation(), diag::err_using_decl_conflict);
+      Diag(BUD->getLocation(), diag::err_using_decl_conflict);
       break;
     }
 
     Diag(Target->getLocation(), diag::note_using_decl_target);
     Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
-    Using->setInvalidDecl();
+    BUD->setInvalidDecl();
     return true;
   }
 
   // Target is not a function.
 
   if (isa<TagDecl>(Target)) {
     // No conflict between a tag and a non-tag.
     if (!Tag) return false;
 
-    Diag(Using->getLocation(), diag::err_using_decl_conflict);
+    Diag(BUD->getLocation(), diag::err_using_decl_conflict);
     Diag(Target->getLocation(), diag::note_using_decl_target);
     Diag(Tag->getLocation(), diag::note_using_decl_conflict);
-    Using->setInvalidDecl();
+    BUD->setInvalidDecl();
     return true;
   }
 
   // No conflict between a tag and a non-tag.
   if (!NonTag) return false;
 
-  Diag(Using->getLocation(), diag::err_using_decl_conflict);
+  Diag(BUD->getLocation(), diag::err_using_decl_conflict);
   Diag(Target->getLocation(), diag::note_using_decl_target);
   Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
-  Using->setInvalidDecl();
+  BUD->setInvalidDecl();
   return true;
 }
 
 /// Determine whether a direct base class is a virtual base class.
 static bool isVirtualDirectBase(CXXRecordDecl *Derived, CXXRecordDecl *Base) {
   if (!Derived->getNumVBases())
     return false;
   for (auto &B : Derived->bases())
     if (B.getType()->getAsCXXRecordDecl() == Base)
       return B.isVirtual();
   llvm_unreachable("not a direct base class");
 }
 
 /// Builds a shadow declaration corresponding to a 'using' declaration.
-UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S,
-                                            UsingDecl *UD,
+UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S, BaseUsingDecl *BUD,
                                             NamedDecl *Orig,
                                             UsingShadowDecl *PrevDecl) {
   // If we resolved to another shadow declaration, just coalesce them.
   NamedDecl *Target = Orig;
   if (isa<UsingShadowDecl>(Target)) {
     Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
     assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
   }
 
   NamedDecl *NonTemplateTarget = Target;
   if (auto *TargetTD = dyn_cast<TemplateDecl>(Target))
     NonTemplateTarget = TargetTD->getTemplatedDecl();
 
   UsingShadowDecl *Shadow;
   if (NonTemplateTarget && isa<CXXConstructorDecl>(NonTemplateTarget)) {
+    UsingDecl *Using = cast<UsingDecl>(BUD);
     bool IsVirtualBase =
         isVirtualDirectBase(cast<CXXRecordDecl>(CurContext),
-                            UD->getQualifier()->getAsRecordDecl());
+                            Using->getQualifier()->getAsRecordDecl());
     Shadow = ConstructorUsingShadowDecl::Create(
-        Context, CurContext, UD->getLocation(), UD, Orig, IsVirtualBase);
+        Context, CurContext, Using->getLocation(), Using, Orig, IsVirtualBase);
   } else {
-    Shadow = UsingShadowDecl::Create(Context, CurContext, UD->getLocation(), UD,
-                                     Target);
+    Shadow = UsingShadowDecl::Create(Context, CurContext, BUD->getLocation(),
+                                     Target->getDeclName(), BUD, Target);
   }
-  UD->addShadowDecl(Shadow);
+  BUD->addShadowDecl(Shadow);
 
-  Shadow->setAccess(UD->getAccess());
-  if (Orig->isInvalidDecl() || UD->isInvalidDecl())
+  Shadow->setAccess(BUD->getAccess());
+  if (Orig->isInvalidDecl() || BUD->isInvalidDecl())
     Shadow->setInvalidDecl();
 
   Shadow->setPreviousDecl(PrevDecl);
 
   if (S)
     PushOnScopeChains(Shadow, S);
   else
     CurContext->addDecl(Shadow);
void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) {
 
   // ...and the scope, if applicable...
   if (S) {
     S->RemoveDecl(Shadow);
     IdResolver.RemoveDecl(Shadow);
   }
 
   // ...and the using decl.
-  Shadow->getUsingDecl()->removeShadowDecl(Shadow);
+  Shadow->getIntroducer()->removeShadowDecl(Shadow);
 
   // TODO: complain somehow if Shadow was used.  It shouldn't
   // be possible for this to happen, because...?
 }
 
 /// Find the base specifier for a base class with the given type.
 static CXXBaseSpecifier *findDirectBaseWithType(CXXRecordDecl *Derived,
                                                 QualType DesiredBase,

clang/lib/Sema/SemaLookup.cpp

for (auto *D : Pos->second) {
       if (D->getUnderlyingDecl()->isFunctionOrFunctionTemplate() &&
           ND->getUnderlyingDecl()->isFunctionOrFunctionTemplate() &&
           SM == ShadowMaps.rbegin())
         continue;
 
       // A shadow declaration that's created by a resolved using declaration
       // is not hidden by the same using declaration.
       if (isa<UsingShadowDecl>(ND) && isa<UsingDecl>(D) &&
-          cast<UsingShadowDecl>(ND)->getUsingDecl() == D)
+          cast<UsingShadowDecl>(ND)->getIntroducer() == D)
         continue;
 
       // We've found a declaration that hides this one.
       return D;
     }
   }
 
   return nullptr;

clang/lib/Sema/SemaTemplate.cpp

if (auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
           PrevDecl ? Previous.getRepresentativeDecl() : nullptr)) {
     if (SS.isEmpty() &&
         !(PrevClassTemplate &&
           PrevClassTemplate->getDeclContext()->getRedeclContext()->Equals(
               SemanticContext->getRedeclContext()))) {
       Diag(KWLoc, diag::err_using_decl_conflict_reverse);
       Diag(Shadow->getTargetDecl()->getLocation(),
            diag::note_using_decl_target);
-      Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
+      Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl) << 0;
       // Recover by ignoring the old declaration.
       PrevDecl = PrevClassTemplate = nullptr;
     }
   }
 
   if (PrevClassTemplate) {
     // Ensure that the template parameter lists are compatible. Skip this check
     // for a friend in a dependent context: the template parameter list itself

clang/tools/libclang/CIndex.cpp

CXCursor clang_getCursorDefinition(CXCursor C) {
   case Decl::VarTemplate: {
     if (VarDecl *Def =
             cast<VarTemplateDecl>(D)->getTemplatedDecl()->getDefinition())
       return MakeCXCursor(cast<VarDecl>(Def)->getDescribedVarTemplate(), TU);
     return clang_getNullCursor();
   }
 
   case Decl::Using:
-    return MakeCursorOverloadedDeclRef(cast<UsingDecl>(D), D->getLocation(),
+    return MakeCursorOverloadedDeclRef(cast<BaseUsingDecl>(D), D->getLocation(),
                                        TU);
 
   case Decl::UsingShadow:
   case Decl::ConstructorUsingShadow:
     return clang_getCursorDefinition(
         MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(), TU));
 
   case Decl::ObjCMethod: {