c++: context completion in lookup_template_class [PR105982]

The below testcase demonstrates that completion of the substituted
context during lookup_template_class can end up registering the desired
specialization for us in more cases than r13-1045-gcb7fd1ea85feea
anticipated.  In particular this can happen for a non-dependent
specialization of a nested class as well.

For this testcase, during overload resolution with A's guides, we
substitute the deduced argument T=int into the TYPENAME_TYPE B::C,
during which we call lookup_template_class for A<T>::B with T=int,
which completes A<int> for the first time, which recursively registers
the desired specialization of B already.  The parent call to
lookup_template_class then tries to register the same specialization,
triggering an ICE.

This patch fixes this by making lookup_template_class determine more
directly whether we need to recheck the specializations table after
completion of the context -- when and only when the call to complete_type
had an effect.

	PR c++/105982

gcc/cp/ChangeLog:

	* pt.cc (lookup_template_class): After calling complete_type for
	the substituted context, check the table again iff the type was
	previously incomplete and complete_type made it complete.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp1z/class-deduction111.C: New test.

diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
index 12a2b57..8672da1 100644 (file)
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -10089,16 +10089,19 @@ lookup_template_class (tree d1, tree arglist, tree in_decl, tree context,
            {
              context = tsubst_aggr_type (context, arglist,
                                          complain, in_decl, true);
-             context = complete_type (context);
-             if (is_dependent_type && arg_depth > 1)
+             /* Try completing the enclosing context if it's not already so.  */
+             if (context != error_mark_node
+                 && !COMPLETE_TYPE_P (context))
                {
-                 /* If this is a dependent nested specialization such as
-                    A<T>::B<U> [with T=int, U=U], then completion of A<int>
-                    could have caused to register the desired specialization
-                    of B already, so check the table again (33959).  */
-                 entry = type_specializations->find_with_hash (&elt, hash);
-                 if (entry)
-                   return entry->spec;
+                 context = complete_type (context);
+                 if (COMPLETE_TYPE_P (context))
+                   {
+                     /* Completion could have caused us to register the desired
+                        specialization already, so check the table again.  */
+                     entry = type_specializations->find_with_hash (&elt, hash);
+                     if (entry)
+                       return entry->spec;
+                   }
                }
            }
        }

diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction111.C b/gcc/testsuite/g++.dg/cpp1z/class-deduction111.C
new file mode 100644 (file)
index 0000000..2406529
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction111.C
@@ -0,0 +1,10 @@
+// PR c++/105982
+// { dg-do compile { target c++17 } }
+
+template<class T>
+struct A {
+  struct B { struct C { }; };
+  A(T, typename B::C);
+};
+
+A a(0, {});