using-enum part 2 (RFC)

[urnathan]

Summary

This is a WIP for the second part of p1099, namely the 'using elaborated-enum-specifier ;' part. It's a WIP because I'd like advice on resolving some FIXMEs in the diff.

I added the parsing to ParseUsingDeclaration, even though the grammar describes a using-enum as a different kind of construct. It seems simplest to disambiguate it there, and AFAICT using-enum is valid in all the places a regular using decl is.

I still use a UsingDecl to represent the using-enum, and add some accessors and a new field to that (this is one of the FIXMEs, see the comment in the diff explaining further).

For instantiation, we can meet an uncompleted scoped enum. There doesnt seem to be a good routine to complete that case, Again a FIXME notes that RequireCompleteDeclContext wants a ScopeRef, which we don't have at the needed point.

There is some similarity and some differences with a using-enum vs regular using, and perhaps some helper routines might be broken out?

[urnathan]

clang/include/clang/AST/DeclCXX.h

3389

I considered a new UsingEnumDecl, but we still have the same chain of shadow decls to maintain, so that'd mean also breaking out the shadow list iterator stuff. Perhaps if we stored 2 bits in the shadowdecl pointer/int pair, and held a discriminator there, then the Enum field could overlay the QualifierLoc and DNLoc?

3415

No point altering the streamers before the data organization is settled.

3444

IIUC these accessors should assert they're being used on the right dynamic type

clang/lib/Parse/ParseDeclCXX.cpp

695–696

this block is copied from the regular using-decl parsing below. It was more awkward making the control flow work with a single block.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

3026

It seems that using-enum results in a place where we need to complete a scoped-enumerator, but not for regular scope lookup within the enum, so we do not have a ScopeSpec around. I copied this block from RequireCompleteDeclContext, but (a) copying makes me sad and (b) I'm concerned about failure modes. what to do?

3052

This loop is very like the regular using-decl loop below. Like the parser, trying to make control flow for the two cases reach a single loop was awkward -- there's a LookupResult object that's live in that case, and here only within an iteration. It seems parameterizing a helper would work though?

[aaron.ballman]

clang/include/clang/AST/DeclCXX.h

3389

That approach sounds plausible to me.

Perhaps another possible approach would be to use trailing objects on the UsingDecl so that you'll either have a trailing object of EnumDecl * or the previous fields.

3444

Agreed.

clang/lib/Parse/ParseDeclCXX.cpp

687–688

We usually do an awkward (to me) diagnostic dance in these situations where we give a "not compatible with previous standards" warning or a "is a C++whatever extension" warning.

e.g., https://github.com/llvm/llvm-project/blob/main/clang/lib/Parse/ParseDeclCXX.cpp#L2842

[urnathan]

Plan of action is to follow https://lists.llvm.org/pipermail/cfe-dev/2021-April/068074.html, break a ShadowIntroducingDecl base out of UsingDecl and then add UsingEnumDecl derived from that.

[urnathan]

oops, created a new revision for the update

clang/include/clang/AST/DeclCXX.h

public:
 
   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.
+/// (resolved) using or using-enum declaration.
 ///
 /// For example,
 /// \code
 /// namespace A {
 ///   void foo();
 /// }
 /// namespace B {
 ///   using A::foo; // <- a UsingDecl
class UsingDecl : public NamedDecl, public Mergeable<UsingDecl> {
 
   /// 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;
 
+  // FIXME: some kind of union with previous members?  We only need exactly one
+  // sort.  Reserve more int bits in the Shadow pointer to discriminate between
+  // using-enum and regular using?
+  EnumDecl *Enum;
+
   /// 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()),
         UsingLocation(UL), QualifierLoc(QualifierLoc),
-      DNLoc(NameInfo.getInfo()), FirstUsingShadow(nullptr, HasTypenameKeyword) {
-  }
+        DNLoc(NameInfo.getInfo()), Enum(nullptr),
+        FirstUsingShadow(nullptr, HasTypenameKeyword) {}
+
+  // using-enum
+  UsingDecl(DeclContext *DC, SourceLocation UL, EnumDecl *ED)
+      : NamedDecl(Using, DC, UL, ED->getDeclName()), UsingLocation(UL),
+        QualifierLoc(), DNLoc(), Enum(ED) {}
 
