[clang] Build UsingType for elaborated type specifiers.

[hokein]

Summary

To support building UsingType for elaborated type specifiers:

namespace ns { class Foo {}; }

using ns::Foo;

// The TypeLoc of `Foo` below should be a ElaboratedTypeLoc with an
inner UsingTypeLoc rather than the underlying `CXXRecordTypeLoc`
class Foo foo;

It seems to work, and improves some diagnostics.

[hokein]

though this is a hack implementation, the result seems promising to me, so I post it for initial thoughts.

clang/include/clang/Sema/Sema.h

3306–3307

This is the key place where it returns the underlying decl.

Alternatively, we could return the UsingDecl as the result (there are only 4 places using it, might be possible to check/verify/adjust all caller place, I feel a bit scary about it, as the name indicates, caller might assume the return Decl is a TagDecl, e.g. the case)

[sammccall]

I'll bite, why do you say it's hacky?
Looks OK to me, by clang standards :-)

clang/include/clang/Sema/DeclSpec.h

516

elsewhere we call this the found decl, seems worth sticking with the terminology unless there's a distinction I'm missing.

(I'd also add a comment here, even though it doesn't seem to be local style, sigh)

clang/include/clang/Sema/Sema.h

3306–3307

Yeah, given the name I think returning the TagDecl makes sense.
(It looks like it should always return TagDecl, though it's hard to tell - if so then changing the static type to TagDecl* seems like it would help)

I think the extra out-param is fine, except given that there are few callsites, I'd prefer a mandatory FoundUsingShadow*& and explicitly ignoring it where appropriate - seems less cryptic and makes discarding sugar more obvious.

3307

nit: needs clang-format for pointer-alignment here and elsewhere

[hokein]

address comments.

[hokein]

clang/lib/Parse/ParseDeclCXX.cpp

2136

Addressing it in https://reviews.llvm.org/D141580.

[sammccall]

clang/include/clang/Sema/DeclSpec.h

510

urgh, this function is now misnamed, because the decl we're returning isn't the representation.
But changing it seems like a lot of unneccesary churn and confusion.
So no action required, I'm just making a face :-S

[hokein]

rebase

clang-tools-extra/include-cleaner/unittests/WalkASTTest.cpp

namespace ns {
            "using ns::^Y;");
   testWalk(R"cpp(
     namespace ns {
       template<class T>
       class Y {};
     }
     using ns::$explicit^Y;)cpp",
            "^Y<int> x;");
