[C++17] Don't crash while diagnosing different access specifier of a deduction guide.

[Rakete1111]

Summary

This fixes PR40552 by not showing the diagnostic that complains about different access specifiers, since the template does not have one.

[aaron.ballman]

test/SemaCXX/cxx1z-class-template-argument-deduction.cpp

360–361

These errors are pretty unfortunate -- they don't really help the user to understand what's gone wrong here. They're an improvement over the crash, but I think we should try to make the errors more useful if we can.

Why is Typo() being treated as a deduction guide? Perhaps we could look to see if there is a -> before making that determination?

[Rakete1111]

test/SemaCXX/cxx1z-class-template-argument-deduction.cpp

360–361

Perhaps we could look to see if there is a -> before making that determination?

Yes that would be possible. The diagnostic would change for the following code:

template <typename>
struct Foo {};

Foo();// -> Foo<int>; 
// currently: deduction guide missing ->
// after: C++ requires type specifier for every declaration

Is that acceptable? Or I guess I could restrict this to partial deduction guides in classes.

[aaron.ballman]

test/SemaCXX/cxx1z-class-template-argument-deduction.cpp

360–361

I think the original diagnostic is better in that case. If you restrict to partial deduction guides, do we get all the good diagnostics?

[rsmith]

test/SemaCXX/cxx1z-class-template-argument-deduction.cpp

360–361

I think the most likely intent in that case was to declare a constructor of Foo, and either it was accidentally written after the end of the class, or the in-class declaration got copy-pasted and the programmer forgot to fix it up. And moreso for a case such as

template <typename>
struct Foo { Foo(); };

template<typename T>
Foo() {
    // ...
}

... where we currently give three errors about deduction guides and no hint that a qualified name is required to define a constructor.

I think it's comparatively unlikely that someone would forget the -> in a deduction guide, given how central it is to the purpose of the declaration. So always disambiguating as a failed constructor rather than a failed deduction guide seems reasonable to me.

[Rakete1111]

This revision has been superseded :)

lib/Sema/SemaDeclCXX.cpp

if (isInstField) {
     if (NonTemplateMember != Member)
       NonTemplateMember->setAccess(AS);
 
     // C++ [temp.deduct.guide]p3:
     //   A deduction guide [...] for a member class template [shall be
     //   declared] with the same access [as the template].
     if (auto *DG = dyn_cast<CXXDeductionGuideDecl>(NonTemplateMember)) {
       auto *TD = DG->getDeducedTemplate();
-      if (AS != TD->getAccess()) {
+      if (AS != TD->getAccess() && TD->getAccess() != AS_none) {
         Diag(DG->getBeginLoc(), diag::err_deduction_guide_wrong_access);
         Diag(TD->getBeginLoc(), diag::note_deduction_guide_template_access)
             << TD->getAccess();
         const AccessSpecDecl *LastAccessSpec = nullptr;
         for (const auto *D : cast<CXXRecordDecl>(CurContext)->decls()) {
           if (const auto *AccessSpec = dyn_cast<AccessSpecDecl>(D))
             LastAccessSpec = AccessSpec;
         }

test/SemaCXX/cxx1z-class-template-argument-deduction.cpp

namespace member_guides {
   private: // expected-note {{declared private by intervening access specifier}}
     template<typename T> struct Private; // expected-note {{declared private}}
     Protected(int) -> Protected<int>; // expected-error {{different access}}
   public: // expected-note 2{{declared public by intervening access specifier}}
     template<typename T> Public(T) -> Public<T>;
     template<typename T> Protected(T) -> Protected<T>; // expected-error {{different access}}
     template<typename T> Private(T) -> Private<T>; // expected-error {{different access}}
   };
+
+  // PR40552
+  template <typename> struct Typo {}; // expected-note{{template is declared here}}
+  struct Type {
+    Typo(); // expected-error{{deduction guide must be declared in the same scope}}
+    // expected-error@-1{{deduction guide declaration without trailing return type}}
+  };
 }
 
 namespace rdar41903969 {
 template <class T> struct A {};
 template <class T> struct B;
 template <class T> struct C {
   C(A<T>&);
   C(B<T>&);