   void anchor() override;
 
 public:
+  // FIXME: Teach these about using enum. (once we've sorted the data structure)
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
   /// Return the source location of the 'using' keyword.
   SourceLocation getUsingLoc() const { return UsingLocation; }
 
   /// Set the source location of the 'using' keyword.
   void setUsingLoc(SourceLocation L) { UsingLocation = L; }
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 this is a C++20 using-enum declaration
+  bool isUsingEnum() const { return Enum != nullptr; }
+
+  // FIXME: Add asserts to the following accessors?
+  /// Return the enum decl this is a using-enum for.
+  EnumDecl *getUsingEnum() const { return Enum; }
+
   /// Return true if the using declaration has 'typename'.
   bool hasTypename() const { return FirstUsingShadow.getInt(); }
 
   /// 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.
public:
   void addShadowDecl(UsingShadowDecl *S);
   void removeShadowDecl(UsingShadowDecl *S);
 
   static UsingDecl *Create(ASTContext &C, DeclContext *DC,
                            SourceLocation UsingL,
                            NestedNameSpecifierLoc QualifierLoc,
                            const DeclarationNameInfo &NameInfo,
                            bool HasTypenameKeyword);
+  static UsingDecl *Create(ASTContext &C, DeclContext *DC,
+                           SourceLocation UsingL, EnumDecl *ED);
 
   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(); }

clang/include/clang/Basic/DiagnosticParseKinds.td

def warn_exception_spec_deprecated : Warning<
   InGroup<DeprecatedDynamicExceptionSpec>, DefaultIgnore;
 def note_exception_spec_deprecated : Note<"use '%0' instead">;
 def warn_cxx98_compat_noexcept_decl : Warning<
   "noexcept specifications are incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def err_expected_catch : Error<"expected catch">;
 def err_using_namespace_in_class : Error<
   "'using namespace' is not allowed in classes">;
+def warn_cxx20_using_enum : Warning<
+  "using enum declaration is incompatible with C++ standards before C++20">,
+  InGroup<CXXPre20Compat>;
 def err_constructor_bad_name : Error<
   "missing return type for function %0; did you mean the constructor name %1?">;
 def err_destructor_tilde_identifier : Error<
   "expected a class name after '~' to name a destructor">;
 def err_destructor_tilde_scope : Error<
   "'~' in destructor name should be after nested name specifier">;
 def err_destructor_template_id : Error<
   "destructor name %0 does not refer to a template">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_using_decl_nested_name_specifier_is_current_class : Error<
   "using declaration refers to its own class">;
 def err_using_decl_nested_name_specifier_is_not_base_class : Error<
   "using declaration refers into '%0', which is not a base class of %1">;
 def err_using_decl_constructor_not_in_direct_base : Error<
   "%0 is not a direct base of %1, cannot inherit constructors">;
 def err_using_decl_can_not_refer_to_class_member : Error<
   "using declaration cannot refer to class member">;
+def err_using_enum_lacks_definition : Error<
+  "enum named by using-enum declaration lacks a definition">;
+def err_using_enum_is_dependent : Error<
+  "using-enum cannot name a dependent type">;
 def err_ambiguous_inherited_constructor : Error<
   "constructor of %0 inherited from multiple base class subobjects">;
 def note_ambiguous_inherited_constructor_using : Note<
   "inherited from base class %0 here">;
 def note_using_decl_class_member_workaround : Note<
   "use %select{an alias declaration|a typedef declaration|a reference|"
   "a const variable|a constexpr variable}0 instead">;
 def err_using_decl_can_not_refer_to_namespace : Error<

clang/include/clang/Sema/Sema.h

bool CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename,
                                const LookupResult *R = nullptr,
                                const UsingDecl *UD = nullptr);
 
   NamedDecl *BuildUsingDeclaration(
       Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,
       bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,
       DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,
       const ParsedAttributesView &AttrList, bool IsInstantiation);
