[clang] Implement P0692R1 from C++20 (access checking on specializations and instantiations)

[aorlov]

Summary

This patch implements paper P0692R1 from the C++20 standard. Disable usual access checking rules to template argument names in a declaration of partial specializations, explicit instantiation or explicit specialization (C++20 13.7.5/10, 13.9.1/6).

Fixes: https://llvm.org/PR37424

This patch also implements option *A* from this paper P0692R1 from the C++20 standard.

This patch follows the @rsmith suggestion from D78404.

[aorlov]

Improved solution. Added more tests.

[aorlov]

Fixed typos. Made minor changes in test cases.

[• Quuxplusone]

The subject line says "access checking on specializations and instantiations," but I don't see any tests for explicit instantiations here — just specializations. In particular, I'm very interested to know if P0692 is intended to have any effect on the legality of https://godbolt.org/z/fqfo8q

template<int*> struct T {};
template struct T<&S::private_static_data>;

It would also be good to document which of the two proposed wordings from http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0692r1.html is actually being adopted in this patch.

[aorlov]

In D92024#2431452, @Quuxplusone wrote:

The subject line says "access checking on specializations and instantiations," but I don't see any tests for explicit instantiations here — just specializations. In particular, I'm very interested to know if P0692 is intended to have any effect on the legality of https://godbolt.org/z/fqfo8q

Thank you for your important suggestion! I'll add test cases for explicit instantiations.

It would also be good to document which of the two proposed wordings from http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0692r1.html is actually being adopted in this patch.

AFAIK there are four options in the paper. This patch covers option *A*. I'll mention this in the summary.
Both wordings relate to option A only, thus both wordings have been adopted.

[aorlov]

Added test cases for explicit instantiations.

@Quuxplusone,
In particular, I'm very interested to know if P0692 is intended to have any effect on the legality of https://godbolt.org/z/fqfo8q

I've checked your particular case. It hasn't been affected by this patch. It works as before. I also added it to func.spec.cpp.

[• Quuxplusone]

clang/lib/Parse/ParseTemplate.cpp

171

I don't know the purpose of this code, but this seems like a super important TODO.

The comment "look ahead until {" is also scary because

template<int I, int J> struct A {};
template<int J> struct A<int{}, J> {};

is also a partial specialization. Why do we need to know isSpecialization, who's supposed to compute it, and why does their answer need to be fixed-up right here?

And is this specific piece of the patch perhaps severable into a separate review? Again, I don't know this code, but... It seems like you've got one part of the patch — "add a SuppressAccessGuard around the call to ParseDeclarator" — which is either a 100% correct or 100% incorrect implementation of P0692R1. And then you've got this other piece, a parser hack, which looks much more heuristic and incomplete in nature, and looks orthogonal to P0692R1.

Btw, I'm not an approver on this (and shouldn't be); if you want better review you might want to ping someone who's touched this code lately (according to git blame).

[aorlov]

clang/lib/Parse/ParseTemplate.cpp

171

@Quuxplusone

I don't know the purpose of this code, but this seems like a super important TODO.

This is a deprecated hint, I'll remove it.

The comment "look ahead until {" is also scary

Nice case! I'll improve the patch.

Why do we need to know isSpecialization

This flag helps to turn off usual access rules further:

Parser::ParseClassSpecifier(... const ParsedTemplateInfo &TemplateInfo, ...) {
...
  bool shouldDelayDiagsInTag =
    (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
     TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
  SuppressAccessChecks diagsFromTag(*this, shouldDelayDiagsInTag);
...
}

And then you've got this other piece, a parser hack,

Totally agree. It also looks like a hack for me. The point is that the principle of parser's workflow is that it analyzes tokens and then consume them one by one at the same time. So we are not confident whether we are parsing a primary template or specialization. Thus TemplateInfo.Kind is not always correct. To define a specialization we should look forward at the whole declaraion without consuming any tokens to leave them for further parsing but set a correct 'Kind'.
On the other side we can somehow store the context of we are parsing a template declaration and throw it through a bunch of calls. But I found this way much more complicated, than of looking at some next tokens. BTW @rsmith suggested this approach in the comment https://reviews.llvm.org/D78404#inline-717620

Btw, I'm not an approver on this (and shouldn't be); if you want better review you might want to ping someone who's touched this code lately (according to git blame).

Thank you. I've already added all related people in the list of reviewers.

[aorlov]

Simplify the patch.
@Quuxplusone,
Actually you've pushed me to some thinking of what more syntactic cases it could be. And I came to that we can get rid of this hack and simplify the patch pretty much. Hope, this fix will be more admissible.

[• Quuxplusone]

And I came to that we can get rid of this hack and simplify the patch pretty much

Wow, this certainly looks massively better than it was before! :) Glad I could help. ;)

[aorlov]

Updated. Disabled function parameters access checking in function templates.
Hi, @broadwaylamb, @rsmith, @saar.raz, @doug.gregor, @mibintc, @hokein. Could you please look at this patch?

[mibintc]

I don't have expertise in this area.

[aorlov]

Hi, community. I kindly ask you to review this patch.

[aorlov]

One more ping!

[aorlov]

Please, somebody look at this patch.

[• Quuxplusone]

clang/lib/Parse/ParseTemplate.cpp

284

Spelling: /supresses/suppresses/, /dignostics kinds/kinds of diagnostics/

clang/test/CXX/class.access/class.friend/p1.cpp

289

This whitespace diff is gratuitous.

292–301

IMHO it would make sense to add several other variations here too:

template <> A::I g2<char>(A::I i); // expected-error {{is a private member of}}
template <> int g2<A::I>(int i);  // expected-error??
template <> A::I g2<A::I*>(A::I i);  // expected-error??
template A::I g2<char>(A::I i); // expected-error {{is a private member of}}
template int g2<A::I**>(int i);  // OK
template A::I g2<A::I***>(A::I i);  // OK??

It might also be better to use a well-formed template template<class> int g3(int) { return 0; } instead of g2 for the explicit specializations, and to use yet another template template<class> int g4(int) { return 0; } instead of g2 for the explicit instantiation declarations. That way there's no accidental "cross-talk" between the various declarations that might affect what diagnostics get printed.

clang/test/CXX/temp/temp.spec/part.spec.cpp

11

I wonder if this test can be shortened and/or removed, now that you're not doing weird parser tricks that need exhaustive testing. E.g. at least the stuff with the final keyword could be removed now, right?

[aorlov]

@Quuxplusone
Thank you for your comments. I updated the patch according to your suggestions.
Does anyone else from the review list want to waste some time to look at this patch? I would appreciate this.

clang/test/CXX/class.access/class.friend/p1.cpp

289

This is done by clang-format. I think we should keep it here.

[aorlov]

Just a ping.

[aorlov]

Please, look at my solution. Is it worth to be accepted?

[aorlov]

One more ping. Please, pay attention to this patch.

[aorlov]

Hi, community. I kindly ask you to review this patch.

[aorlov]

Ping! Please, don't pass by this patch. I need your competent evaluation to load it!

[aorlov]

Just one more ping!

[aorlov]

Ping! Please, review this patch!

[krisb]

clang/lib/Parse/ParseDecl.cpp

3076

It seems to be a change unrelated to the patch.

clang/lib/Parse/ParseDeclCXX.cpp

1476–1477

The comment needs to be updated.

clang/test/CXX/temp/temp.spec/func.spec.cpp

96

Formatting issue here.

106

Before this patch clang diagnosed cases like

class A { class C {}; };
template <typename T> void func(A::C) {}

Why is it no longer the case?

[aorlov]

@krisb Thank you for your comments. I will consider them.

clang/test/CXX/temp/temp.spec/func.spec.cpp

106

Your example generates an error error: 'C' is a private member of 'A' on latest clang.
This patch is intended to implement a proposal p0692r1 and consider this example as valid.
Did I understand your question correctly?

[krisb]

Do we still need the following tests:

• clang/test/CXX/temp/temp.spec/temp.explicit/p11.cpp
• clang/test/CXX/temp/temp.spec/temp.explicit/p12.cpp

?

clang/test/CXX/temp/temp.spec/func.spec.cpp

106

It doesn't seem the aforementioned example falls under any of the cases from P0692R1 unless I misinterpreted its wordings.
It's a primary template, right?
Consider also the following example for which clang issues the error in both cases (before and after the patch):

class A { class C {}; };
template <class T> A::C func();

I'm also wondering about something like:

class A { class C {}; };
template <typename T> T func() {}
template <> A::C func<A::C>();

clang/test/CXX/temp/temp.spec/part.spec.cpp

4

It seems this test checks more than just partial specialization cases.
Could you please align the comments with what the test actually tests?

[aorlov]

@krisb

In D92024#2677857, @krisb wrote:

Do we still need the following tests:

