Re: [PATCH] c++: CTAD and deduction guide selection [PR86439]

Jason Merrill via Gcc-patches Tue, 22 Jun 2021 12:57:35 -0700

On 6/22/21 2:45 PM, Patrick Palka wrote:

During CTAD, we select the best viable deduction guide via
build_new_function_call, which performs overload resolution on the set
of candidate guides and then forms a call to the guide.  As the PR
points out, this latter step is unnecessary and occasionally gives us
the wrong answer since a call to the selected guide may be ill-formed,
or forming the call may have side effects such as prematurely deducing
the type of a {}.


This patch introduces a specialized subroutine modeled off of
build_new_function_call that stops short of building a call to the
selected function, and makes do_class_deduction use this subroutine
instead.  And since we no longer build a call, do_class_deduction
doesn't need to set tf_decltype or cp_unevaluated_operand.

This change causes us to reject some container CTAD examples in the
libstdc++ testsuite due to deduction failure for {}, which AFAICT is the
correct behavior.  Previously, in the case of e.g. the first removed
example for std::map, the type of {} would be deduced to less<int> as a
side effect of forming the call to the selected guide

   template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
              typename _Allocator = allocator<pair<const _Key, _Tp>>,
              typename = _RequireNotAllocator<_Compare>,
              typename = _RequireAllocator<_Allocator>>
       map(initializer_list<pair<_Key, _Tp>>,
           _Compare = _Compare(), _Allocator = _Allocator())
       -> map<_Key, _Tp, _Compare, _Allocator>;

which made later overload resolution for the constructor call
unambiguous.  Now, the type of {} remains undeduced until constructor
overload resolution, and we complain about ambiguity with the two
constructors

   map(initializer_list<value_type> __l,
       const _Compare& __comp = _Compare(),
       const allocator_type& __a = allocator_type())

   map(initializer_list<value_type> __l, const allocator_type& __a)

This patch just removes these problematic container CTAD examples.

Bootstrapped and regtested on x86_64-pc-linux-gnu, does this look OK for
trunk?

OK.

        PR c++/86439

gcc/cp/ChangeLog:

        * call.c (print_error_for_call_failure): Constify 'args'
        parameter.
        (perform_dguide_overload_resolution): Define.
        * cp-tree.h: (perform_dguide_overload_resolution): Declare.
        * pt.c (do_class_deduction): Use perform_dguide_overload_resolution
        instead of build_new_function_call.  Don't use tf_decltype or
        set cp_unevaluated_operand.  Remove unnecessary NULL_TREE tests.

libstdc++-v3/ChangeLog:

        * testsuite/23_containers/map/cons/deduction.cc: Remove
        ambiguous CTAD constructs.
        * testsuite/23_containers/multimap/cons/deduction.cc: Likewise.
        * testsuite/23_containers/multiset/cons/deduction.cc: Likewise.
        * testsuite/23_containers/set/cons/deduction.cc: Likewise.
        * testsuite/23_containers/unordered_map/cons/deduction.cc: Likewise.
        * testsuite/23_containers/unordered_multimap/cons/deduction.cc:
        Likewise.
        * testsuite/23_containers/unordered_multiset/cons/deduction.cc:
        Likewise.
        * testsuite/23_containers/unordered_set/cons/deduction.cc: Likewise.

gcc/testsuite/ChangeLog:

        * g++.dg/cpp1z/class-deduction88.C: New test.
        * g++.dg/cpp1z/class-deduction89.C: New test.
        * g++.dg/cpp1z/class-deduction90.C: New test.
---
  gcc/cp/call.c                                 | 36 +++++++++++++++-
  gcc/cp/cp-tree.h                              |  2 +
  gcc/cp/pt.c                                   | 41 +++++++------------
  .../g++.dg/cpp1z/class-deduction88.C          | 20 +++++++++
  .../g++.dg/cpp1z/class-deduction89.C          | 15 +++++++
  .../g++.dg/cpp1z/class-deduction90.C          | 16 ++++++++
  .../23_containers/map/cons/deduction.cc       | 19 ---------
  .../23_containers/multimap/cons/deduction.cc  | 20 ---------
  .../23_containers/multiset/cons/deduction.cc  | 14 -------
  .../23_containers/set/cons/deduction.cc       | 15 -------
  .../unordered_map/cons/deduction.cc           | 16 --------
  .../unordered_multimap/cons/deduction.cc      | 16 --------
  .../unordered_multiset/cons/deduction.cc      | 10 -----
  .../unordered_set/cons/deduction.cc           | 10 -----
  14 files changed, 102 insertions(+), 148 deletions(-)
  create mode 100644 gcc/testsuite/g++.dg/cpp1z/class-deduction88.C
  create mode 100644 gcc/testsuite/g++.dg/cpp1z/class-deduction89.C
  create mode 100644 gcc/testsuite/g++.dg/cpp1z/class-deduction90.C

diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 9f03534c20c..aafc7acca24 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -4629,7 +4629,7 @@ perform_overload_resolution (tree fn,
     functions.  */

static void

-print_error_for_call_failure (tree fn, vec<tree, va_gc> *args,
+print_error_for_call_failure (tree fn, const vec<tree, va_gc> *args,
                              struct z_candidate *candidates)
  {
    tree targs = NULL_TREE;
@@ -4654,6 +4654,40 @@ print_error_for_call_failure (tree fn, vec<tree, va_gc> 
*args,
      print_z_candidates (loc, candidates);
  }

+/* Perform overload resolution on the set of deduction guides DGUIDES

+   using ARGS.  Returns the selected deduction guide, or error_mark_node
+   if overload resolution fails.  */
+
+tree
+perform_dguide_overload_resolution (tree dguides, const vec<tree, va_gc> *args,
+                                   tsubst_flags_t complain)
+{
+  z_candidate *candidates;
+  bool any_viable_p;
+  tree result;
+
+  gcc_assert (deduction_guide_p (OVL_FIRST (dguides)));
+
+  /* Get the high-water mark for the CONVERSION_OBSTACK.  */
+  void *p = conversion_obstack_alloc (0);
+
+  z_candidate *cand = perform_overload_resolution (dguides, args, &candidates,
+                                                  &any_viable_p, complain);
+  if (!cand)
+    {
+      if (complain & tf_error)
+       print_error_for_call_failure (dguides, args, candidates);
+      result = error_mark_node;
+    }
+  else
+    result = cand->fn;
+
+  /* Free all the conversions we allocated.  */
+  obstack_free (&conversion_obstack, p);
+
+  return result;
+}
+
  /* Return an expression for a call to FN (a namespace-scope function,
     or a static member function) with the ARGS.  This may change
     ARGS.  */
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 36f99ccf189..6f713719589 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -6437,6 +6437,8 @@ extern void complain_about_bad_argument   (location_t 
arg_loc,
                                                 tree from_type, tree to_type,
                                                 tree fndecl, int parmnum);
  extern void maybe_inform_about_fndecl_for_bogus_argument_init (tree, int);
+extern tree perform_dguide_overload_resolution (tree, const vec<tree, va_gc> *,
+                                                tsubst_flags_t);

/* A class for recording information about access failures (e.g. private

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 15947b2c812..732fb405adf 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -29382,7 +29382,7 @@ do_class_deduction (tree ptype, tree tmpl, tree init,
      if (tree guide = maybe_aggr_guide (tmpl, init, args))
        cands = lookup_add (guide, cands);

- tree call = error_mark_node;

+  tree fndecl = error_mark_node;

/* If this is list-initialization and the class has a list constructor, first

       try deducing from the list as a single argument, as [over.match.list].  
*/
@@ -29396,11 +29396,9 @@ do_class_deduction (tree ptype, tree tmpl, tree init,
        }
    if (list_cands)
      {
-      ++cp_unevaluated_operand;
-      call = build_new_function_call (list_cands, &args, tf_decltype);
-      --cp_unevaluated_operand;
+      fndecl = perform_dguide_overload_resolution (list_cands, args, tf_none);

- if (call == error_mark_node)

+      if (fndecl == error_mark_node)
        {
          /* That didn't work, now try treating the list as a sequence of
             arguments.  */
@@ -29416,31 +29414,22 @@ do_class_deduction (tree ptype, tree tmpl, tree init,
             "user-declared constructors", type);
        return error_mark_node;
      }
-  else if (!cands && call == error_mark_node)
+  else if (!cands && fndecl == error_mark_node)
      {
        error ("cannot deduce template arguments of %qT, as it has no viable "
             "deduction guides", type);
        return error_mark_node;
      }

- if (call == error_mark_node)

-    {
-      ++cp_unevaluated_operand;
-      call = build_new_function_call (cands, &args, tf_decltype);
-      --cp_unevaluated_operand;
-    }
+  if (fndecl == error_mark_node)
+    fndecl = perform_dguide_overload_resolution (cands, args, tf_none);

- if (call == error_mark_node)

+  if (fndecl == error_mark_node)
      {
        if (complain & tf_warning_or_error)
        {
          error ("class template argument deduction failed:");
-
-         ++cp_unevaluated_operand;
-         call = build_new_function_call (cands, &args,
-                                         complain | tf_decltype);
-         --cp_unevaluated_operand;
-
+         perform_dguide_overload_resolution (cands, args, complain);
          if (elided)
            inform (input_location, "explicit deduction guides not considered "
                    "for copy-initialization");
@@ -29451,8 +29440,7 @@ do_class_deduction (tree ptype, tree tmpl, tree init,
       constructor is chosen, the initialization is ill-formed.  */
    else if (flags & LOOKUP_ONLYCONVERTING)
      {
-      tree fndecl = cp_get_callee_fndecl_nofold (call);
-      if (fndecl && DECL_NONCONVERTING_P (fndecl))
+      if (DECL_NONCONVERTING_P (fndecl))
        {
          if (complain & tf_warning_or_error)
            {
@@ -29470,12 +29458,10 @@ do_class_deduction (tree ptype, tree tmpl, tree init,

/* If CTAD succeeded but the type doesn't have any explicit deduction

       guides, this deduction might not be what the user intended.  */
-  if (call != error_mark_node && !any_dguides_p)
+  if (fndecl != error_mark_node && !any_dguides_p)
      {
-      tree fndecl = cp_get_callee_fndecl_nofold (call);
-      if (fndecl != NULL_TREE
-         && (!DECL_IN_SYSTEM_HEADER (fndecl)
-             || global_dc->dc_warn_system_headers)
+      if ((!DECL_IN_SYSTEM_HEADER (fndecl)
+          || global_dc->dc_warn_system_headers)
          && warning (OPT_Wctad_maybe_unsupported,
                      "%qT may not intend to support class template argument "
                      "deduction", type))
@@ -29483,7 +29469,8 @@ do_class_deduction (tree ptype, tree tmpl, tree init,
                "warning");
      }

- return cp_build_qualified_type (TREE_TYPE (call), cp_type_quals (ptype));

+  return cp_build_qualified_type (TREE_TYPE (TREE_TYPE (fndecl)),
+                                 cp_type_quals (ptype));
  }

/* Replace occurrences of 'auto' in TYPE with the appropriate type deduced

diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction88.C 
b/gcc/testsuite/g++.dg/cpp1z/class-deduction88.C
new file mode 100644
index 00000000000..f8fea966696
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction88.C
@@ -0,0 +1,20 @@
+// PR c++/86439
+// { dg-do compile { target c++17 } }
+
+struct NC {
+  NC() = default;
+  NC(NC const&) = delete;
+  NC& operator=(NC const&) = delete;
+};
+
+template <int>
+struct C {
+  C(NC const&);
+};
+
+C(NC) -> C<0>;
+
+int main() {
+  NC nc;
+  C c(nc);
+}
diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction89.C 
b/gcc/testsuite/g++.dg/cpp1z/class-deduction89.C
new file mode 100644
index 00000000000..dd898573022
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction89.C
@@ -0,0 +1,15 @@
+// PR c++/86439
+// { dg-do compile { target c++17 } }
+
+struct B { };
+struct C { };
+
+template<class T>
+struct A {
+  A(T, B);
+};
+
+template<class T>
+A(T, C) -> A<T>;
+
+A a(0, {});
diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction90.C 
b/gcc/testsuite/g++.dg/cpp1z/class-deduction90.C
new file mode 100644
index 00000000000..8b93193c7b0
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction90.C
@@ -0,0 +1,16 @@
+// PR c++/86439
+// { dg-do compile { target c++17 } }
+
+struct less { };
+struct allocator { };
+
+template<class T, class U = less, class V = allocator>
+struct A {
+  A(T, U);
+  A(T, V);
+};
+
+template<class T, class U = less>
+A(T, U) -> A<T>;
+
+A a(0, {}); // { dg-error "ambiguous" }
diff --git a/libstdc++-v3/testsuite/23_containers/map/cons/deduction.cc 
b/libstdc++-v3/testsuite/23_containers/map/cons/deduction.cc
index e9628c4ac32..8def11ed574 100644
--- a/libstdc++-v3/testsuite/23_containers/map/cons/deduction.cc
+++ b/libstdc++-v3/testsuite/23_containers/map/cons/deduction.cc
@@ -39,10 +39,6 @@ static_assert(std::is_same_v<
              std::map<int, double>>);
  */

-static_assert(std::is_same_v<

-             decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}, {}}),
-             std::map<int, double>>);
-
  /* This is not deducible, ambiguous candidates:
   * map(initializer_list<value_type>, const Compare&, const _Allocator& = {})
   * map(initializer_list<value_type>, const _Allocator&)
@@ -90,11 +86,6 @@ void f()
                                  std::less<int>{}, {}}),
                std::map<int, double>>);