+  NamedDecl *BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
+                                   SourceLocation EnumLoc, EnumDecl *ED);
   NamedDecl *BuildUsingPackDecl(NamedDecl *InstantiatedFrom,
                                 ArrayRef<NamedDecl *> Expansions);
 
   bool CheckInheritingConstructorUsingDecl(UsingDecl *UD);
 
   /// Given a derived-class using shadow declaration for a constructor and the
   /// correspnding base class constructor, find or create the implicit
   /// synthesized derived class constructor to use for this initialization.
   CXXConstructorDecl *
   findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor,
                             ConstructorUsingShadowDecl *DerivedShadow);
 
   Decl *ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS,
                               SourceLocation UsingLoc,
                               SourceLocation TypenameLoc, CXXScopeSpec &SS,
                               UnqualifiedId &Name, SourceLocation EllipsisLoc,
                               const ParsedAttributesView &AttrList);
+  Decl *ActOnUsingEnumDeclaration(Scope *CurScope, AccessSpecifier AS,
+                                  SourceLocation EnumLoc, const DeclSpec &);
   Decl *ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS,
                               MultiTemplateParamsArg TemplateParams,
                               SourceLocation UsingLoc, UnqualifiedId &Name,
                               const ParsedAttributesView &AttrList,
                               TypeResult Type, Decl *DeclFromDeclSpec);
 
   /// BuildCXXConstructExpr - Creates a complete call to a constructor,
   /// including handling of its default argument expressions.

clang/lib/AST/DeclCXX.cpp

APValue *LifetimeExtendedTemporaryDecl::getOrCreateValue(bool MayCreate) const {
   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()),