+  testWalk(R"cpp(
+    namespace ns { class Foo {}; }
+  )cpp", "using ns::$explicit^Foo; class ^Foo foo;");
 }
 
 TEST(WalkAST, Namespaces) {
   testWalk("namespace ns { void x(); }", "using namespace ^ns;");
 }
 
 TEST(WalkAST, TemplateNames) {
   testWalk("template<typename> struct $explicit^S {};", "^S<int> s;");

clang/include/clang/Sema/DeclSpec.h

#include "clang/Basic/TransformTypeTraits.def"
   bool isTypeSpecPipe() const { return TypeSpecPipe; }
   bool isTypeSpecSat() const { return TypeSpecSat; }
   bool isConstrainedAuto() const { return ConstrainedAuto; }
 
   ParsedType getRepAsType() const {
     assert(isTypeRep((TST) TypeSpecType) && "DeclSpec does not store a type");
     return TypeRep;
   }
+  // Returns the underlying decl, if any.
   Decl *getRepAsDecl() const {
-    assert(isDeclRep((TST) TypeSpecType) && "DeclSpec does not store a decl");
+    auto *D = getRepAsFoundDecl();
+    if (const auto *Using = dyn_cast_or_null<UsingShadowDecl>(D))
+      return Using->getTargetDecl();
+    return D;
+  }
+  // Returns the originally found decl, if any.
+  Decl *getRepAsFoundDecl() const {
+    assert(isDeclRep((TST)TypeSpecType) && "DeclSpec does not store a decl");
     return DeclRep;
   }
   Expr *getRepAsExpr() const {
     assert(isExprRep((TST) TypeSpecType) && "DeclSpec does not store an expr");
     return ExprRep;
   }
   TemplateIdAnnotation *getRepAsTemplateId() const {
     assert(isTemplateIdRep((TST) TypeSpecType) &&

clang/include/clang/Sema/Sema.h

bool isAcceptableTagRedeclaration(const TagDecl *Previous,
                                     const IdentifierInfo *Name);
 
   enum TagUseKind {
     TUK_Reference,   // Reference to a tag:  'struct foo *X;'
     TUK_Declaration, // Fwd decl of a tag:   'struct foo;'
     TUK_Definition,  // Definition of a tag: 'struct foo { int X; } Y;'
     TUK_Friend       // Friend declaration:  'friend struct foo;'
   };
 
   enum OffsetOfKind {
     // Not parsing a type within __builtin_offsetof.
     OOK_Outside,
     // Parsing a type within __builtin_offsetof.
     OOK_Builtin,
     // Parsing a type within macro "offsetof", defined in __buitin_offsetof
     // To improve our diagnostic message.
     OOK_Macro,
   };
 
   DeclResult ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
                       SourceLocation KWLoc, CXXScopeSpec &SS,
                       IdentifierInfo *Name, SourceLocation NameLoc,
                       const ParsedAttributesView &Attr, AccessSpecifier AS,
                       SourceLocation ModulePrivateLoc,
                       MultiTemplateParamsArg TemplateParameterLists,
                       bool &OwnedDecl, bool &IsDependent,
                       SourceLocation ScopedEnumKWLoc,
                       bool ScopedEnumUsesClassTag, TypeResult UnderlyingType,
                       bool IsTypeSpecifier, bool IsTemplateParamOrArg,
-                      OffsetOfKind OOK, SkipBodyInfo *SkipBody = nullptr);
+                      OffsetOfKind OOK,
+                      UsingShadowDecl*& FoundUsingShadow,
+                      SkipBodyInfo *SkipBody = nullptr);
 
   DeclResult ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
                                      unsigned TagSpec, SourceLocation TagLoc,
                                      CXXScopeSpec &SS, IdentifierInfo *Name,
                                      SourceLocation NameLoc,
                                      const ParsedAttributesView &Attr,
                                      MultiTemplateParamsArg TempParamLists);
 

clang/lib/Parse/ParseDecl.cpp

