Consider explicit conversions before aggregate fallback []

Allow explicit conversion functions when matching the implicit copy constructor during single-argument direct-initialization, preventing premature C++20 aggregate fallback.

Extend EDGcpfe24743 to cover explicit conversion functions.

Signed-off-by: Yihan Wang <[email protected]>

Author: yronglin

src/expr.c

@@ -30702,11 +30702,15 @@ parentheses do not themselves correspond to aggregate initialization).
     an_arg_match_summary  arg_match;
     an_operand            opnd;
     clear_arg_match_summary(&arg_match);
+    /* When matching the first reference parameter of a copy constructor
+       called with one argument in a direct-initialization context, explicit
+       conversion functions are considered ([over.match.copy]). */
     prep_list_initializer(arg_list, dest_type, /*is_direct_init=*/TRUE,
                           /*check_narrowing=*/FALSE,
                           /*warning_on_narrowing=*/FALSE,
                           CCO_CAST | CCO_FUNC_NOTATION_CAST |
-                          CCO_EXPLICIT_CAST | CCO_DIRECT_INITIALIZATION,
+                          CCO_EXPLICIT_CAST | CCO_DIRECT_INITIALIZATION |
+                          CCO_ALLOW_EXPLICIT_CONV_FUNCTIONS,
                           /*fill_in_dtor=*/TRUE, /*force_temp=*/FALSE,
                           /*make_lvalue_temp=*/FALSE,
                           &opnd, (an_init_state*)NULL, &arg_match);

src/overload.c

@@ -27542,7 +27542,9 @@ will be an lvalue instead of the usual prvalue.
                                   (a_param_type_ptr)NULL,
                                   /*param_type_is_deduced=*/FALSE,
                                   try_user_conversions_in_ovl_res,
-                                  /*allow_expl_conv_funcs=*/FALSE,
+                                  /*allow_expl_conv_funcs=*/
+                                    (conv_context &
+                                      CCO_ALLOW_EXPLICIT_CONV_FUNCTIONS) != 0,
                                   arg_match);
       }  /* if */
     } else {

tests/tests/changes/EDGcpfe24743.sft.cpp

@@ -15,3 +15,9 @@ struct S  { operator D() const; };
 void g(S p) {
   D d(p);  // Previously an error.  Now okay.
 }
+
+struct ExplicitS { explicit operator D() const; };
+D h(ExplicitS p) {
+  D d(p);       // Previously an error in C++20 mode.  Now okay.
+  return D(p);  // Likewise.
+}