+    : NamedDecl(K, DC, Loc,
+                (Using->isUsingEnum() ? Target : Using)->getDeclName()),
       redeclarable_base(C), UsingOrNextShadow(cast<NamedDecl>(Using)) {
   if (Target)
     setTargetDecl(Target);
   setImplicit();
 }
 
 UsingShadowDecl::UsingShadowDecl(Kind K, ASTContext &C, EmptyShell Empty)
     : NamedDecl(K, nullptr, SourceLocation(), DeclarationName()),

 
 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::Create(ASTContext &C, DeclContext *DC, SourceLocation UL,
+                             EnumDecl *ED) {
+  return new (C, DC) UsingDecl(DC, UL, ED);
+}
+
 UsingDecl *UsingDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID) UsingDecl(nullptr, SourceLocation(),
                                NestedNameSpecifierLoc(), DeclarationNameInfo(),
                                false);
 }
 
 SourceRange UsingDecl::getSourceRange() const {
   SourceLocation Begin = isAccessDeclaration()

clang/lib/Parse/ParseDeclCXX.cpp

 ///       using-declarator-list ',' using-declarator '...'[opt]
 ///
 ///     using-declarator-list: [C++98-14]
 ///       using-declarator
 ///
 ///     alias-declaration: C++11 [dcl.dcl]p1
 ///       'using' identifier attribute-specifier-seq[opt] = type-id ;
 ///
+///     using-enum-declaration: [C++20, dcl.enum]
+///       'using' elaborated-enum-specifier ;
+///
+///     elaborated-enum-specifier:
+///       'enum' nested-name-specifier[opt] identifier
+
 Parser::DeclGroupPtrTy
 Parser::ParseUsingDeclaration(DeclaratorContext Context,
                               const ParsedTemplateInfo &TemplateInfo,
                               SourceLocation UsingLoc, SourceLocation &DeclEnd,
                               AccessSpecifier AS) {
+  SourceLocation UELoc;
+  if (TryConsumeToken(tok::kw_enum, UELoc)) {
+    // C++20 using-enum
+    if (!getLangOpts().CPlusPlus20)
+      Diag(UELoc, diag::warn_cxx20_using_enum);
+
+    DeclSpec DS(AttrFactory);
+    ParseEnumSpecifier(UELoc, DS, TemplateInfo, AS,
+                       // DSC_trailing has the semantics we desire
+                       // FIXME: should we add an alias for it?
+                       DeclSpecContext::DSC_trailing);
+
+    if (TemplateInfo.Kind) {
+      SourceRange R = TemplateInfo.getSourceRange();
+      Diag(UsingLoc, diag::err_templated_using_directive_declaration)
+          << 1 /* declaration */ << R << FixItHint::CreateRemoval(R);
+
+      return nullptr;
+    }
+
+    // FIXME: Should we parse (and ignore) attributes?  The regular using-decl
+    // parsing does that.
+
+    Decl *UED = Actions.ActOnUsingEnumDeclaration(getCurScope(), AS, UELoc, DS);
+    DeclEnd = Tok.getLocation();
+    if (ExpectAndConsume(tok::semi, diag::err_expected_after,
+                         "using-enum declaration"))
+      SkipUntil(tok::semi);
+
+    return Actions.ConvertDeclToDeclGroup(UED);
+  }
+
   // Check for misplaced attributes before the identifier in an
   // alias-declaration.
   ParsedAttributesWithRange MisplacedAttrs(AttrFactory);
   MaybeParseCXX11Attributes(MisplacedAttrs);
 
   UsingDeclarator D;
   bool InvalidDeclarator = ParseUsingDeclarator(Context, D);
 
Parser::ParseUsingDeclaration(DeclaratorContext Context,
   if (DeclsInGroup.size() > 1)
     Diag(Tok.getLocation(), getLangOpts().CPlusPlus17 ?
          diag::warn_cxx17_compat_multi_using_declaration :
          diag::ext_multi_using_declaration);
 
   // Eat ';'.
   DeclEnd = Tok.getLocation();
   if (ExpectAndConsume(tok::semi, diag::err_expected_after,
-                       !Attrs.empty() ? "attributes list"
+                       !Attrs.empty()    ? "attributes list"
+                       : UELoc.isValid() ? "using-enum declaration"
                                          : "using declaration"))
     SkipUntil(tok::semi);
 
   return Actions.BuildDeclaratorGroup(DeclsInGroup);
 }
 
 Decl *Parser::ParseAliasDeclarationAfterDeclarator(
     const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc,
     UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS,

clang/lib/Sema/SemaDeclCXX.cpp

if (!SS.getScopeRep()->containsUnexpandedParameterPack() &&
         << SourceRange(SS.getBeginLoc(), TargetNameInfo.getEndLoc());
       EllipsisLoc = SourceLocation();
     }
   }
 
   NamedDecl *UD =
       BuildUsingDeclaration(S, AS, UsingLoc, TypenameLoc.isValid(), TypenameLoc,
                             SS, TargetNameInfo, EllipsisLoc, AttrList,
-                            /*IsInstantiation*/false);
+                            /*IsInstantiation*/ false);
   if (UD)
     PushOnScopeChains(UD, S, /*AddToContext*/ false);
 
   return UD;
 }
 