if (!Name && TUK == Sema::TUK_Definition && Tok.is(tok::l_brace) &&
     SkipBody = Actions.shouldSkipAnonEnumBody(getCurScope(),
                                               NextToken().getIdentifierInfo(),
                                               NextToken().getLocation());
 
   bool Owned = false;
   bool IsDependent = false;
   const char *PrevSpec = nullptr;
   unsigned DiagID;
+  UsingShadowDecl* FoundUsing = nullptr;
   Decl *TagDecl =
       Actions.ActOnTag(getCurScope(), DeclSpec::TST_enum, TUK, StartLoc, SS,
                     Name, NameLoc, attrs, AS, DS.getModulePrivateSpecLoc(),
                     TParams, Owned, IsDependent, ScopedEnumKWLoc,
                     IsScopedUsingClassTag,
                     BaseType, DSC == DeclSpecContext::DSC_type_specifier,
                     DSC == DeclSpecContext::DSC_template_param ||
                         DSC == DeclSpecContext::DSC_template_type_arg,
-                    OffsetOfState, &SkipBody).get();
+                    OffsetOfState, FoundUsing, &SkipBody).get();
 
   if (SkipBody.ShouldSkip) {
     assert(TUK == Sema::TUK_Definition && "can only skip a definition");
 
     BalancedDelimiterTracker T(*this, tok::l_brace);
     T.consumeOpen();
     T.skipToEnd();
 
     if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
-                           NameLoc.isValid() ? NameLoc : StartLoc,
-                           PrevSpec, DiagID, TagDecl, Owned,
+                           NameLoc.isValid() ? NameLoc : StartLoc, PrevSpec,
+                           DiagID, FoundUsing ? FoundUsing : TagDecl, Owned,
                            Actions.getASTContext().getPrintingPolicy()))
       Diag(StartLoc, DiagID) << PrevSpec;
     return;
   }
 
   if (IsDependent) {
     // This enum has a dependent nested-name-specifier. Handle it as a
     // dependent tag.
if (Tok.is(tok::l_brace) && TUK == Sema::TUK_Definition) {
     if (SkipBody.CheckSameAsPrevious &&
         !Actions.ActOnDuplicateDefinition(TagDecl, SkipBody)) {
       DS.SetTypeSpecError();
       return;
     }
   }
 
   if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
-                         NameLoc.isValid() ? NameLoc : StartLoc,
-                         PrevSpec, DiagID, TagDecl, Owned,
+                         NameLoc.isValid() ? NameLoc : StartLoc, PrevSpec,
+                         DiagID, FoundUsing ? FoundUsing : TagDecl, Owned,
                          Actions.getASTContext().getPrintingPolicy()))
     Diag(StartLoc, DiagID) << PrevSpec;
 }
 
 /// ParseEnumBody - Parse a {} enclosed enumerator-list.
 ///       enumerator-list:
 ///         enumerator
 ///         enumerator-list ',' enumerator

clang/lib/Parse/ParseDeclCXX.cpp

if (!Name && !TemplateId &&
     else
       SkipUntil(tok::comma, StopAtSemi);
     return;
   }
 
   // Create the tag portion of the class or class template.
   DeclResult TagOrTempResult = true; // invalid
   TypeResult TypeResult = true;      // invalid
+  UsingShadowDecl *FoundUsing = nullptr;
 
   bool Owned = false;
   Sema::SkipBodyInfo SkipBody;
   if (TemplateId) {
     // Explicit specialization, class template partial specialization,
     // or explicit instantiation.
     ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
                                        TemplateId->NumArgs);
if (TemplateId) {
     // Declaration or definition of a class type
     TagOrTempResult = Actions.ActOnTag(
         getCurScope(), TagType, TUK, StartLoc, SS, Name, NameLoc, attrs, AS,
         DS.getModulePrivateSpecLoc(), TParams, Owned, IsDependent,
         SourceLocation(), false, clang::TypeResult(),
         DSC == DeclSpecContext::DSC_type_specifier,
         DSC == DeclSpecContext::DSC_template_param ||
             DSC == DeclSpecContext::DSC_template_type_arg,
-        OffsetOfState, &SkipBody);
+        OffsetOfState, FoundUsing, &SkipBody);
 
     // If ActOnTag said the type was dependent, try again with the
     // less common call.
     if (IsDependent) {
       assert(TUK == Sema::TUK_Reference || TUK == Sema::TUK_Friend);
       TypeResult = Actions.ActOnDependentTag(getCurScope(), TagType, TUK, SS,
                                              Name, StartLoc, NameLoc);
     }
#include "clang/Basic/TransformTypeTraits.def"
   unsigned DiagID;
   bool Result;
   if (!TypeResult.isInvalid()) {
     Result = DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc,
                                 NameLoc.isValid() ? NameLoc : StartLoc,
                                 PrevSpec, DiagID, TypeResult.get(), Policy);
   } else if (!TagOrTempResult.isInvalid()) {
     Result = DS.SetTypeSpecType(
         TagType, StartLoc, NameLoc.isValid() ? NameLoc : StartLoc, PrevSpec,
-        DiagID, TagOrTempResult.get(), Owned, Policy);
+        DiagID, FoundUsing ? FoundUsing : TagOrTempResult.get(), Owned, Policy);
   } else {
     DS.SetTypeSpecError();
     return;
   }
 
   if (Result)
     Diag(StartLoc, DiagID) << PrevSpec;
 

