[gcc r14-12702] c++: substituting fn parm redeclared with dep alias tmpl [PR120224]

[Patrick Palka]

https://gcc.gnu.org/g:c401ff8c4304eee1dc80adf0573a052a632214a3

commit r14-12702-gc401ff8c4304eee1dc80adf0573a052a632214a3
Author: Patrick Palka <ppalka@redhat.com>
Date:   Thu Jun 5 11:07:25 2025 -0400

    c++: substituting fn parm redeclared with dep alias tmpl [PR120224]
    
    Here we declare f twice, the second time around using a dependent
    alias template.  Due to alias template transparency these are logically
    the same overload.  But now the function type of f (produced from the
    first declaration) diverges from the type of its formal parameter
    (produced from the subsequent redefinition) in that substituting T=int
    succeeds for the function type but not for the formal parameter type.
    This eventually causes us to produce an undiagnosed error_mark_node in
    the AST of the function call, leading to failure of the sanity check
    check added in r14-6343-g0c018a74eb1aff.
    
    Before r14-6343 we would still go on to reject the testcase later at
    instantiation time, from regenerate_decl_from_template, making this a
    regression.
    
    To fix this, it seems we just need to propagate error_mark_node upon
    substitution failure into the type of a PARM_DECL.
    
            PR c++/120224
    
    gcc/cp/ChangeLog:
    
            * pt.cc (tsubst_function_decl): Return error_mark_node if
            substituting into the formal parameter list failed.
            (tsubst_decl) <case PARM_DECL>: Return error_mark_node
            upon TREE_TYPE substitution failure, when in a SFINAE
            context.  Return error_mark_node upon DECL_CHAIN substitution
            failure.
    
    gcc/testsuite/ChangeLog:
    
            * g++.dg/cpp0x/alias-decl-80.C: New test.
    
    Reviewed-by: Jason Merrill <jason@redhat.com>
    (cherry picked from commit 51e93aadc94940e2da854cf1321a7ab1aebf8d1a)

Diff:
---
 gcc/cp/pt.cc                               | 14 ++++++++++++--
 gcc/testsuite/g++.dg/cpp0x/alias-decl-80.C | 21 +++++++++++++++++++++
 2 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
index 3ba1fb944b34..733ce975500c 100644
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -14719,6 +14719,8 @@ tsubst_function_decl (tree t, tree args, tsubst_flags_t complain,
   if (closure && DECL_IOBJ_MEMBER_FUNCTION_P (t))
     parms = DECL_CHAIN (parms);
   parms = tsubst (parms, args, complain, t);
+  if (parms == error_mark_node)
+    return error_mark_node;
   for (tree parm = parms; parm; parm = DECL_CHAIN (parm))
     DECL_CONTEXT (parm) = r;
   if (closure && DECL_IOBJ_MEMBER_FUNCTION_P (t))
@@ -15294,6 +15296,9 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain,
               /* We're dealing with a normal parameter.  */
               type = tsubst (TREE_TYPE (t), args, complain, in_decl);
 
+	    if (type == error_mark_node && !(complain & tf_error))
+	      RETURN (error_mark_node);
+
             type = type_decays_to (type);
             TREE_TYPE (r) = type;
             cp_apply_type_quals_to_decl (cp_type_quals (type), r);
@@ -15331,8 +15336,13 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain,
 	/* If cp_unevaluated_operand is set, we're just looking for a
 	   single dummy parameter, so don't keep going.  */
 	if (DECL_CHAIN (t) && !cp_unevaluated_operand)
-	  DECL_CHAIN (r) = tsubst (DECL_CHAIN (t), args,
-				   complain, DECL_CHAIN (t));
+	  {
+	    tree chain = tsubst (DECL_CHAIN (t), args,
+				 complain, DECL_CHAIN (t));
+	    if (chain == error_mark_node)
+	      RETURN (error_mark_node);
+	    DECL_CHAIN (r) = chain;
+	  }
 
         /* FIRST_R contains the start of the chain we've built.  */
         r = first_r;
diff --git a/gcc/testsuite/g++.dg/cpp0x/alias-decl-80.C b/gcc/testsuite/g++.dg/cpp0x/alias-decl-80.C
new file mode 100644
index 000000000000..9c0eadc967c0
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/alias-decl-80.C
@@ -0,0 +1,21 @@
+// PR c++/120224
+// { dg-do compile { target c++11 } }
+
+template<class> using void_t = void;
+
+template<class T>
+void f(void*); // #1
+
+template<class T>
+void f(void_t<typename T::type>*) { } // { dg-error "not a class" } defn of #1
+
+template<class T>
+void g(int, void*); // #2
+
+template<class T>
+void g(int, void_t<typename T::type>*) { } // { dg-error "not a class" } defn of #2
+
+int main() {
+  f<int>(0); // { dg-error "no match" }
+  g<int>(0, 0); // { dg-error "no match" }
+}