+Decl *Sema::ActOnUsingEnumDeclaration(Scope *S, AccessSpecifier AS,
+                                      SourceLocation EnumLoc,
+                                      const DeclSpec &DS) {
+  switch (DS.getTypeSpecType()) {
+  case DeclSpec::TST_error:
+    // This will already have been diagnosed
+    return nullptr;
+
+  case DeclSpec::TST_enum:
+    break;
+
+  case DeclSpec::TST_typename:
+    Diag(DS.getTypeSpecTypeLoc(), diag::err_using_enum_is_dependent);
+    return nullptr;
+
+  default:
+    llvm_unreachable("unexpected DeclSpec type");
+  }
+
+  auto *Enum = cast<EnumDecl>(DS.getRepAsDecl());
+  auto *Def = Enum->getDefinition();
+
+  // FIXME: See the comment in TemplateInstantiator::VisitUsingDecl about
+  // completing the enum.  Figure out best way of achieving that
+  // The enum's definition must be reachable
+  if (!Def) {
+    Diag(DS.getTypeSpecTypeLoc(), diag::err_using_enum_lacks_definition);
+    Diag(Enum->getLocation(), diag::note_entity_declared_at) << Enum;
+    return nullptr;
+  }
+
+  auto *UD = BuildUsingDeclaration(S, AS, EnumLoc, Def);
+  if (UD)
+    PushOnScopeChains(UD, S, /*AddToContext*/ false);
+
+  return UD;
+}
+
 /// Determine whether a using declaration considers the given
 /// declarations as "equivalent", e.g., if they are redeclarations of
 /// the same entity or are both typedefs of the same type.
 static bool
 IsEquivalentForUsingDecl(ASTContext &Context, NamedDecl *D1, NamedDecl *D2) {
   if (D1->getCanonicalDecl() == D2->getCanonicalDecl())
     return true;
 
for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
     UsingShadowDecl *PrevDecl = nullptr;
     if (!CheckUsingShadowDecl(UD, *I, Previous, PrevDecl))
       BuildUsingShadowDecl(S, UD, *I, PrevDecl);
   }
 
   return UD;
 }
 
+NamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
+                                       SourceLocation EnumLoc, EnumDecl *ED) {
+  UsingDecl *UD = UsingDecl::Create(Context, CurContext, EnumLoc, ED);
+  UD->setAccess(AS);
+  CurContext->addDecl(UD);
+
+  // Create the shadow decls for each enumerator
+  for (EnumConstantDecl *EC : ED->enumerators()) {
+    UsingShadowDecl *PrevDecl = nullptr;
+    // FIXME: Best location info for the Lookup?
+    DeclarationNameInfo DNI(EC->getDeclName(), EC->getLocation());
+    LookupResult Previous(*this, DNI, LookupUsingDeclName,
+                          ForVisibleRedeclaration);
+    LookupName(Previous, S);
+    // FIXME: See regular using-decl lookup nadgering here 'it is really dumb
+    // that we have to do this'  do we need to do that here too?
+    if (!CheckUsingShadowDecl(UD, EC, Previous, PrevDecl)) {
+      BuildUsingShadowDecl(S, UD, EC, PrevDecl);
+    }
+  }
+
+  return UD;
+}
+
 NamedDecl *Sema::BuildUsingPackDecl(NamedDecl *InstantiatedFrom,
                                     ArrayRef<NamedDecl *> Expansions) {
   assert(isa<UnresolvedUsingValueDecl>(InstantiatedFrom) ||
          isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) ||
          isa<UsingPackDecl>(InstantiatedFrom));
 
   auto *UPD =
       UsingPackDecl::Create(Context, CurContext, InstantiatedFrom, Expansions);

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

