[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

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

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.

3317

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

[hokein]

address comments.

[hokein]

clang/lib/Parse/ParseDeclCXX.cpp

2134

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

public:
 
   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;'
   };
 
   Decl *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,
+                 UsingShadowDecl*& FoundUsingShadow,
                  SkipBodyInfo *SkipBody = nullptr);
 
   Decl *ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
                                 unsigned TagSpec, SourceLocation TagLoc,
                                 CXXScopeSpec &SS, IdentifierInfo *Name,
                                 SourceLocation NameLoc,
                                 const ParsedAttributesView &Attr,
                                 MultiTemplateParamsArg TempParamLists);
 
   TypeResult ActOnDependentTag(Scope *S,

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,
-      &SkipBody);
+      FoundUsing, &SkipBody);
 
   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,
-        &SkipBody);
-
+        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"
   const char *PrevSpec = nullptr;
   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()) {
+    // FIXME: !! TagOrTempResult.get() can be a nullptr here, this looks
+    // suspicious.
     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

Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
                      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,
+                     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;
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

Decl *Sema::ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
 
   // 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);
+                      /*IsTemplateParamOrArg=*/false,
+                      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;
+  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);
+                        /*IsTemplateParamOrArg*/false,
+                        FoundUsing);
   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}}
+    struct dr417::H {}; // expected-error {{namespace 'M' does not enclose}} expected-error {{forward declaration of struct cannot have}}
   }
 }
 
 namespace dr418 { // dr418: no
 namespace example1 {
 void f1(int, int = 0);
 void f1(int = 0, int);
 

clang/test/SemaCXX/using-decl-1.cpp

namespace UsingDeclVsHiddenName {
 
   namespace B {
     using A::HiddenTag1;
     using A::HiddenFn1; // expected-note {{using declaration}}
     using A::HiddenLocalExtern1;
 
     struct S {
       friend struct HiddenTag1; // expected-error {{tag type that does not match previous}}
+#if __cplusplus < 201103L
+    // expected-warning@-2 {{befriending enumeration type 'struct HiddenTag1' is a C++11 extension}}
+#endif
+
       friend struct HiddenTag2; // expected-note {{conflicting declaration}}
       friend void HiddenFn1(); // expected-error {{cannot befriend target of using declaration}}
       friend void HiddenFn2(); // expected-note {{conflicting declaration}}
       void f() {
         // OK, these are not in the scope of namespace B, even though they're
         // members of the namespace.
         void HiddenLocalExtern1();
         void HiddenLocalExtern2();

 }
 
 // expected-error@+5 {{requires a qualified name}}
 // expected-error@+4 {{expected ';'}}
 // expected-error@+3 {{expected '}'}}
 // expected-note@+2 {{to match this '{'}}
 // expected-error@+1 {{expected ';'}}
 template<class> struct S { using S
 No newline at end of file