aorlov created this revision.
aorlov added reviewers: broadwaylamb, rsmith, saar.raz, doug.gregor.
aorlov added projects: LLVM, clang.
Herald added a subscriber: cfe-commits.
aorlov requested review of this revision.
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
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D92024
Files:
clang/include/clang/Parse/Parser.h
clang/lib/Parse/ParseDecl.cpp
clang/lib/Parse/ParseDeclCXX.cpp
clang/lib/Parse/ParseTemplate.cpp
clang/test/CXX/drs/dr1xx.cpp
clang/test/CXX/temp/temp.spec/func.spec.cpp
clang/test/CXX/temp/temp.spec/part.spec.cpp
Index: clang/test/CXX/temp/temp.spec/part.spec.cpp
===================================================================
--- /dev/null
+++ clang/test/CXX/temp/temp.spec/part.spec.cpp
@@ -0,0 +1,321 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// C++20 [temp.class.spec] 17.6.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.
+
+// 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:
+ class ProtectedClass {};
+ template <class T> class TemplateProtectedClass {};
+
+ using AliasProtectedClass = const char;
+
+ void protectedFunc();
+ void protectedFuncOverloaded();
+ void protectedFuncOverloaded(int);
+
+ static void protectedStaticFunc();
+ static void protectedStaticFuncOverloaded();
+ static void protectedStaticFuncOverloaded(int);
+
+ static constexpr int protectedStaticInt = 43;
+
+private:
+ class PrivateClass {};
+ 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 full
+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>>;
+template <> class CT1<TestClass::TemplatePublicClass<int>>;
+template <> class CT1<TestClass::AliasPublicClass>;
+template <> class CT2<TestClass::PublicClass, TestClass::PublicClass>;
+template <> class CT3<TestClass::publicStaticInt>;
+template <> class CT4<&TestClass::publicFunc>;
+template <> class CT4<&TestClass::publicFuncOverloaded>;
+template <> class 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> {};
+template <typename T> class CT1<TestClass::TemplatePublicClass<T>> {};
+template <> class CT1<TestClass::TemplatePublicClass<int>> {};
+template <> class CT1<TestClass::AliasPublicClass> {};
+template <> class CT2<TestClass::PublicClass, TestClass::PublicClass> {};
+template <> class CT3<TestClass::publicStaticInt> {};
+template <> class CT4<&TestClass::publicFunc> {};
+template <> class CT4<&TestClass::publicFuncOverloaded> {};
+template <> class CT5<&TestClass::publicStaticFunc> {};
+template <> class CT5<&TestClass::publicStaticFuncOverloaded> {};
+template <> class CT5<&globalFunction> {};
+template <> template <> class CT6<TestClass::PublicClass>::NCT1<TestClass::PublicClass> {};
+template <> template <typename NT> class CT6<TestClass::PublicClass>::NCT2 {}; // declaration
+
+// protected
+template <> class CT1<TestClass::ProtectedClass>;
+template <typename T> class CT1<TestClass::TemplateProtectedClass<T>>;
+template <> class CT1<TestClass::TemplateProtectedClass<int>>;
+template <> class CT1<TestClass::AliasProtectedClass>;
+template <> class CT2<TestClass::ProtectedClass, TestClass::ProtectedClass>;
+template <> class CT3<TestClass::protectedStaticInt>;
+template <> class CT4<&TestClass::protectedFunc>;
+template <> class 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>> {};
+template <> class CT1<TestClass::TemplateProtectedClass<int>> {};
+template <> class CT1<TestClass::AliasProtectedClass> {};
+template <> class CT2<TestClass::ProtectedClass, TestClass::ProtectedClass> {};
+template <> class CT3<TestClass::protectedStaticInt> {};
+template <> class CT4<&TestClass::protectedFunc> {};
+template <> class CT4<&TestClass::protectedFuncOverloaded> {};
+template <> class CT5<&TestClass::protectedStaticFunc> {};
+template <> class CT5<&TestClass::protectedStaticFuncOverloaded> {};
+template <> template <> class CT6<TestClass::ProtectedClass>::NCT1<TestClass::ProtectedClass> {};
+template <> template <typename NT> class CT6<TestClass::ProtectedClass>::NCT2 {}; // declaration
+
+// private
+template <> class CT1<TestClass::PrivateClass>;
+template <typename T> class CT1<TestClass::TemplatePrivateClass<T>>;
+template <> class CT1<TestClass::TemplatePrivateClass<int>>;
+template <> class CT1<TestClass::AliasPrivateClass>;
+template <> class CT2<TestClass::PrivateClass, TestClass::PrivateClass>;
+template <> class CT3<TestClass::privateStaticInt>;
+template <> class 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> {};
+template <typename T> class CT1<TestClass::TemplatePrivateClass<T>> {};
+template <> class CT1<TestClass::TemplatePrivateClass<int>> {};
+template <> class CT1<TestClass::AliasPrivateClass> {};
+template <> class CT2<TestClass::PrivateClass, TestClass::PrivateClass> {};
+template <> class CT3<TestClass::privateStaticInt> {};
+template <> class CT4<&TestClass::privateFunc> {}; // PR37424
+template <> class CT4<&TestClass::privateFuncOverloaded> {}; // PR37424
+template <> class CT5<&TestClass::privateStaticFunc> {};
+template <> class CT5<&TestClass::privateStaticFuncOverloaded> {};
+template <> template <> class CT6<TestClass::PrivateClass>::NCT1<TestClass::PrivateClass> {};
+template <> template <typename NT> class CT6<TestClass::PrivateClass>::NCT2 {}; // declaration
+
+// template declarations for full final
+template <typename T> class FCT1 {};
+template <typename T1, typename T2> class FCT2 {};
+template <int X> class FCT3 {};
+template <void (TestClass::*)()> class FCT4 {};
+template <void (*)()> class FCT5 {};
+template <typename T> class FCT6 {
+ template <typename NT> class NCT1 {};
+ template <typename NT> class NCT2; // forward declaration
+};
+
+// full final specializations
+
+// public
+template <> class FCT1<TestClass::PublicClass> final {};
+template <typename T> class FCT1<TestClass::TemplatePublicClass<T>> final {};
+template <> class FCT1<TestClass::TemplatePublicClass<int>> final {};
+template <> class FCT1<TestClass::AliasPublicClass> final {};
+template <> class FCT2<TestClass::PublicClass, TestClass::PublicClass> final {};
+template <> class FCT3<TestClass::publicStaticInt> final {};
+template <> class FCT4<&TestClass::publicFunc> final {};
+template <> class FCT4<&TestClass::publicFuncOverloaded> final {};
+template <> class FCT5<&TestClass::publicStaticFunc> final {};
+template <> class FCT5<&TestClass::publicStaticFuncOverloaded> final {};
+template <> class FCT5<&globalFunction> final {};
+template <> template <> class FCT6<TestClass::PublicClass>::NCT1<TestClass::PublicClass> final {};
+template <> template <typename NT> class FCT6<TestClass::PublicClass>::NCT2 final {};
+
+// protected
+template <> class FCT1<TestClass::ProtectedClass> final {};
+template <typename T> class FCT1<TestClass::TemplateProtectedClass<T>> final {};
+template <> class FCT1<TestClass::TemplateProtectedClass<int>> final {};
+template <> class FCT1<TestClass::AliasProtectedClass> final {};
+template <> class FCT2<TestClass::ProtectedClass, TestClass::ProtectedClass> final {};
+template <> class FCT3<TestClass::protectedStaticInt> final {};
+template <> class FCT4<&TestClass::protectedFunc> final {};
+template <> class FCT4<&TestClass::protectedFuncOverloaded> final {};
+template <> class FCT5<&TestClass::protectedStaticFunc> final {};
+template <> class FCT5<&TestClass::protectedStaticFuncOverloaded> final {};
+template <> template <> class FCT6<TestClass::ProtectedClass>::NCT1<TestClass::ProtectedClass> final {};
+template <> template <typename NT> class FCT6<TestClass::ProtectedClass>::NCT2 final {};
+
+// private
+template <> class FCT1<TestClass::PrivateClass> final {};
+template <typename T> class FCT1<TestClass::TemplatePrivateClass<T>> final {};
+template <> class FCT1<TestClass::TemplatePrivateClass<int>> final {};
+template <> class FCT1<TestClass::AliasPrivateClass> final {};
+template <> class FCT2<TestClass::PrivateClass, TestClass::PrivateClass> final {};
+template <> class FCT3<TestClass::privateStaticInt> final {};
+template <> class FCT4<&TestClass::privateFunc> final {};
+template <> class FCT4<&TestClass::privateFuncOverloaded> final {};
+template <> class FCT5<&TestClass::privateStaticFunc> final {};
+template <> class FCT5<&TestClass::privateStaticFuncOverloaded> final {};
+template <> template <> class FCT6<TestClass::PrivateClass>::NCT1<TestClass::PrivateClass> final {};
+template <> template <typename NT> class FCT6<TestClass::PrivateClass>::NCT2 final {};
+
+//----------------------------------------------------------//
+
+// template declarations for partial
+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> {};
+template <typename T> class CTT1<T, TestClass::TemplatePublicClass<T>> {};
+template <typename T> class CTT1<T, TestClass::TemplatePublicClass<int>> {};
+template <typename T> class CTT1<T, TestClass::AliasPublicClass> {};
+template <typename T> class CTT2<T, TestClass::PublicClass, TestClass::PublicClass> {};
+template <typename T> class CTT2<TestClass::PublicClass, T, TestClass::PublicClass> {};
+template <typename T> class CTT2<TestClass::PublicClass, TestClass::PublicClass, T> {};
+template <typename T> class CTT3<T, TestClass::publicStaticInt> {};
+template <typename T> class CTT4<T, &TestClass::publicFunc> {};
+template <typename T> class CTT4<T, &TestClass::publicFuncOverloaded> {};
+template <typename T> class CTT5<T, &TestClass::publicStaticFunc> {};
+template <typename T> class CTT5<T, &TestClass::publicStaticFuncOverloaded> {};
+template <typename T> class CTT5<T, &globalFunction> {};
+// 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 *> {};
+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 *> {};
+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> {};
+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> {};
+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 {};
+template <typename T1> template <typename T2> class CTT6<TestClass::PublicClass, T1>::NCT4<T2, TestClass::PublicClass> {};
+template <typename T1, typename T2, typename T3> using PublicAlias1 = class CTT6<T1, T2>::template NCT4<T3, TestClass::PublicClass>;
+template <typename T1, typename T3> using PublicAlias2 = class CTT6<TestClass::PublicClass, T1>::template NCT4<T3, TestClass::PublicClass>;
+
+// protected
+
+template <typename T> class CTT1<T, TestClass::ProtectedClass> {};
+template <typename T> class CTT1<T, TestClass::TemplateProtectedClass<T>> {};
+template <typename T> class CTT1<T, TestClass::TemplateProtectedClass<int>> {};
+template <typename T> class CTT1<T, TestClass::AliasProtectedClass> {};
+template <typename T> class CTT2<T, TestClass::ProtectedClass, TestClass::ProtectedClass> {};
+template <typename T> class CTT2<TestClass::ProtectedClass, T, TestClass::ProtectedClass> {};
+template <typename T> class CTT2<TestClass::ProtectedClass, TestClass::ProtectedClass, T> {};
+template <typename T> class CTT3<T, TestClass::protectedStaticInt> {};
+template <typename T> class CTT4<T, &TestClass::protectedFunc> {};
+template <typename T> class CTT4<T, &TestClass::protectedFuncOverloaded> {};
+template <typename T> class CTT5<T, &TestClass::protectedStaticFunc> {};
+template <typename T> class CTT5<T, &TestClass::protectedStaticFuncOverloaded> {};
+// 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> {};
+// 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> {};
+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> {};
+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> {};
+template <typename T1, typename T2, typename T3> using ProtectedAlias1 = class CTT6<T1, T2>::template NCT4<T3, TestClass::ProtectedClass>;
+template <typename T1, typename T3> using ProtectedAlias2 = class CTT6<TestClass::ProtectedClass, T1>::template NCT4<T3, TestClass::ProtectedClass>;
+
+// private
+
+template <typename T> class CTT1<T, TestClass::PrivateClass> {};
+template <typename T> class CTT1<T, TestClass::TemplatePrivateClass<T>> {};
+template <typename T> class CTT1<T, TestClass::TemplatePrivateClass<int>> {};
+template <typename T> class CTT1<T, TestClass::AliasPrivateClass> {};
+template <typename T> class CTT2<T, TestClass::PrivateClass, TestClass::PrivateClass> {};
+template <typename T> class CTT2<TestClass::PrivateClass, T, TestClass::PrivateClass> {};
+template <typename T> class CTT2<TestClass::PrivateClass, TestClass::PrivateClass, T> {};
+template <typename T> class CTT3<T, TestClass::privateStaticInt> {};
+template <typename T> class CTT4<T, &TestClass::privateFunc> {};
+template <typename T> class CTT4<T, &TestClass::privateFuncOverloaded> {};
+template <typename T> class CTT5<T, &TestClass::privateStaticFunc> {};
+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 *> {};
+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> {};
+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 {};
+template <typename T1> template <typename T2> class CTT6<TestClass::PrivateClass, T1>::NCT4<T2, TestClass::PrivateClass> {};
+template <typename T1, typename T2, typename T3> using PrivateAlias1 = class CTT6<T1, T2>::template NCT4<T3, TestClass::PrivateClass>;
+template <typename T1, typename T3> using PrivateAlias2 = class CTT6<TestClass::PrivateClass, T1>::template NCT4<T3, TestClass::PrivateClass>;
Index: clang/test/CXX/temp/temp.spec/func.spec.cpp
===================================================================
--- /dev/null
+++ clang/test/CXX/temp/temp.spec/func.spec.cpp
@@ -0,0 +1,90 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// C++20 [temp.explicit] 17.8/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.
+
+class A {
+ // expected-note@+1 14{{implicitly declared private here}}
+ template <typename T> class B {};
+ // expected-note@+1 {{implicitly declared private here}}
+ static constexpr int num = 42;
+
+protected:
+ // expected-note@+1 9{{declared protected here}}
+ class C {};
+ // expected-note@+1 {{declared protected here}}
+ static constexpr int num2 = 42;
+
+public:
+ template <typename T> class D {};
+};
+
+class E : public A {
+ template <typename T> 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();
+
+ template <> A::C func1<A::C>();
+ // expected-error@+1 {{is a private member of}}
+ template <> A::B<A::C> func2<A::C>();
+ template <> A::D<A::C> func3<A::C>();
+ // expected-error@+1 {{is a private member of}}
+ template <> class A::B<int> func4<A::C>();
+ template <> void func5<A::C>();
+ // expected-error@+1 {{is a private member of}}
+ template <> void func5<A::B<int>>();
+ template <> void func5<A::D<A::C>>();
+ template <> void func5<int>();
+};
+
+// expected-error@+1 {{is a protected member of}}
+template <typename T> 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::num> void func6();
+// expected-error@+1 {{is a protected member of}}
+template <int x = A::num2> void func7();
+
+// 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;
+}
+
+// expected-error@+1 {{is a protected member of}}
+template <> A::C func1<A::C>();
+// expected-error@+2 {{is a private member of}}
+// expected-error@+1 {{is a protected member of}}
+template <> A::B<A::C> func2<A::C>();
+// expected-error@+1 {{is a protected member of}}
+template <> A::D<A::C> func3<A::C>();
+// expected-error@+1 {{is a private member of}}
+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>();
\ No newline at end of file
Index: clang/test/CXX/drs/dr1xx.cpp
===================================================================
--- clang/test/CXX/drs/dr1xx.cpp
+++ clang/test/CXX/drs/dr1xx.cpp
@@ -934,12 +934,12 @@
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;
Index: clang/lib/Parse/ParseTemplate.cpp
===================================================================
--- clang/lib/Parse/ParseTemplate.cpp
+++ clang/lib/Parse/ParseTemplate.cpp
@@ -167,6 +167,59 @@
LastParamListWasEmpty),
DeclEnd);
+ // This is a quick trick to identify a partial specialization before the
+ // next forward parsing.
+ // Look for any empty temp-arg-list in the sequence of templates
+ // E.g. `template<class A> template<class B> template<> template<class C>`
+ // ~~~~~~~~~~~~Here we've got it.~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~
+ for (auto list : ParamLists)
+ if (!list->size()) {
+ isSpecialization = true;
+ break;
+ }
+
+ // Check whether it is a partial specialization.
+
+ // TODO. This can produce wrong detection in case of a later class
+ // declaration. Example:
+ // // forward declaration of a nested class C2
+ // template<class T1> C1 {template<class T2> C2;};
+ // //later declaration of a class C2 End example.
+ // template<class T1> template<class T2> C1<T>::C2 {};
+
+ // Keyword `using` means that it'a an alias declaration.
+ if (!isSpecialization && !ParamLists.empty() && Tok.isNot(tok::kw_using) &&
+ Tok.isOneOf(tok::kw_class, tok::kw_struct, tok::kw_union)) {
+ // Next sequences of tokens can surely identify a partial specialization:
+ // `>::` in `class A<B>::C{};`
+ // `>{` in `class A::B<C>{};`
+ // `> final` in `class A::B<C> final {};`
+ // `>;` in `class A::B<C>;`
+ // `>>::` in `class A<B<D>>::C{};`
+ // `>>{` in `class A::B<C<D>>{};`
+ // `>> final` in `class A::B<C<D>> final {};`
+ // `>>;` in `class A::B<C<D>>;`
+ // `>>>::` in `class A<B<D<E>>>::C{};`
+ // `>>>{` in `class A::B<C<D<E>>>{};`
+ // `>>> final` in `class A::B<C<D<E>>> final {};`
+ // `>>>;` in `class A::B<C<D<E>>>;`
+ int TokIdx = 0;
+ Token NextTok;
+ Token NextNextTok = GetLookAheadToken(TokIdx++);
+ // Look ahead untill `{` or `;`.
+ while (!NextNextTok.isOneOf(tok::l_brace, tok::semi)) {
+ NextTok = NextNextTok;
+ NextNextTok = GetLookAheadToken(TokIdx++);
+
+ if (NextTok.isOneOf(tok::greater, tok::greatergreater,
+ tok::greatergreatergreater) &&
+ (NextNextTok.isOneOf(tok::coloncolon, tok::l_brace, tok::semi) ||
+ (NextNextTok.is(tok::identifier) &&
+ isCXX11FinalKeyword(NextNextTok))))
+ isSpecialization = true;
+ }
+ }
+
return ParseSingleDeclarationAfterTemplate(
Context,
ParsedTemplateInfo(&ParamLists, isSpecialization, LastParamListWasEmpty),
@@ -245,6 +298,11 @@
else
DS.takeAttributesFrom(prefixAttrs);
+ const bool NeedSuppressAccessChecks =
+ (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
+ TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
+ SuppressAccessChecks SuppressAccessGuard(*this, NeedSuppressAccessChecks);
+
// Parse the declarator.
ParsingDeclarator DeclaratorInfo(*this, DS, (DeclaratorContext)Context);
if (TemplateInfo.TemplateParams)
@@ -259,6 +317,9 @@
return nullptr;
}
+ if (NeedSuppressAccessChecks)
+ SuppressAccessGuard.done();
+
llvm::TimeTraceScope TimeScope("ParseTemplate", [&]() {
return std::string(DeclaratorInfo.getIdentifier() != nullptr
? DeclaratorInfo.getIdentifier()->getName()
Index: clang/lib/Parse/ParseDeclCXX.cpp
===================================================================
--- clang/lib/Parse/ParseDeclCXX.cpp
+++ clang/lib/Parse/ParseDeclCXX.cpp
@@ -1770,14 +1770,6 @@
}
}
- // 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) {
@@ -1950,6 +1942,14 @@
}
}
+ // 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 there is a body, parse it and inform the actions module.
if (TUK == Sema::TUK_Definition) {
assert(Tok.is(tok::l_brace) ||
@@ -2292,8 +2292,8 @@
/// isCXX11FinalKeyword - Determine whether the next token is a C++11
/// 'final' or Microsoft 'sealed' contextual keyword.
-bool Parser::isCXX11FinalKeyword() const {
- VirtSpecifiers::Specifier Specifier = isCXX11VirtSpecifier();
+bool Parser::isCXX11FinalKeyword(const Token &Tok) const {
+ VirtSpecifiers::Specifier Specifier = isCXX11VirtSpecifier(Tok);
return Specifier == VirtSpecifiers::VS_Final ||
Specifier == VirtSpecifiers::VS_GNU_Final ||
Specifier == VirtSpecifiers::VS_Sealed;
Index: clang/lib/Parse/ParseDecl.cpp
===================================================================
--- clang/lib/Parse/ParseDecl.cpp
+++ clang/lib/Parse/ParseDecl.cpp
@@ -2998,7 +2998,7 @@
// 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))
+ !DS.hasTypeSpecifier() && NextToken().is(tok::less))
Tok.setKind(tok::identifier);
SourceLocation Loc = Tok.getLocation();
Index: clang/include/clang/Parse/Parser.h
===================================================================
--- clang/include/clang/Parse/Parser.h
+++ clang/include/clang/Parse/Parser.h
@@ -2846,7 +2846,8 @@
void ParseOptionalCXX11VirtSpecifierSeq(VirtSpecifiers &VS, bool IsInterface,
SourceLocation FriendLoc);
- bool isCXX11FinalKeyword() const;
+ bool isCXX11FinalKeyword(const Token &Tok) const;
+ bool isCXX11FinalKeyword() const { return isCXX11FinalKeyword(Tok); }
/// DeclaratorScopeObj - RAII object used in Parser::ParseDirectDeclarator to
/// enter a new C++ declarator scope and exit it when the function is
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