Decl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
   if (!Owner->isFunctionOrMethod())
     Owner->addDecl(Inst);
 
   return Inst;
 }
 
 Decl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) {
 
+  bool CheckRedeclaration = Owner->isRecord();
+
+  if (D->isUsingEnum()) {
+    // Cannot be a dependent type, but still could be an instantiation
+    EnumDecl *EnumD = cast_or_null<EnumDecl>(SemaRef.FindInstantiatedDecl(
+        D->getLocation(), D->getUsingEnum(), TemplateArgs));
+
+    UsingDecl *NewUD =
+        UsingDecl::Create(SemaRef.Context, Owner, D->getLocation(), EnumD);
+
+    // FIXME: Complete Enum -- we'll need this in the non-template case too
+    // Sema::RequireCompleteDeclContext wants a CXXScopeSpec, Where do I get one
+    // of those?
+    if (!EnumD->isCompleteDefinition()) {
+      if (EnumDecl *Pattern = EnumD->getInstantiatedFromMemberEnum()) {
+        MemberSpecializationInfo *MSI = EnumD->getMemberSpecializationInfo();
+        if (MSI->getTemplateSpecializationKind() !=
+            TSK_ExplicitSpecialization) {
+          if (SemaRef.InstantiateEnum(
+                  D->getLocation(), EnumD, Pattern,
+                  SemaRef.getTemplateInstantiationArgs(EnumD),
+                  TSK_ImplicitInstantiation))
+            NewUD->setInvalidDecl();
+        }
+      }
+    }
+
+    SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D);
+    NewUD->setAccess(D->getAccess());
+    Owner->addDecl(NewUD);
+
+    // Don't process the shadow decls for an invalid decl.
+    if (NewUD->isInvalidDecl())
+      return NewUD;
+
+    bool isFunctionScope = Owner->isFunctionOrMethod();
+
+    // FIXME: Helper routine for this?  It's nearly the same as the
+    // non-using-enum case
+    // Process the shadow decls.
+    for (auto *Shadow : D->shadows()) {
+      // FIXME: UsingShadowDecl doesn't preserve its immediate target, so
+      // reconstruct it in the case where it matters.  Hm, can we extract it
+      // from the DeclSpec when parsing and save it in the UsingDecl itself?
+      NamedDecl *OldTarget = Shadow->getTargetDecl();
+
+      NamedDecl *InstTarget =
+          cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
+              Shadow->getLocation(), OldTarget, TemplateArgs));
+      if (!InstTarget)
+        return nullptr;
+
+      UsingShadowDecl *PrevDecl = nullptr;
+      if (CheckRedeclaration) {
+        DeclarationNameInfo DNI(Shadow->getDeclName(), Shadow->getLocation());
+        LookupResult Prev(SemaRef, DNI, Sema::LookupUsingDeclName,
+                          Sema::ForVisibleRedeclaration);
+        SemaRef.LookupQualifiedName(Prev, Owner);
+        if (SemaRef.CheckUsingShadowDecl(NewUD, InstTarget, Prev, PrevDecl))
+          continue;
+      } else if (UsingShadowDecl *OldPrev =
+                     getPreviousDeclForInstantiation(Shadow)) {
+        PrevDecl = cast_or_null<UsingShadowDecl>(SemaRef.FindInstantiatedDecl(
+            Shadow->getLocation(), OldPrev, TemplateArgs));
+      }
+
+      UsingShadowDecl *InstShadow = SemaRef.BuildUsingShadowDecl(
+          /*Scope*/ nullptr, NewUD, InstTarget, PrevDecl);
+      SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow);
+
+      if (isFunctionScope)
+        SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow,
+                                                             InstShadow);
+    }
+    return NewUD;
+  }
+
   // The nested name specifier may be dependent, for example
   //     template <typename T> struct t {
   //       struct s1 { T f1(); };
   //       struct s2 : s1 { using s1::f1; };
   //     };
   //     template struct t<int>;
   // Here, in using s1::f1, s1 refers to t<T>::s1;
   // we need to substitute for t<int>::s1.
   NestedNameSpecifierLoc QualifierLoc
     = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
                                           TemplateArgs);
   if (!QualifierLoc)
     return nullptr;
 
   // For an inheriting constructor declaration, the name of the using
   // declaration is the name of a constructor in this class, not in the
   // base class.
   DeclarationNameInfo NameInfo = D->getNameInfo();
   if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
     if (auto *RD = dyn_cast<CXXRecordDecl>(SemaRef.CurContext))
       NameInfo.setName(SemaRef.Context.DeclarationNames.getCXXConstructorName(
           SemaRef.Context.getCanonicalType(SemaRef.Context.getRecordType(RD))));
-
-  // We only need to do redeclaration lookups if we're in a class
-  // scope (in fact, it's not really even possible in non-class
-  // scopes).
-  bool CheckRedeclaration = Owner->isRecord();
-
-  LookupResult Prev(SemaRef, NameInfo, Sema::LookupUsingDeclName,
+  LookupResult Prev = LookupResult(SemaRef, NameInfo, Sema::LookupUsingDeclName,
                                    Sema::ForVisibleRedeclaration);
 
   UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner,
                                        D->getUsingLoc(),
                                        QualifierLoc,
                                        NameInfo,
                                        D->hasTypename());
 
   CXXScopeSpec SS;
   SS.Adopt(QualifierLoc);