clang/lib/Sema/SemaDecl.cpp

 Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
                CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
                const ParsedAttributesView &Attrs, AccessSpecifier AS,
                SourceLocation ModulePrivateLoc,
                MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl,
                bool &IsDependent, SourceLocation ScopedEnumKWLoc,
                bool ScopedEnumUsesClassTag, TypeResult UnderlyingType,
                bool IsTypeSpecifier, bool IsTemplateParamOrArg,
-               OffsetOfKind OOK, SkipBodyInfo *SkipBody) {
+               OffsetOfKind OOK, UsingShadowDecl *&FoundUsingShadow,
+               SkipBodyInfo *SkipBody) {
   // If this is not a definition, it must have a name.
   IdentifierInfo *OrigName = Name;
   assert((Name != nullptr || TUK == TUK_Definition) &&
          "Nameless record must be a definition!");
   assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference);
 
   OwnedDecl = false;
   TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
if (getLangOpts().CPlusPlus) {
       }
     }
 
     // If this is a redeclaration of a using shadow declaration, it must
     // declare a tag in the same context. In MSVC mode, we allow a
     // redefinition if either context is within the other.
     if (auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
       auto *OldTag = dyn_cast<TagDecl>(PrevDecl);
+      FoundUsingShadow = Shadow;
       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->getIntroducer()->getLocation(), diag::note_using_decl)

clang/lib/Sema/SemaDeclCXX.cpp