• clang/test/CXX/temp/temp.spec/temp.explicit/p11.cpp
• clang/test/CXX/temp/temp.spec/temp.explicit/p12.cpp

?

We can remove p11.cpp and partially p12.cpp, because p12 has another kind of test in namespace test0{ ... }.

[aorlov]

clang/test/CXX/temp/temp.spec/func.spec.cpp

106

Oh, I caught the point.
The paper says that the usual access checking rules do not apply to:

• partial specialization
• explicit instantiation
• explicit specialization

Also it comes out from the Standard that the usual access checking rules applies to primary templates, only if they are not declared as friends.

class A { class C {}; };
template <typename T> void func(A::C) {}

It's a primary template, right?

Yes, it is a primary template. The access checking rules should work here. But they do not after this patch. This is a mistake I will sort out.

Consider also the following example for which clang issues the error in both cases (before and after the patch):

class A { class C {}; };
template <class T> A::C func();

This is also a primary template and should be handled with the access rules. The patch turns it off. This is a mistake. I'll handle.

I'm also wondering about something like:

class A { class C {}; };
template <typename T> T func() {}
template <> A::C func<A::C>();

This is an explicit specialization. It should not issue any errors here. The patch handles it correctly. It's OK.

[aorlov]

Updated. @krisb, please, verify.

[krisb]

Thank you! It looks more consistent now.

clang/lib/Parse/ParseDecl.cpp

3087

Basically, if __attribute((unavailable)) should trigger the error for any use of an unavailable class, we have it already broken.
For example, for this code clang-12 doesn't produce any diagnostics:

class __attribute((unavailable)) X {
  template <typename T> class __attribute((unavailable)) Y {};
};
class __attribute((unavailable)) A { 
    class __attribute((unavailable)) C {}; 
};
template <> class X::Y<A::C> {};

So, I don't see much sense in inventing something new to workaround only the cases that come with this patch. It's better to either fix it globally or leave it broken atm with the corresponding FIXME.

clang/test/CXX/temp/temp.spec/func.spec.cpp

55

Formatting seems broken here and below.

[aorlov]

@krisb
Thanks for the review.

clang/lib/Parse/ParseDecl.cpp

3087

Anyway, I tried to remove the access diagnostics only. Who knows which diagnostics may be needed. Or you strongly prefer using SuppressAccessChecks instead?

clang/test/CXX/temp/temp.spec/func.spec.cpp

55

This is clang-format fault. I wrote it at different lines. Just has to add a line between.

[krisb]

clang/lib/Parse/ParseDecl.cpp

3087

Basically, I'd prefer consistency. Having two different ways of doing (almost) the same things doesn't look good to me. But I'm not sure about SuppressAccessChecks as turns all kinds of diagnostics off. Did you consider a possibility to improve SuppressAccessChecks to disable only a particular (specified) type of diagnostics?

[aorlov]

Simplified the solution. Replaced RemoveDiagnosticsFromPool with SuppressAccessChecks.
@krisb, please, look.

[aorlov]

Just a ping!

[krisb]

@aorlov, thank you! LGTM.

clang/lib/Parse/ParseDecl.cpp