+  // We only need to do redeclaration lookups if we're in a class
+  // scope (in fact, it's not really even possible in non-class
+  // scopes).
   if (CheckRedeclaration) {
     Prev.setHideTags(false);
     SemaRef.LookupQualifiedName(Prev, Owner);
 
     // Check for invalid redeclarations.
     if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLoc(),
                                             D->hasTypename(), SS,
                                             D->getLocation(), Prev))
       NewUD->setInvalidDecl();
-
   }
 
   if (!NewUD->isInvalidDecl() &&
       SemaRef.CheckUsingDeclQualifier(D->getUsingLoc(), D->hasTypename(), SS,
                                       NameInfo, D->getLocation(), nullptr, D))
     NewUD->setInvalidDecl();
+
   SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D);
   NewUD->setAccess(D->getAccess());
   Owner->addDecl(NewUD);
 
   // Don't process the shadow decls for an invalid decl.
   if (NewUD->isInvalidDecl())
     return NewUD;
 

clang/test/SemaCXX/cxx20-using-enum.cpp

+// RUN: %clang_cc1 -fsyntax-only -std=c++17 -verify %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++20 -verify %s
+
+// p1099 'using enum ELABORATED-ENUM-SPECIFIER ;'
+
+namespace One {
+namespace Bob {
+enum A { a, // expected-note{{declared here}}
+         b,
+         c };
+class C; // expected-note{{previous use}}
+enum class D : int;
+enum class D { d,
+               e,
+               f };
+enum class D : int;
+} // namespace Bob
+
+using enum Bob::A;
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+using enum Bob::B; // expected-error{{no enum named 'B'}}
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+using enum Bob::C; // expected-error{{tag type that does not match}}
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+auto v = a;
+
+A g; // expected-error{{unknown type name 'A'}}
+
+int A;
+
+using enum Bob::D;
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+} // namespace One
+
+namespace Two {
+namespace Kevin {
+enum class B { d,
+               e,
+               f };
+}
+
+using enum Kevin::B;
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+auto w = e;
+
+} // namespace Two
+
+namespace Three {
+namespace Stuart {
+enum class C : int; // expected-note{{declared here}}
+}
+
+using enum Stuart::C; // expected-error{{lacks a definition}}
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+} // namespace Three
+
+namespace Four {
+class Dave {
+public:
+  enum D { a,
+           b,
+           c };
+
+private:
+  enum class E { d, // expected-note{{declared private here}}
+                 e,
+                 f };
+};
+
+using enum Dave::D;
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+using enum Dave::E; // expected-error{{is a private member}}
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+
+} // namespace Four
+
+namespace Five {
+enum class A { b,
+               c };
+class Dave {
+public:
+  using enum A;
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+  A f = b;
+};
+
+} // namespace Five
+
+namespace Six {
+template <typename T> class TPL;
+template <> class TPL<int> {
+public:
+  enum A { a };
+};
+
+template <typename T> class USR {
+  using enum TPL<T>::B; // expected-error{{cannot name a dependent type}}
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+  using enum TPL<int>::A;
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+};
+} // namespace Six
+
+// Now instantiate things
+namespace Seven {
+namespace Stuart {
+enum class A { a,
+               b,
+               c };
+}
+
+static_assert(!int(Stuart::A::a));
+constexpr int Bar() {
+  using enum Stuart::A;
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+  return int(b);
+}
+static_assert(Bar() == 1);
+
+template <int I> constexpr int Foo() {
+  using enum Stuart::A;
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+  return int(b) + I;
+}
+
+static_assert(Foo<10>() == 11);
+
+template <int I> struct C {
+  using enum Stuart::A;
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+  static constexpr int V = int(c) + I;
+
+  enum class D { d,
+                 e,
+                 f };
+  using enum D;
+#if __cplusplus < 202002
+// expected-warning@-2{{standards before C++20}}
+#endif
+
+  static constexpr int W = int(f) + I;
+};
+
+static_assert(C<2>::V == 4);
+static_assert(C<20>::W == 22);
+
+} // namespace Seven