DeclResult Sema::ActOnTemplatedFriendTag(
 
   // If it's explicit specializations all the way down, just forget
   // about the template header and build an appropriate non-templated
   // friend.  TODO: for source fidelity, remember the headers.
   if (isAllExplicitSpecializations) {
     if (SS.isEmpty()) {
       bool Owned = false;
       bool IsDependent = false;
+      UsingShadowDecl* FoundUsing = nullptr;
       return ActOnTag(S, TagSpec, TUK_Friend, TagLoc, SS, Name, NameLoc, Attr,
                       AS_public,
                       /*ModulePrivateLoc=*/SourceLocation(),
                       MultiTemplateParamsArg(), Owned, IsDependent,
                       /*ScopedEnumKWLoc=*/SourceLocation(),
                       /*ScopedEnumUsesClassTag=*/false,
                       /*UnderlyingType=*/TypeResult(),
                       /*IsTypeSpecifier=*/false,
-                      /*IsTemplateParamOrArg=*/false, /*OOK=*/OOK_Outside);
+                      /*IsTemplateParamOrArg=*/false, /*OOK=*/OOK_Outside, FoundUsing);
     }
 
     NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
     ElaboratedTypeKeyword Keyword
       = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
     QualType T = CheckTypenameType(Keyword, TagLoc, QualifierLoc,
                                    *Name, NameLoc);
     if (T.isNull())

clang/lib/Sema/SemaTemplate.cpp

 Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc,
                                  SourceLocation TemplateLoc, unsigned TagSpec,
                                  SourceLocation KWLoc, CXXScopeSpec &SS,
                                  IdentifierInfo *Name, SourceLocation NameLoc,
                                  const ParsedAttributesView &Attr) {
 
   bool Owned = false;
   bool IsDependent = false;
-  Decl *TagD = ActOnTag(S, TagSpec, Sema::TUK_Reference, KWLoc, SS, Name,
-               NameLoc, Attr, AS_none, /*ModulePrivateLoc=*/SourceLocation(),
+  UsingShadowDecl* FoundUsing = nullptr;
+  Decl *TagD =
+      ActOnTag(S, TagSpec, Sema::TUK_Reference, KWLoc, SS, Name, NameLoc, Attr,
+               AS_none, /*ModulePrivateLoc=*/SourceLocation(),
                MultiTemplateParamsArg(), Owned, IsDependent, SourceLocation(),
                false, TypeResult(), /*IsTypeSpecifier*/ false,
-               /*IsTemplateParamOrArg*/ false, /*OOK=*/OOK_Outside).get();
+               /*IsTemplateParamOrArg*/ false, /*OOK=*/OOK_Outside, FoundUsing)
+          .get();
   assert(!IsDependent && "explicit instantiation of dependent name not yet handled");
 
   if (!TagD)
     return true;
 
   TagDecl *Tag = cast<TagDecl>(TagD);
   assert(!Tag->isEnum() && "shouldn't see enumerations here");
 

clang/lib/Sema/SemaType.cpp

case DeclSpec::TST_interface: {
 
     assert(DS.getTypeSpecWidth() == TypeSpecifierWidth::Unspecified &&
            DS.getTypeSpecComplex() == 0 &&
            DS.getTypeSpecSign() == TypeSpecifierSign::Unspecified &&
            "No qualifiers on tag names!");
 
     // TypeQuals handled by caller.
     Result = Context.getTypeDeclType(D);
+    if (const auto *Using =
+            dyn_cast_or_null<UsingShadowDecl>(DS.getRepAsFoundDecl()))
+      Result = Context.getUsingType(Using, Result);
 
     // In both C and C++, make an ElaboratedType.
     ElaboratedTypeKeyword Keyword
       = ElaboratedType::getKeywordForTypeSpec(DS.getTypeSpecType());
     Result = S.getElaboratedType(Keyword, DS.getTypeSpecScope(), Result,
                                  DS.isTypeSpecOwned() ? D : nullptr);
     break;
   }

clang/test/CXX/drs/dr2xx.cpp

namespace dr284 { // dr284: no
   namespace B {
     struct W;
     using A::X;
     using A::Y;
     using A::Z;
   }
   struct B::V {}; // expected-error {{no struct named 'V'}}
   struct B::W {};
-  struct B::X {}; // FIXME: ill-formed
+  struct B::X {}; // expected-error {{forward declaration of struct cannot have}}
   enum B::Y e; // ok per dr417
   class B::Z z; // ok per dr417
 
   struct C {
     struct X;
     enum Y {};
     class Z {};
   };
   struct D : C {
     struct W;
     using C::X;
     using C::Y;
     using C::Z;
   };
   struct D::V {}; // expected-error {{no struct named 'V'}}
   struct D::W {};
-  struct D::X {}; // FIXME: ill-formed
+  struct D::X {}; // expected-error {{forward declaration of struct cannot have}}
   enum D::Y e2; // ok per dr417
   class D::Z z2; // ok per dr417
 }
 
 namespace dr285 { // dr285: yes
   template<typename T> void f(T, int); // expected-note {{match}}
   template<typename T> void f(int, T); // expected-note {{match}}
   template<> void f<int>(int, int) {} // expected-error {{ambiguous}}

clang/test/CXX/drs/dr4xx.cpp

namespace dr417 { // dr417: no
   struct B::X { struct Y; };
   struct C::X::Y {}; // ok!
   namespace N {
     struct D;
     struct E;
     struct F;
     struct H;
   }
-  // FIXME: This is ill-formed.
   using N::D;
-  struct dr417::D {}; // expected-warning {{extra qualification}}
+  struct dr417::D {}; // expected-error {{forward declaration of struct cannot}} expected-warning {{extra qualification}}
   using namespace N;
   struct dr417::E {}; // expected-warning {{extra qualification}} expected-error {{no struct named 'E'}}
   struct N::F {};
   struct G;
   using N::H;
   namespace M {
     struct dr417::G {}; // expected-error {{namespace 'M' does not enclose}}
     struct dr417::H {}; // expected-error {{namespace 'M' does not enclose}}