while (1) {
     // implementation for VS2013 uses _Atomic as an identifier for one of the
     // classes in <atomic>.
     //
     // A typedef declaration containing _Atomic<...> is among the places where
     // the class is used.  If we are currently parsing such a declaration, treat
     // the token as an identifier.
     if (getLangOpts().MSVCCompat && Tok.is(tok::kw__Atomic) &&
         DS.getStorageClassSpec() == clang::DeclSpec::SCS_typedef &&
         !DS.hasTypeSpecifier() && GetLookAheadToken(1).is(tok::less))
       Tok.setKind(tok::identifier);
 
     SourceLocation Loc = Tok.getLocation();
 
     // Helper for image types in OpenCL.
     auto handleOpenCLImageKW = [&] (StringRef Ext, TypeSpecifierType ImageTypeSpec) {
       // Check if the image type is supported and otherwise turn the keyword into an identifier
       // because image types from extensions are not reserved identifiers.
       if (!StringRef(Ext).empty() && !getActions().getOpenCLOptions().isSupported(Ext, getLangOpts())) {
         Tok.getIdentifierInfo()->revertTokenIDToIdentifier();
         Tok.setKind(tok::identifier);
         return false;
       }
       isInvalid = DS.SetTypeSpecType(ImageTypeSpec, Loc, PrevSpec, DiagID, Policy);
       return true;
     };
 
+    // Turn off usual access checking for template specializations and
+    // instantiations.
+    bool IsTemplateSpecOrInst =
+        (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
+         TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
+
     switch (Tok.getKind()) {
     default:
     DoneWithDeclSpec:
       if (!AttrsLastTime)
         ProhibitAttributes(attrs);
       else {
         // Reject C++11 attributes that appertain to decl specifiers as
         // we don't support any C++11 attributes that appertain to decl
case tok::annot_cxxscope: {
       // shape of a constructor declaration, process it as one.
       if ((DSContext == DeclSpecContext::DSC_top_level ||
            DSContext == DeclSpecContext::DSC_class) &&
           Actions.isCurrentClassName(*Next.getIdentifierInfo(), getCurScope(),
                                      &SS) &&
           isConstructorDeclarator(/*Unqualified*/ false))
         goto DoneWithDeclSpec;
 
+      // C++20 [temp.spec] 13.9/6.
+      // This disables the access checking rules for function template explicit
+      // instantiation and explicit specialization:
+      // - `return type`.
+      SuppressAccessChecks SAC(*this, IsTemplateSpecOrInst);
+
       ParsedType TypeRep =
           Actions.getTypeName(*Next.getIdentifierInfo(), Next.getLocation(),
                               getCurScope(), &SS, false, false, nullptr,
                               /*IsCtorOrDtorName=*/false,
                               /*WantNontrivialTypeSourceInfo=*/true,
                               isClassTemplateDeductionContext(DSContext));
 
+      if (IsTemplateSpecOrInst)
+        SAC.done();
+
       // If the referenced identifier is not a type, then this declspec is
       // erroneous: We already checked about that it has no type specifier, and
       // C++ doesn't have implicit int.  Diagnose it as a typo w.r.t. to the
       // typename.
       if (!TypeRep) {
         if (TryAnnotateTypeConstraint())
           goto DoneWithDeclSpec;
         if (Tok.isNot(tok::annot_cxxscope) ||
case tok::identifier: {
           T.skipToEnd();
           continue;
         }
       }
 
       // In C++, check to see if this is a scope specifier like foo::bar::, if
       // so handle it as such.  This is important for ctor parsing.
       if (getLangOpts().CPlusPlus) {
-        if (TryAnnotateCXXScopeToken(EnteringContext)) {
+        // C++20 [temp.spec] 13.9/6.
+        // This disables the access checking rules for function template
+        // explicit instantiation and explicit specialization:
+        // - `return type`.
+        SuppressAccessChecks SAC(*this, IsTemplateSpecOrInst);
+
+        const bool Success = TryAnnotateCXXScopeToken(EnteringContext);
+
+        if (IsTemplateSpecOrInst)
+          SAC.done();
+
+        if (Success) {
+          if (IsTemplateSpecOrInst)
+            SAC.redelay();
           DS.SetTypeSpecError();
           goto DoneWithDeclSpec;
         }
+
         if (!Tok.is(tok::identifier))
           continue;
       }
 
       // Check for need to substitute AltiVec keyword tokens.
       if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid))
         break;
 

clang/lib/Parse/ParseDeclCXX.cpp

void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
   }
 
   if (Tok.is(tok::code_completion)) {
     // Code completion for a struct, class, or union name.
     cutOffParsing();
     Actions.CodeCompleteTag(getCurScope(), TagType);
     return;
   }
 
-  // C++03 [temp.explicit] 14.7.2/8:
-  //   The usual access checking rules do not apply to names used to specify
-  //   explicit instantiations.
-  //
-  // As an extension we do not perform access checking on the names used to
-  // specify explicit specializations either. This is important to allow
-  // specializing traits classes for private types.
-  //
-  // Note that we don't suppress if this turns out to be an elaborated
-  // type specifier.
-  bool shouldDelayDiagsInTag =
-    (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
-     TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
+  // C++20 [temp.class.spec] 13.7.5/10
+  //   The usual access checking rules do not apply to non-dependent names
+  //   used to specify template arguments of the simple-template-id of the
+  //   partial specialization.
+  // C++20 [temp.spec] 13.9/6:
+  //   The usual access checking rules do not apply to names in a declaration
+  //   of an explicit instantiation or explicit specialization...
+  const bool shouldDelayDiagsInTag =
+      (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate);
   SuppressAccessChecks diagsFromTag(*this, shouldDelayDiagsInTag);
 
   ParsedAttributesWithRange attrs(AttrFactory);
   // If attributes exist after tag, parse them.
   MaybeParseAttributes(PAKM_CXX11 | PAKM_Declspec | PAKM_GNU, attrs);
 
   // Parse inheritance specifiers.
   if (Tok.isOneOf(tok::kw___single_inheritance,
if (AttrRange.isValid()) {
         << FixItHint::CreateRemoval(AttrRange);
 
       // Recover by adding misplaced attributes to the attribute list
       // of the class so they can be applied on the class later.
       attrs.takeAllFrom(Attributes);
     }
   }
 
-  // If this is an elaborated type specifier, and we delayed
-  // diagnostics before, just merge them into the current pool.
-  if (shouldDelayDiagsInTag) {
-    diagsFromTag.done();
-    if (TUK == Sema::TUK_Reference)
-      diagsFromTag.redelay();
-  }
-
   if (!Name && !TemplateId && (DS.getTypeSpecType() == DeclSpec::TST_error ||
                                TUK != Sema::TUK_Definition)) {
     if (DS.getTypeSpecType() != DeclSpec::TST_error) {
       // We have a declaration or reference to an anonymous class.
       Diag(StartLoc, diag::err_anon_type_definition)
         << DeclSpec::getSpecifierName(TagType, Policy);
     }
 
if (TemplateId) {
     // less common call.
     if (IsDependent) {
       assert(TUK == Sema::TUK_Reference || TUK == Sema::TUK_Friend);
       TypeResult = Actions.ActOnDependentTag(getCurScope(), TagType, TUK,
                                              SS, Name, StartLoc, NameLoc);
     }
   }
 
+  // If this is an elaborated type specifier in function template,
+  // and we delayed diagnostics before,
+  // just merge them into the current pool.
+  if (shouldDelayDiagsInTag) {
+    diagsFromTag.done();
+    if (TUK == Sema::TUK_Reference &&
+        TemplateInfo.Kind == ParsedTemplateInfo::Template)
+      diagsFromTag.redelay();
+  }
+
   // If there is a body, parse it and inform the actions module.
   if (TUK == Sema::TUK_Definition) {
     assert(Tok.is(tok::l_brace) ||
            (getLangOpts().CPlusPlus && Tok.is(tok::colon)) ||
            isClassCompatibleKeyword());
     if (SkipBody.ShouldSkip)
       SkipCXXMemberSpecification(StartLoc, AttrFixitLoc, TagType,
                                  TagOrTempResult.get());
Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS,
 
   // decl-specifier-seq:
   // Parse the common declaration-specifiers piece.
   ParsingDeclSpec DS(*this, TemplateDiags);
   DS.takeAttributesFrom(attrs);
   if (MalformedTypeSpec)
     DS.SetTypeSpecError();
 
+  // Turn off usual access checking for templates explicit specialization
+  // and instantiation.
+  // C++20 [temp.spec] 13.9/6.
+  // This disables the access checking rules for member function template
+  // explicit instantiation and explicit specialization.
+  bool IsTemplateSpecOrInst =
+      (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
+       TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
+  SuppressAccessChecks diagsFromTag(*this, IsTemplateSpecOrInst);
+
   ParseDeclarationSpecifiers(DS, TemplateInfo, AS, DeclSpecContext::DSC_class,
                              &CommonLateParsedAttrs);
 
+  if (IsTemplateSpecOrInst)
+    diagsFromTag.done();
+
   // Turn off colon protection that was set for declspec.
   X.restore();
 
   // If we had a free-standing type definition with a missing semicolon, we
   // may get this far before the problem becomes obvious.
   if (DS.hasTagDefinition() &&
       TemplateInfo.Kind == ParsedTemplateInfo::NonTemplate &&
       DiagnoseMissingSemiAfterTagDefinition(DS, AS, DeclSpecContext::DSC_class,
auto TryConsumePureSpecifier = [&] (bool AllowDefinition) {
     return true;
   };
 
   SmallVector<Decl *, 8> DeclsInGroup;
   ExprResult BitfieldSize;
   ExprResult TrailingRequiresClause;
   bool ExpectSemi = true;
 
+  // C++20 [temp.spec] 13.9/6.
+  // This disables the access checking rules for member function template
+  // explicit instantiation and explicit specialization.
+  SuppressAccessChecks SAC(*this, IsTemplateSpecOrInst);
+
   // Parse the first declarator.
   if (ParseCXXMemberDeclaratorBeforeInitializer(
           DeclaratorInfo, VS, BitfieldSize, LateParsedAttrs)) {
     TryConsumeToken(tok::semi);
     return nullptr;
   }
 
+  if (IsTemplateSpecOrInst)
+    SAC.done();
+
   // Check for a member function definition.
   if (BitfieldSize.isUnset()) {
     // MSVC permits pure specifier on inline functions defined at class scope.
     // Hence check for =0 before checking for function definition.
     if (getLangOpts().MicrosoftExt && DeclaratorInfo.isDeclarationOfFunction())
       TryConsumePureSpecifier(/*AllowDefinition*/ true);
 
     FunctionDefinitionKind DefinitionKind = FunctionDefinitionKind::Declaration;

clang/lib/Parse/ParseTemplate.cpp

Decl *Parser::ParseTemplateDeclarationOrSpecialization(
   if (Tok.is(tok::kw_concept))
     return ParseConceptDefinition(
         ParsedTemplateInfo(&ParamLists, isSpecialization,
                            LastParamListWasEmpty),
         DeclEnd);
 
   return ParseSingleDeclarationAfterTemplate(
       Context,
       ParsedTemplateInfo(&ParamLists, isSpecialization, LastParamListWasEmpty),
       ParsingTemplateParams, DeclEnd, AccessAttrs, AS);
 }
 
 /// Parse a single declaration that declares a template,
 /// template specialization, or explicit instantiation of a template.
 ///
 /// \param DeclEnd will receive the source location of the last token
 /// within this declaration.
if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation)
     ProhibitAttributes(prefixAttrs);
   else
     DS.takeAttributesFrom(prefixAttrs);
 
   // Parse the declarator.
   ParsingDeclarator DeclaratorInfo(*this, DS, (DeclaratorContext)Context);
   if (TemplateInfo.TemplateParams)
     DeclaratorInfo.setTemplateParameterLists(*TemplateInfo.TemplateParams);
+
+  // Turn off usual access checking for template specializations and
+  // instantiations.
+  // C++20 [temp.spec] 13.9/6.
+  // This disables the access checking rules for function template explicit
+  // instantiation and explicit specialization:
+  // - parameter-list;
+  // - template-argument-list;
+  // - noexcept-specifier;
+  // - dynamic-exception-specifications (deprecated in C++11, removed since
+  //   C++17).
+  bool IsTemplateSpecOrInst =
+      (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
+       TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
+  SuppressAccessChecks SAC(*this, IsTemplateSpecOrInst);
+
   ParseDeclarator(DeclaratorInfo);
+
+  if (IsTemplateSpecOrInst)
+    SAC.done();
+
   // Error parsing the declarator?
   if (!DeclaratorInfo.hasName()) {
     // If so, skip until the semi-colon or a }.
     SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
     if (Tok.is(tok::semi))
       ConsumeToken();
     return nullptr;
   }
 
   llvm::TimeTraceScope TimeScope("ParseTemplate", [&]() {
     return std::string(DeclaratorInfo.getIdentifier() != nullptr
                            ? DeclaratorInfo.getIdentifier()->getName()
                            : "<unknown>");
   });
 
   LateParsedAttrList LateParsedAttrs(true);
   if (DeclaratorInfo.isFunctionDeclarator()) {
     if (Tok.is(tok::kw_requires))
       ParseTrailingRequiresClause(DeclaratorInfo);
 
     MaybeParseGNUAttributes(DeclaratorInfo, &LateParsedAttrs);

clang/test/CXX/class.access/class.friend/p1.cpp

#endif
   template<> X<int>::~X() {
     A a; // expected-error {{calling a private constructor}}
   }
 }
 
 // Return types, parameters and default arguments to friend functions.
 namespace test8 {
   class A {
-    typedef int I; // expected-note 4 {{declared private here}}
+    typedef int I;        // expected-note 6 {{declared private here}}
     static const I x = 0; // expected-note {{implicitly declared private here}}
     friend I f(I i);
     template<typename T> friend I g(I i);
   };
 
   const A::I A::x;
   A::I f(A::I i = A::x) {}
   template<typename T> A::I g(A::I i) {
     T t;
   }
   template A::I g<A::I>(A::I i);
 
   A::I f2(A::I i = A::x) {} // expected-error 3 {{is a private member of}}
   template<typename T> A::I g2(A::I i) { // expected-error 2 {{is a private member of}}
     T t;
   }
-  template A::I g2<A::I>(A::I i);
+  template <> A::I g2<char>(A::I i) { return 0; } // OK
+  template A::I g2<A::I>(A::I i);                 // OK
+  template <> A::I g2<char>(A::I i);              // OK
+  template <> A::I g2<A::I *>(A::I i);            // OK
+  template A::I g2<unsigned>(A::I i);             // OK
+  template int g2<A::I **>(int i);                // OK
+  template A::I g2<A::I ***>(A::I i);             // OK
+
+  template <typename T> A::I g3(A::I i) { return 0; } // expected-error 2 {{is a private member of}}
+  template <> int g3<A::I>(int i);                    // OK
 }
 
 // PR6885
 namespace test9 {
   class B {
     friend class test9;
   };
 }

clang/test/CXX/drs/dr1xx.cpp

template <class T> struct C {
     void f();
     void g();
   };
 
   template <class T> void C<T>::f() {}
   template <class T> void C<T>::g() {}
 
   class A {
-    class B {}; // expected-note {{here}}
+    class B {};
     void f();
   };
 
   template void C<A::B>::f();
-  template <> void C<A::B>::g(); // expected-error {{private}}
+  template <> void C<A::B>::g();
 
   void A::f() {
     C<B> cb;
     cb.f();
   }
 }
 
 namespace dr183 { // dr183: sup 382

clang/test/CXX/temp/temp.spec/func.spec.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -verify %s
+
+// C++20 [temp.spec] 13.9/6:
+//   The usual access checking rules do not apply to names in a declaration
+//   of an explicit instantiation or explicit specialization, with the
+//   exception of names appearing in a function body, default argument,
+//   base-clause, member-specification, enumerator-list, or static data member
+//   or variable template initializer.
+//   [Note : In particular, the template arguments and names used in the
+//   function declarator(including parameter types, return types and exception
+//   specifications) may be private types or objects that would normally not be
+//   accessible. — end note]
+
+class A {
+  // expected-note@+1 17{{implicitly declared private here}}
+  template <typename T> class B {};
+  // expected-note@+1 3{{implicitly declared private here}}
+  static constexpr int num1 = 42;
+
+protected:
+  // expected-note@+1 13{{declared protected here}}
+  class C {};
+  // expected-note@+1 2{{declared protected here}}
+  static constexpr int num2 = 43;
+  static int num4;
+
+public:
+  template <typename T> class D {};
+  static constexpr int num3 = 44;
+};
+int A::num4 = 44;
+
+class E : public A {
+
+  // Declarations
+
+  // expected-error@+1 {{is a private member of}}
+  template <typename T = A::B<int>> void func1();
+  template <typename T = A::C> void func2();
+  template <typename T = class A::D<int>> void func3();
+  // expected-error@+1 {{is a private member of}}
+  template <typename T> A::B<int> func4();
+  // expected-error@+1 {{is a private member of}}
+  template <typename T> A::B<T> func5();
+  template <typename T> class A::C func6();
+  template <typename T> class A::D<int> func7();
+  // expected-error@+1 2{{is a private member of}}
+  template <typename T> void func8(class A::B<T>, int x = A::num1);
+  template <typename T> void func9(A::C, A::D<T>, int = A::num3);
+
+  // Specializations inside class declaration
+  template <> void func1<A::B<char>>() {}
+  template <> void func2<class A::D<char>>() {
+  } template <> void func3<class A::C>() {
+  }
+  template <> class A::B<int> func4<A::B<char>>() { return {}; } template <> A::B<A::D<int>> func5<A::D<int>>() {
+    return {};
+  }
+  template <> class A::C func6<A::C>() { return {}; } template <> A::D<int> func7<char>() {
+    return {};
+  }
+  template <> void func8<char>(class A::B<char>, int) {}
+  template <> void func9<A::B<char>>(A::C, A::D<A::B<char>>, int) {}
+
+  // FIXME: Instantiations inside class declaration.
+  // don't work correctly.
+};
+
+// Definitions
+
+template <typename T> void E::func1() {}
+template <typename T> void E::func2() {}
+template <typename T> void E::func3() {}
+// expected-error@+1 {{is a private member of}}
+template <typename T> A::B<int> E::func4() { return {}; }
+// expected-error@+1 {{is a private member of}}
+template <typename T> A::B<T> E::func5() { return {}; }
+template <typename T> A::C E::func6() { return {}; }
+template <typename T> A::D<int> E::func7() { return {}; }
+// expected-error@+1 {{is a private member of}}
+template <typename T> void E::func8(A::B<T>, int) {}
+template <typename T> void E::func9(A::C, A::D<T>, int) {}
+
+// Specializations
+
+template <> void E::func1<A::B<int>>() {}
+template <> void E::func2<class A::C>() {}
+template <> void E::func3<class A::D<int>>() {
+} template <> class A::B<int> E::func4<A::B<int>>() {
+  return {};
+} template <> A::B<A::C> E::func5<A::C>() {
+  return {};
+}
+template <> class A::C E::func6<A::D<int>>() { return {}; } template <> A::D<int> E::func7<int>() {
+  return {};
+}
+template <> void E::func8<int>(class A::B<int>, int) {}
+template <> void E::func9<A::C>(A::C, A::D<A::C>, int) {}
+
+// Instantiations
+
+template <> void E::func1<A::B<int>>();
+template <> void E::func2<class A::C>();
+template <> void E::func3<class A::D<int>>();
+template <> class A::B<int> E::func4<A::B<int>>();
+template <> A::B<A::C> E::func5<A::C>();
+template <> class A::C E::func6<A::D<int>>();
+template <> A::D<int> E::func7<int>();
+template <> void E::func8<int>(class A::B<int>, int);
+template <> void E::func9<A::C>(A::C, A::D<A::C>, int);
+
+//----------------------------------------------------------//
+
+// forward declarations
+
+// expected-error@+1 {{is a protected member of}}
+template <typename T> class A::C func1();
+// expected-error@+1 {{is a private member of}}
+template <typename T> A::B<T> func2();
+template <typename T> A::D<T> func3();
+// expected-error@+1 {{is a private member of}}
+template <typename T> class A::B<int> func4();
+template <typename T> void func5();
+// expected-error@+1 {{is a private member of}}
+template <int x = A::num1> void func6();
+// expected-error@+1 {{is a protected member of}}
+template <int x = A::num2> void func7();
+// expected-error@+1 {{is a protected member of}}
+template <typename T> void func8(int x = sizeof(A::C));
+// expected-error@+1 {{is a private member of}}
+template <typename T> void func9(int x = A::num1);
+// expected-error@+2 {{is a private member of}}
+// expected-error@+1 {{is a protected member of}}
+template <typename T> void func10(class A::B<T>, int x = A::num2);
+// expected-error@+1 {{is a protected member of}}
+template <typename T> void func11(class A::C, A::D<T>, int = A::num3);
+template <typename T> void func12();
+template <int x> void func13();
+template <typename T, int x> void func14();
+template <template <typename> typename T> void func15();
+// expected-error@+1 {{is a protected member of}}
+template <typename T = A::C> void func16();
+// expected-error@+1 {{is a private member of}}
+template <typename T = A::B<int>> void func17();
+// expected-error@+1 {{is a protected member of}}
+template <typename T> auto func18() -> A::C;
+template <typename T> T func19();
+
+//----------------------------------------------------------//
+
+// definitions
+
+// expected-error@+1 2{{is a protected member of}}
+template <typename T> A::C func1() { A::C x; }
+// expected-error@+2 {{is a private member of}}
+// expected-error@+1 {{is a protected member of}}
+template <typename T> A::B<T> func2() { A::D<A::C> x; }
+template <typename T> A::D<T> func3() { A::D<int> x; }
+// expected-error@+2 2{{is a private member of}}
+// expected-error@+1 {{is a protected member of}}
+template <typename T> class A::B<int> func4() { A::B<A::C> x; }
+
+template <typename T>
+void func5() {
+  // expected-error@+2 {{is a private member of}}
+  // expected-error@+1 {{is a protected member of}}
+  A::B<A::D<A::C>> x;
+  // expected-error@+1 {{is a private member of}}
+  A::B<int> x2;
+}
+template <typename T> void func8(int x) {}
+template <typename T> void func9(int x) {}
+// expected-error@+1 {{is a private member of}}
+template <typename T> void func10(A::B<T>, int x) {}
+// expected-error@+1 {{is a protected member of}}
+template <typename T> void func11(A::C, A::D<T>, int) {}
+template <typename T> void func12() {}
+template <int x> void func13() {}
+template <typename T, int x> void func14() {}
+template <template <typename> typename T> void func15() {}
+template <typename T> void func16() {}
+template <typename T> void func17() {}
+// expected-error@+1 {{is a protected member of}}
+template <typename T> auto func18() -> A::C {
+  // expected-error@+1 {{is a protected member of}}
+  return A::C{};
+}
+template <typename T> T func19() {
+  return T{};
+}
+
+//----------------------------------------------------------//
+
+// explicit specializations
+
+template <> A::C func1<A::C>();
+template <> A::B<A::C> func2<A::C>();
+template <> A::D<A::C> func3<A::C>();
+template <> class A::B<int> func4<A::C>();
+template <> void func5<A::C>();
+template <> void func5<A::B<int>>();
+template <> void func5<A::D<A::C>>();
+template <> void func5<int>();
+template <> void func8<A::C>(int x);
+template <> void func9<decltype(A::num1)>(int);
+template <> void func10<A::D<int>>(A::B<A::D<int>>, int);
+template <> void func11<A::C>(A::C, A::D<A::C>, int);
+template <> void func12<class A::B<char>>() {
+} template <> void func13<A::num1>() {
+}
+template <> void func14<A::B<int>, A::num2>() {}
+template <> void func15<A::D>() {}
+template <> void func16<class A::B<char>>() {
+} template <> void func17<A::B<class A::C>>() {
+}
+template <> auto func18<int>() -> class A::C;
+template <> A::B<int> func19<class A::B<int>>();
+
+//----------------------------------------------------------//
+
+// explicit instantiations
+
+template void func10<A::C>(A::B<A::C>, decltype(A::num1));
+template void func11<A::B<int>>(A::C, A::D<A::B<int>>, decltype(A::num2));
+template void func12<A::C>();
+template void func13<A::num2>();
+template void func13<A::num3>();
+template void func14<A::C, A::num1>();
+template void func15<A::B>();
+template void func17();
+template auto func18<char>() -> A::C;
+template class A::C func19<A::C>();
+
+//----------------------------------------------------------//
+
+// Other cases
+
+template <int *x> class StealClass {
+  friend int stealFunc() { return *x; }
+};
+
+template class StealClass<&A::num4>;
+int stealFunc();
+
+int stealFunc2() {
+  return stealFunc();
+}

clang/test/CXX/temp/temp.spec/part.spec.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// C++20 [temp.class.spec] 13.7.5/10
+//   The usual access checking rules do not apply to non-dependent names
+//   used to specify template arguments of the simple-template-id of the
+//   partial specialization.
+//
+// C++20 [temp.spec] 13.9/6:
+//   The usual access checking rules do not apply to names in a declaration
+//   of an explicit instantiation or explicit specialization...
+
+// TODO: add test cases for `enum`
+
+// class for tests
+class TestClass {
+public:
+  class PublicClass {};
+  template <class T> class TemplatePublicClass {};
+
+  using AliasPublicClass = unsigned char;
+
+  void publicFunc();
+  void publicFuncOverloaded();
+  void publicFuncOverloaded(int);
+
+  static void publicStaticFunc();
+  static void publicStaticFuncOverloaded();
+  static void publicStaticFuncOverloaded(int);
+
+  static constexpr int publicStaticInt = 42;
+
+protected:
+  // expected-note@+1 8{{declared protected here}}
+  class ProtectedClass {};
+  template <class T> class TemplateProtectedClass {};
+
+  // expected-note@+1 2{{declared protected here}}
+  using AliasProtectedClass = const char;
+
+  // expected-note@+1 3{{declared protected here}}
+  void protectedFunc();
+  void protectedFuncOverloaded();
+  void protectedFuncOverloaded(int);
+
+  // expected-note@+1 2{{declared protected here}}
+  static void protectedStaticFunc();
+  // expected-note@+1 2{{declared protected here}}
+  static void protectedStaticFuncOverloaded();
+  static void protectedStaticFuncOverloaded(int);
+
+  // expected-note@+1 2{{declared protected here}}
+  static constexpr int protectedStaticInt = 43;
+
+private:
+  // expected-note@+1 10{{declared private here}}
+  class PrivateClass {};
+  // expected-note@+1 {{declared private here}}
+  template <class T> class TemplatePrivateClass {};
+
+  using AliasPrivateClass = char *;
+
+  void privateFunc();
+  void privateFuncOverloaded();
+  void privateFuncOverloaded(int);
+
+  static void privateStaticFunc();
+  static void privateStaticFuncOverloaded();
+  static void privateStaticFuncOverloaded(int);
+
+  static constexpr int privateStaticInt = 44;
+};
+
+void globalFunction() {}
+
+//----------------------------------------------------------//
+
+// template declarations for explicit instantiations
+template <typename T> class IT1 {};
+template <typename T1, typename T2> class IT2 {};
+template <int X> class IT3 {};
+template <void (TestClass::*)()> class IT4 {};
+template <void (*)()> class IT5 {};
+template <typename T> class IT6 {
+  template <typename NT> class NIT1 {};
+};
+template <typename T1, typename T2> class IT7 {};
+template <void (TestClass::*)(), int X> class IT8 {};
+template <typename T, void (*)()> class IT9 {};
+
+// explicit instantiations
+
+// public
+template class IT1<TestClass::PublicClass>;
+template struct IT1<TestClass::TemplatePublicClass<int>>;
+template class IT1<TestClass::AliasPublicClass>;
+template struct IT2<TestClass::PublicClass, TestClass::PublicClass>;
+template class IT3<TestClass::publicStaticInt>;
+template struct IT4<&TestClass::publicFunc>;
+template class IT4<&TestClass::publicFuncOverloaded>;
+template class IT5<&TestClass::publicStaticFunc>;
+template class IT5<&TestClass::publicStaticFuncOverloaded>;
+template class IT5<&globalFunction>;
+template class IT6<TestClass::PublicClass>::template NIT1<TestClass::PublicClass>;
+template class IT7<TestClass::AliasPublicClass, TestClass::PublicClass>;
+template struct IT7<TestClass::PublicClass, TestClass::TemplatePublicClass<TestClass::PublicClass>>;
+template class IT8<&TestClass::publicFunc, TestClass::publicStaticInt>;
+template class IT8<&TestClass::publicFuncOverloaded, TestClass::publicStaticInt>;
+template class IT9<TestClass::PublicClass, &TestClass::publicStaticFunc>;
+template class IT9<TestClass::PublicClass, &TestClass::publicStaticFuncOverloaded>;
+template class IT9<TestClass::PublicClass, &globalFunction>;
+
+// protected
+template class IT1<TestClass::ProtectedClass>;
+template struct IT1<TestClass::TemplateProtectedClass<int>>;
+template class IT1<TestClass::AliasProtectedClass>;
+template struct IT2<TestClass::ProtectedClass, TestClass::ProtectedClass>;
+template class IT3<TestClass::protectedStaticInt>;
+template struct IT4<&TestClass::protectedFunc>;
+template class IT4<&TestClass::protectedFuncOverloaded>;
+template class IT5<&TestClass::protectedStaticFunc>;
+template class IT5<&TestClass::protectedStaticFuncOverloaded>;
+template class IT6<TestClass::ProtectedClass>::template NIT1<TestClass::ProtectedClass>;
+template class IT7<TestClass::AliasProtectedClass, TestClass::ProtectedClass>;
+template struct IT7<TestClass::ProtectedClass, TestClass::TemplateProtectedClass<TestClass::ProtectedClass>>;
+template class IT8<&TestClass::protectedFunc, TestClass::protectedStaticInt>;
+template class IT8<&TestClass::protectedFuncOverloaded, TestClass::protectedStaticInt>;
+template class IT9<TestClass::ProtectedClass, &TestClass::protectedStaticFunc>;
+template class IT9<TestClass::ProtectedClass, &TestClass::protectedStaticFuncOverloaded>;
+template class IT9<TestClass::ProtectedClass, &globalFunction>;
+
+// private
+template class IT1<TestClass::PrivateClass>;
+template struct IT1<TestClass::TemplatePrivateClass<int>>;
+template class IT1<TestClass::AliasPrivateClass>;
+template struct IT2<TestClass::PrivateClass, TestClass::PrivateClass>;
+template class IT3<TestClass::privateStaticInt>;
+template struct IT4<&TestClass::privateFunc>;
+template class IT4<&TestClass::privateFuncOverloaded>;
+template class IT5<&TestClass::privateStaticFunc>;
+template class IT5<&TestClass::privateStaticFuncOverloaded>;
+template class IT6<TestClass::PrivateClass>::template NIT1<TestClass::PrivateClass>;
+template class IT7<TestClass::AliasPrivateClass, TestClass::PrivateClass>;
+template struct IT7<TestClass::PrivateClass, TestClass::TemplatePrivateClass<TestClass::PrivateClass>>;
+template class IT8<&TestClass::privateFunc, TestClass::privateStaticInt>;
+template class IT8<&TestClass::privateFuncOverloaded, TestClass::privateStaticInt>;
+template class IT9<TestClass::PrivateClass, &TestClass::privateStaticFunc>;
+template class IT9<TestClass::PrivateClass, &TestClass::privateStaticFuncOverloaded>;
+template class IT9<TestClass::PrivateClass, &globalFunction>;
+
+//----------------------------------------------------------//
+
+// template declarations for full specializations
+template <typename T> class CT1 {};
+template <typename T1, typename T2> class CT2 {};
+template <int X> class CT3 {};
+template <void (TestClass::*)()> class CT4 {};
+template <void (*)()> class CT5 {};
+template <typename T> class CT6 {
+  template <typename NT> class NCT1 {};
+  template <typename NT> class NCT2; // forward declaration
+};
+
+// full specializations
+
+// public
+template <> class CT1<TestClass::PublicClass>;
+template <typename T> class CT1<TestClass::TemplatePublicClass<T>>; // not full but let it be here
+template <> struct CT1<TestClass::TemplatePublicClass<int>>;
+template <> class CT1<TestClass::AliasPublicClass>;
+template <> struct CT2<TestClass::PublicClass, TestClass::PublicClass>;
+template <> class CT3<TestClass::publicStaticInt>;
+template <> struct CT4<&TestClass::publicFunc>;
+template <> class CT4<&TestClass::publicFuncOverloaded>;
+template <> struct CT5<&TestClass::publicStaticFunc>;
+template <> class CT5<&TestClass::publicStaticFuncOverloaded>;
+template <> class CT5<&globalFunction>;
+template <> template <> class CT6<TestClass::PublicClass>::NCT1<TestClass::PublicClass>;
+
+template <> class CT1<TestClass::PublicClass> final {};
+template <typename T> class CT1<TestClass::TemplatePublicClass<T>> {};
+template <> class CT1<TestClass::TemplatePublicClass<int>> final {};
+template <> class CT1<TestClass::AliasPublicClass> {};
+template <> class CT2<TestClass::PublicClass, TestClass::PublicClass> final {};
+template <> class CT3<TestClass::publicStaticInt> {};
+template <> class CT4<&TestClass::publicFunc> final {};
+template <> class CT4<&TestClass::publicFuncOverloaded> {};
+template <> class CT5<&TestClass::publicStaticFunc> final {};
+template <> class CT5<&TestClass::publicStaticFuncOverloaded> {};
+template <> class CT5<&globalFunction> final {};
+template <> template <> class CT6<TestClass::PublicClass>::NCT1<TestClass::PublicClass> {};
+template <> template <typename NT> class CT6<TestClass::PublicClass>::NCT2 final {}; // declaration
+
+// protected
+template <> class CT1<TestClass::ProtectedClass>;
+template <typename T> class CT1<TestClass::TemplateProtectedClass<T>>; // not full but let it be here
+template <> class CT1<TestClass::TemplateProtectedClass<int>>;
+template <> struct CT1<TestClass::AliasProtectedClass>;
+template <> class CT2<TestClass::ProtectedClass, TestClass::ProtectedClass>;
+template <> struct CT3<TestClass::protectedStaticInt>;
+template <> class CT4<&TestClass::protectedFunc>;
+template <> struct CT4<&TestClass::protectedFuncOverloaded>;
+template <> class CT5<&TestClass::protectedStaticFunc>;
+template <> class CT5<&TestClass::protectedStaticFuncOverloaded>;
+template <> template <> class CT6<TestClass::ProtectedClass>::NCT1<TestClass::ProtectedClass>;
+
+template <> class CT1<TestClass::ProtectedClass> {};
+template <typename T> class CT1<TestClass::TemplateProtectedClass<T>> final {}; // not full but let it be here
+template <> class CT1<TestClass::TemplateProtectedClass<int>> {};
+template <> class CT1<TestClass::AliasProtectedClass> final {};
+template <> class CT2<TestClass::ProtectedClass, TestClass::ProtectedClass> {};
+template <> class CT3<TestClass::protectedStaticInt> final {};
+template <> class CT4<&TestClass::protectedFunc> {};
+template <> class CT4<&TestClass::protectedFuncOverloaded> final {};
+template <> class CT5<&TestClass::protectedStaticFunc> {};
+template <> class CT5<&TestClass::protectedStaticFuncOverloaded> final {};
+template <> template <> class CT6<TestClass::ProtectedClass>::NCT1<TestClass::ProtectedClass> {};
+template <> template <typename NT> class CT6<TestClass::ProtectedClass>::NCT2 final {}; // declaration
+
+// private
+template <> class CT1<TestClass::PrivateClass>;
+template <typename T> class CT1<TestClass::TemplatePrivateClass<T>>; // not full but let it be here
+template <> struct CT1<TestClass::TemplatePrivateClass<int>>;
+template <> class CT1<TestClass::AliasPrivateClass>;
+template <> struct CT2<TestClass::PrivateClass, TestClass::PrivateClass>;
+template <> class CT3<TestClass::privateStaticInt>;
+template <> struct CT4<&TestClass::privateFunc>;
+template <> class CT4<&TestClass::privateFuncOverloaded>;
+template <> class CT5<&TestClass::privateStaticFunc>;
+template <> class CT5<&TestClass::privateStaticFuncOverloaded>;
+template <> template <> class CT6<TestClass::PrivateClass>::NCT1<TestClass::PrivateClass>;
+
+template <> class CT1<TestClass::PrivateClass> final {};
+template <typename T> class CT1<TestClass::TemplatePrivateClass<T>> {}; // not full but let it be here
+template <> class CT1<TestClass::TemplatePrivateClass<int>> final {};
+template <> class CT1<TestClass::AliasPrivateClass> {};
+template <> class CT2<TestClass::PrivateClass, TestClass::PrivateClass> final {};
+template <> class CT3<TestClass::privateStaticInt> {};
+template <> class CT4<&TestClass::privateFunc> final {};     // PR37424
+template <> class CT4<&TestClass::privateFuncOverloaded> {}; // PR37424
+template <> class CT5<&TestClass::privateStaticFunc> final {};
+template <> class CT5<&TestClass::privateStaticFuncOverloaded> {};
+template <> template <> class CT6<TestClass::PrivateClass>::NCT1<TestClass::PrivateClass> final {};
+template <> template <typename NT> class CT6<TestClass::PrivateClass>::NCT2 {}; // declaration
+
+//----------------------------------------------------------//
+
+// template declarations for full specializations with parents
+class P1 {};
+template <typename T> class PCT1 {};
+template <typename T1, typename T2> class PCT2 {};
+template <int X> class PCT3 {};
+template <void (TestClass::*)()> class PCT4 {};
+template <void (*)()> class PCT5 {};
+template <typename T> class PCT6 {
+  // expected-note@+1 3{{implicitly declared private here}}
+  template <typename NT> class NPCT1 {};
+  // expected-note@+1 {{template is declared here}}
+  template <typename NT> class NPCT2; // forward declaration
+};
+
+// full specializations with parents
+
+// protected + public
+template <> class PCT1<TestClass::PublicClass> : P1 {};
+template <typename T> class PCT1<TestClass::TemplatePublicClass<T>> : PCT2<TestClass::PublicClass, TestClass::PublicClass> {}; // not full but let it be here
+template <> struct PCT1<TestClass::TemplatePublicClass<int>> : PCT1<TestClass::AliasPublicClass> {};
+template <> class PCT1<TestClass::AliasProtectedClass> : PCT2<TestClass::PublicClass, int> {};
+template <> struct PCT2<TestClass::ProtectedClass, TestClass::PublicClass> : PCT3<TestClass::publicStaticInt> {};
+template <> class PCT3<TestClass::protectedStaticInt> : PCT4<&TestClass::publicFunc> {};
+template <> struct PCT4<&TestClass::protectedFunc> : PCT5<&TestClass::publicStaticFunc> {};
+template <> class PCT4<&TestClass::publicFuncOverloaded> : PCT5<&TestClass::publicStaticFuncOverloaded> {};
+template <> class PCT5<&TestClass::protectedStaticFunc> : PCT5<&TestClass::publicStaticFuncOverloaded> {};
+// expected-error@+1 {{is a private member of}}
+template <> class PCT5<&TestClass::protectedStaticFuncOverloaded> : PCT6<TestClass::PublicClass>::NPCT1<TestClass::PublicClass> {};
+// expected-error@+2 {{is a protected member of}}
+// expected-error@+1 {{is a private member of}}
+template <> class PCT5<&globalFunction> : PCT6<TestClass::ProtectedClass>::NPCT1<int> {};
+template <> template <typename NT> class PCT6<TestClass::PublicClass>::NPCT2 : P1 {}; // declaration
+template <> template <> class PCT6<TestClass::PublicClass>::NPCT1<TestClass::ProtectedClass> : PCT6<TestClass::PublicClass>::template NPCT2<int> {};
+
+// protected + private
+template <> class PCT1<TestClass::PrivateClass> : P1 {};
+// expected-error@+2 {{is a protected member of}}
+// expected-error@+1 {{is a private member of}}
+template <typename T> class PCT1<TestClass::TemplatePrivateClass<T>> : PCT2<TestClass::PrivateClass, TestClass::ProtectedClass> {}; // not full but let it be here
+// expected-error@+1 {{is a protected member of}}
+template <> class PCT1<TestClass::TemplatePrivateClass<int>> : PCT1<TestClass::AliasProtectedClass> {};
+// expected-error@+2 {{is a protected member of}}
+// expected-error@+1 {{is a private member of}}
+template <> class PCT1<TestClass::AliasPrivateClass> : PCT2<TestClass::ProtectedClass, TestClass::PrivateClass> {};
+// expected-error@+1 {{is a protected member of}}
+template <> class PCT2<TestClass::PrivateClass, TestClass::PrivateClass> : PCT3<TestClass::protectedStaticInt> {};
+// expected-error@+1 {{is a protected member of}}
+template <> class PCT3<TestClass::privateStaticInt> : PCT4<&TestClass::protectedFunc> {};
+// expected-error@+1 {{is a protected member of}}
+template <> class PCT4<&TestClass::privateFunc> : PCT5<&TestClass::protectedStaticFunc> {};
+// expected-error@+1 {{is a protected member of}}
+template <> class PCT4<&TestClass::privateFuncOverloaded> : PCT5<&TestClass::protectedStaticFuncOverloaded> {};
+template <> class PCT5<&TestClass::privateStaticFunc> : P1 {};
+// expected-error@+2 {{implicit instantiation of undefined template}}
+// expected-error@+1 {{is a private member of}}
+template <> template <> class PCT6<TestClass::PrivateClass>::NPCT1<TestClass::PrivateClass> : PCT6<TestClass::PrivateClass>::NPCT2<int> {};
+// expected-error@+1 3{{is a private member of}}
+template <> class PCT5<&TestClass::privateStaticFuncOverloaded> : PCT6<TestClass::PrivateClass>::NPCT1<TestClass::PrivateClass> {};
+template <> template <typename NT> class PCT6<TestClass::PrivateClass>::NPCT2 : P1 {}; // declaration
+
+//----------------------------------------------------------//
+
+// template declarations for partial specializations
+template <typename T1, typename T2> class CTT1 {};
+template <typename T1, typename T2, typename T3> class CTT2 {};
+template <typename T, int X> class CTT3 {};
+template <typename T, void (TestClass::*)()> class CTT4 {};
+template <typename T, void (*)()> class CTT5 {};
+template <typename T1, typename T2> class CTT6 {
+  template <typename NT> class NCT1 {};
+  template <typename NT> class NCT2; // forward declaration
+  template <typename NT1, typename NT2> class NCT3 {};
+  template <typename NT1, typename NT2> class NCT4; // forward declaration
+};
+
+// partial specializations
+
+// public
+template <typename T> class CTT1<T, TestClass::PublicClass> final {};
+template <typename T> class CTT1<T, TestClass::TemplatePublicClass<T>> {};
+template <typename T> struct CTT1<T, TestClass::TemplatePublicClass<int>> final {};
+template <typename T> class CTT1<T, TestClass::AliasPublicClass> {};
+template <typename T> struct CTT2<T, TestClass::PublicClass, TestClass::PublicClass> final {};
+template <typename T> struct CTT2<TestClass::PublicClass, T, TestClass::PublicClass> {};
+template <typename T> class CTT2<TestClass::PublicClass, TestClass::PublicClass, T> final {};
+template <typename T> class CTT3<T, TestClass::publicStaticInt> {};
+template <typename T> class CTT4<T, &TestClass::publicFunc> final {};
+template <typename T> class CTT4<T, &TestClass::publicFuncOverloaded> {};
+template <typename T> class CTT5<T, &TestClass::publicStaticFunc> final {};
+template <typename T> class CTT5<T, &TestClass::publicStaticFuncOverloaded> {};
+template <typename T> class CTT5<T, &globalFunction> final {};
+// expected-error@+1 {{cannot specialize a dependent template}}
+template <typename T1> template <typename T2> class CTT6<T1, TestClass::PublicClass>::template NCT1<T2 *> {};
+template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT1<T3 *> final {};
+template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT2 {}; // declaration
+template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT2<T3 *> final {};
+template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT3<T3, TestClass::PublicClass> {};
+// expected-error@+1 {{cannot specialize a dependent template}}
+template <typename T1> template <typename T2> class CTT6<T1, TestClass::PublicClass>::template NCT3<T2, TestClass::PublicClass> final {};
+template <typename T1, typename T2> template <typename T3, typename T4> class CTT6<T1, T2>::NCT4 {}; // declaration
+template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT4<T3, TestClass::PublicClass> final {};
+template <typename T> class CTT6<TestClass::PublicClass, T> {
+  template <typename T1, typename T2> class NCT3 {};
+  template <typename T1, typename T2> class NCT4;
+};
+template <typename T1> template <typename T2> class CTT6<TestClass::PublicClass, T1>::NCT3<T2, TestClass::PublicClass> {};
+template <typename T1> template <typename, typename> class CTT6<TestClass::PublicClass, T1>::NCT4 final {};
+template <typename T1> template <typename T2> class CTT6<TestClass::PublicClass, T1>::NCT4<T2, TestClass::PublicClass> {};
+
+// protected
+
+template <typename T> class CTT1<T, TestClass::ProtectedClass> {};
+template <typename T> class CTT1<T, TestClass::TemplateProtectedClass<T>> final {};
+template <typename T> struct CTT1<T, TestClass::TemplateProtectedClass<int>> {};
+template <typename T> class CTT1<T, TestClass::AliasProtectedClass> final {};
+template <typename T> struct CTT2<T, TestClass::ProtectedClass, TestClass::ProtectedClass> {};
+template <typename T> class CTT2<TestClass::ProtectedClass, T, TestClass::ProtectedClass> final {};
+template <typename T> struct CTT2<TestClass::ProtectedClass, TestClass::ProtectedClass, T> {};
+template <typename T> class CTT3<T, TestClass::protectedStaticInt> final {};
+template <typename T> class CTT4<T, &TestClass::protectedFunc> {};
+template <typename T> class CTT4<T, &TestClass::protectedFuncOverloaded> final {};
+template <typename T> class CTT5<T, &TestClass::protectedStaticFunc> {};
+template <typename T> class CTT5<T, &TestClass::protectedStaticFuncOverloaded> final {};
+// expected-error@+1 {{cannot specialize a dependent template}}
+template <typename T1> template <typename T2> class CTT6<T1, TestClass::ProtectedClass>::template NCT1<T2 *> {};
+template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT3<T3, TestClass::ProtectedClass> final {};
+// expected-error@+1 {{cannot specialize a dependent template}}
+template <typename T1> template <typename T2> class CTT6<T1, TestClass::ProtectedClass>::template NCT3<T2, TestClass::ProtectedClass> {};
+template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT4<T3, TestClass::ProtectedClass> final {};
+template <typename T> class CTT6<TestClass::ProtectedClass, T> {
+  template <typename T1, typename T2> class NCT3 {};
+  template <typename T1, typename T2> class NCT4;
+};
+template <typename T1> template <typename T2> class CTT6<TestClass::ProtectedClass, T1>::NCT3<T2, TestClass::ProtectedClass> final {};
+template <typename T1> template <typename, typename> class CTT6<TestClass::ProtectedClass, T1>::NCT4 {};
+template <typename T1> template <typename T2> class CTT6<TestClass::ProtectedClass, T1>::NCT4<T2, TestClass::ProtectedClass> final {};
+
+// private
+
+template <typename T> class CTT1<T, TestClass::PrivateClass> final {};
+template <typename T> class CTT1<T, TestClass::TemplatePrivateClass<T>> {};
+template <typename T> struct CTT1<T, TestClass::TemplatePrivateClass<int>> final {};
+template <typename T> class CTT1<T, TestClass::AliasPrivateClass> {};
+template <typename T> struct CTT2<T, TestClass::PrivateClass, TestClass::PrivateClass> final {};
+template <typename T> class CTT2<TestClass::PrivateClass, T, TestClass::PrivateClass> {};
+template <typename T> struct CTT2<TestClass::PrivateClass, TestClass::PrivateClass, T> final {};
+template <typename T> class CTT3<T, TestClass::privateStaticInt> {};
+template <typename T> class CTT4<T, &TestClass::privateFunc> final {};
+template <typename T> class CTT4<T, &TestClass::privateFuncOverloaded> {};
+template <typename T> class CTT5<T, &TestClass::privateStaticFunc> final {};
+template <typename T> class CTT5<T, &TestClass::privateStaticFuncOverloaded> {};
+// expected-error@+1 {{cannot specialize a dependent template}}
+template <typename T1> template <typename T2> class CTT6<T1, TestClass::PrivateClass>::template NCT1<T2 *> final {};
+template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT3<T3, TestClass::PrivateClass> {};
+// expected-error@+1 {{cannot specialize a dependent template}}
+template <typename T1> template <typename T2> class CTT6<T1, TestClass::PrivateClass>::template NCT3<T2, TestClass::PrivateClass> final {};
+template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT4<T3, TestClass::PrivateClass> {};
+template <typename T> class CTT6<TestClass::PrivateClass, T> {
+  template <typename T1, typename T2> class NCT3 {};
+  template <typename T1, typename T2> class NCT4;
+};
+template <typename T1> template <typename T2> class CTT6<TestClass::PrivateClass, T1>::NCT3<T2, TestClass::PrivateClass> {};
+template <typename T1> template <typename, typename> class CTT6<TestClass::PrivateClass, T1>::NCT4 final {};
+template <typename T1> template <typename T2> class CTT6<TestClass::PrivateClass, T1>::NCT4<T2, TestClass::PrivateClass> final {};
+
+//----------------------------------------------------------//
+
+// template declarations for partial specializations with parents
+template <typename T1, typename T2> class PCTT1 {};
+template <typename T1, typename T2, typename T3> class PCTT2 {};
+template <typename T, int X> class PCTT3 {};
+template <typename T, void (TestClass::*)()> class PCTT4 {};
+template <typename T, void (*)()> class PCTT5 {};
+template <typename T1, typename T2> class PCTT6 {
+  template <typename NT> class NCT1 {};
+  template <typename NT> class NCT2; // forward declaration
+  template <typename NT1, typename NT2> class NCT3 {};
+  template <typename NT1, typename NT2> class NCT4; // forward declaration
+};
+
+// partial specializations with parents
+
+// protected + public
+template <typename T> class PCTT1<T, TestClass::PublicClass> : P1 {};
+template <typename T> struct PCTT1<T, TestClass::TemplatePublicClass<T>> final : PCTT2<T, TestClass::PublicClass, TestClass::PublicClass> {}; // not full but let it be here
+template <typename T> class PCTT1<T, TestClass::TemplatePublicClass<int>> : PCTT1<T, TestClass::AliasPublicClass> {};
+// expected-error@+1 {{is a protected member of}}
+template <typename T> class PCTT1<T, TestClass::TemplatePublicClass<TestClass::TemplateProtectedClass<T>>> final : PCTT1<T, TestClass::ProtectedClass> {};
+template <typename T> struct PCTT1<T, TestClass::AliasProtectedClass> : PCTT2<T, TestClass::PublicClass, int> {};
+template <typename T> class PCTT2<T, TestClass::ProtectedClass, TestClass::PublicClass> final : PCTT3<T, TestClass::publicStaticInt> {};
+template <typename T> class PCTT3<T, TestClass::protectedStaticInt> : PCTT4<T, &TestClass::publicFunc> {};
+template <typename T> struct PCTT4<T, &TestClass::protectedFunc> final : PCTT5<T, &TestClass::publicStaticFunc> {};
+template <typename T> class PCTT4<T, &TestClass::publicFuncOverloaded> : PCTT5<T, &TestClass::publicStaticFuncOverloaded> {};
+template <typename T> class PCTT5<T, &TestClass::protectedStaticFunc> final : PCTT5<T, &TestClass::publicStaticFuncOverloaded> {};
+template <typename T> class PCTT5<T, &TestClass::protectedStaticFuncOverloaded> : PCTT6<T, TestClass::PublicClass>::template NCT1<TestClass::PublicClass> {};
+// expected-error@+1 {{is a protected member of}}
+template <typename T> class PCTT5<T, &globalFunction> : PCTT6<T, TestClass::ProtectedClass>::template NCT1<int> {};
+// expected-error@+1 {{is a protected member of}}
+template <typename T1, typename T2> template <typename T3> class PCTT6<T1, T2>::NCT2 final : PCTT4<T1, &TestClass::protectedFunc> {}; // declaration
+template <typename T1, typename T2> template <typename T3> class PCTT6<T1, T2>::NCT2<T3 *> : P1 {};
+// expected-error@+2 {{cannot specialize a dependent template}}
+// expected-error@+1 {{is a protected member of}}
+template <typename T> template <typename NT> class PCTT6<T, TestClass::ProtectedClass>::template NCT1<NT *> : PCTT6<T, TestClass::ProtectedClass>::template NCT2<int> {};
+
+// protected + private
+template <typename T> class PCTT1<T, TestClass::PrivateClass> : P1 {};
+// expected-error@+2 {{is a protected member of}}
+// expected-error@+1 {{is a private member of}}
+template <typename T> struct PCTT1<T, TestClass::TemplatePrivateClass<T>> final : PCTT2<T, TestClass::PrivateClass, TestClass::ProtectedClass> {}; // not full but let it be here
+// expected-error@+1 {{is a protected member of}}
+template <typename T> class PCTT1<T, TestClass::TemplatePrivateClass<int>> : PCTT1<T, TestClass::AliasProtectedClass> {};
+// expected-error@+2 {{is a protected member of}}
+// expected-error@+1 {{is a private member of}}
+template <typename T> struct PCTT1<T, TestClass::AliasPrivateClass> final : PCTT2<T, TestClass::ProtectedClass, TestClass::PrivateClass> {};
+// expected-error@+1 {{is a protected member of}}
+template <typename T> class PCTT2<T, TestClass::PrivateClass, TestClass::TemplatePrivateClass<T>> : PCTT3<T, TestClass::protectedStaticInt> {};
+// expected-error@+1 {{is a protected member of}}
+template <typename T> class PCTT3<T, TestClass::privateStaticInt> final : PCTT4<T, &TestClass::protectedFunc> {};
+// expected-error@+1 {{is a protected member of}}
+template <typename T> struct PCTT4<T, &TestClass::privateFunc> : PCTT5<T, &TestClass::protectedStaticFunc> {};
+// expected-error@+1 {{is a protected member of}}
+template <typename T> class PCTT4<T, &TestClass::privateFuncOverloaded> final : PCTT5<T, &TestClass::protectedStaticFuncOverloaded> {};
+template <typename T> class PCTT5<T, &TestClass::privateStaticFunc> : P1 {};
+// expected-error@+2 {{cannot specialize a dependent template}}
+// expected-error@+1 {{is a private member of}}
+template <typename T> class PCTT6<T, TestClass::PrivateClass>::template PCTT1<TestClass::PrivateClass> : PCTT6<T, TestClass::PrivateClass>::template NCT2<int> {};
+// expected-error@+1 {{is a private member of}}
+template <typename T> class PCTT5<T, &TestClass::privateStaticFuncOverloaded> final : PCTT6<T, T>::template NCT1<TestClass::PrivateClass> {};
+template <typename T> class PCTT6<TestClass::PrivateClass, T> {
+  template <typename T1, typename T2> class NCT3 final {};
+  template <typename T1, typename T2> class NCT4;
+};
+template <typename T1> template <typename, typename> class PCTT6<TestClass::PrivateClass, T1>::NCT4 final {};
+// expected-error@+1 2{{is a private member of}}
+template <typename T1> template <typename T2> struct PCTT6<TestClass::PrivateClass, T1>::template NCT3<T2, TestClass::TemplatePrivateClass<TestClass::TemplateProtectedClass<TestClass::PublicClass>>> : PCTT6<TestClass::PrivateClass, T1>::NCT4<T2, TestClass::TemplatePrivateClass<int>> {};

clang/test/CXX/temp/temp.spec/temp.explicit/p11.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
-// expected-no-diagnostics
-
-class X {
-  template <typename T> class Y {};
-};
-
-class A {
-  class B {};
-  class C {};
-};
-
-// C++0x [temp.explicit] 14.7.2/11:
-//   The usual access checking rules do not apply to names used to specify
-//   explicit instantiations.
-template class X::Y<A::B>;
-
-// As an extension, this rule is applied to explicit specializations as well.
-template <> class X::Y<A::C> {};

clang/test/CXX/temp/temp.spec/temp.explicit/p12.cpp

namespace test2 {
   template <class T> class Temp {
     static Temp<A::Public> make();
   };
   template <> class Temp<A::Private> {
   public:
     Temp(int x) {}
   };
 
-  template <> class Temp<A::Private> Temp<int>::make() { // expected-error {{'Private' is a private member of 'test2::A'}}
+  template <> class Temp<A::Private> Temp<int>::make() {
     return Temp<A::Public>(0);
   }
+
+  template <>
+  class Temp<char> {
+    static Temp<A::Private> make() { // expected-error {{is a private member}}
+      return Temp<A::Public>(0);
+    }
+  };
 }