c++: constrained partial spec using qualified name [PR92944, PR103678]

In the nested_name_specifier branch within cp_parser_class_head, we need
to update 'type' with the result of maybe_process_partial_specialization
like we do in the template_id_p branch.

	PR c++/92944
	PR c++/103678

gcc/cp/ChangeLog:

	* parser.cc (cp_parser_class_head): Update 'type' with the result
	of maybe_process_partial_specialization in the
	nested_name_specifier branch.  Refactor nearby code to accomodate
	that maybe_process_partial_specialization returns a _TYPE, not a
	TYPE_DECL, and eliminate local variable 'class_type' in passing.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp2a/concepts-partial-spec10.C: New test.
	* g++.dg/cpp2a/concepts-partial-spec11.C: New test.

diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
index 8b38165..f1947ee 100644 (file)
--- a/gcc/cp/parser.cc
+++ b/gcc/cp/parser.cc
@@ -26535,7 +26535,7 @@ cp_parser_class_head (cp_parser* parser,
     }
   else if (nested_name_specifier)
     {
-      tree class_type;
+      type = TREE_TYPE (type);
 
       /* Given:
 
@@ -26545,31 +26545,27 @@ cp_parser_class_head (cp_parser* parser,
         we will get a TYPENAME_TYPE when processing the definition of
         `S::T'.  We need to resolve it to the actual type before we
         try to define it.  */
-      if (TREE_CODE (TREE_TYPE (type)) == TYPENAME_TYPE)
+      if (TREE_CODE (type) == TYPENAME_TYPE)
        {
-         class_type = resolve_typename_type (TREE_TYPE (type),
-                                             /*only_current_p=*/false);
-         if (TREE_CODE (class_type) != TYPENAME_TYPE)
-           type = TYPE_NAME (class_type);
-         else
+         type = resolve_typename_type (type, /*only_current_p=*/false);
+         if (TREE_CODE (type) == TYPENAME_TYPE)
            {
              cp_parser_error (parser, "could not resolve typename type");
              type = error_mark_node;
            }
        }
 
-      if (maybe_process_partial_specialization (TREE_TYPE (type))
-         == error_mark_node)
+      type = maybe_process_partial_specialization (type);
+      if (type == error_mark_node)
        {
          type = NULL_TREE;
          goto done;
        }
 
-      class_type = current_class_type;
       /* Enter the scope indicated by the nested-name-specifier.  */
       pushed_scope = push_scope (nested_name_specifier);
       /* Get the canonical version of this type.  */
-      type = TYPE_MAIN_DECL (TREE_TYPE (type));
+      type = TYPE_MAIN_DECL (type);
       /* Call push_template_decl if it seems like we should be defining a
         template either from the template headers or the type we're
         defining, so that we diagnose both extra and missing headers.  */

diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-partial-spec10.C b/gcc/testsuite/g++.dg/cpp2a/concepts-partial-spec10.C
new file mode 100644 (file)
index 0000000..d45a1b0
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp2a/concepts-partial-spec10.C
@@ -0,0 +1,17 @@
+// PR c++/92944
+// { dg-do compile { target c++20 } }
+
+namespace ns { template<class T> struct A { }; }
+
+template<class T> requires true struct ns::A<T> { using type = T; };
+template<class T> requires false struct ns::A<T> { };
+
+template<class T> struct ns::A<T*> { };
+template<class T> requires true struct ns::A<T*> { using type = T; };
+template<class T> requires false struct ns::A<T*> { };
+
+using ty1 = ns::A<int>::type;
+using ty1 = int;
+
+using ty2 = ns::A<int*>::type;
+using ty2 = int;

diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-partial-spec11.C b/gcc/testsuite/g++.dg/cpp2a/concepts-partial-spec11.C
new file mode 100644 (file)
index 0000000..0333450
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp2a/concepts-partial-spec11.C
@@ -0,0 +1,19 @@
+// PR c++/103678
+// { dg-do compile { target c++20 } }
+
+template<class>
+struct A {
+ template<class...>
+ struct B;
+};
+
+template<class A_t>
+template<class B_t>
+struct A<A_t>::B<B_t> {};
+
+template<class A_t>
+template<class B_t>
+requires requires {
+ typename B_t;
+}
+struct A<A_t>::B<B_t> {};