c++: bad direct reference binding via conv fn [PR113064]

When computing a direct reference binding via a conversion function
yields a bad conversion, reference_binding incorrectly commits to that
conversion instead of trying a conversion via a temporary.  This causes
us to reject the first testcase because the bad direct conversion to B&&
via the && conversion operator prevents us from considering the good
conversion via the & conversion operator and a temporary.  (Similar
story for the second testcase.)

This patch fixes this by making reference_binding not prematurely commit
to such a bad direct conversion.  We still fall back to it if using a
temporary also fails (otherwise the diagnostic for cpp0x/explicit7.C
regresses).

	PR c++/113064

gcc/cp/ChangeLog:

	* call.cc (reference_binding): Still try a conversion via a
	temporary if a direct conversion was bad.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp0x/rv-conv4.C: New test.
	* g++.dg/cpp0x/rv-conv5.C: New test.

diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc
index d9ddd36cec0d539c0f877c2c9b0861bd3258f5a9..1c675726f8ca51c9de98383a5958fb3905cd6702 100644 (file)
--- a/gcc/cp/call.cc
+++ b/gcc/cp/call.cc
@@ -1739,6 +1739,7 @@ reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags,
                   tsubst_flags_t complain)
 {
   conversion *conv = NULL;
+  conversion *bad_direct_conv = nullptr;
   tree to = TREE_TYPE (rto);
   tree from = rfrom;
   tree tfrom;
@@ -1925,13 +1926,23 @@ reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags,
       z_candidate *cand = build_user_type_conversion_1 (rto, expr, flags,
                                                        complain);
       if (cand)
-       return cand->second_conv;
+       {
+         if (!cand->second_conv->bad_p)
+           return cand->second_conv;
+
+         /* Direct reference binding wasn't successful and yielded a bad
+            conversion.  Proceed with trying to go through a temporary
+            instead, and if that also fails then we'll return this bad
+            conversion rather than no conversion for sake of better
+            diagnostics.  */
+         bad_direct_conv = cand->second_conv;
+       }
     }
 
   /* From this point on, we conceptually need temporaries, even if we
      elide them.  Only the cases above are "direct bindings".  */
   if (flags & LOOKUP_NO_TEMP_BIND)
-    return NULL;
+    return bad_direct_conv ? bad_direct_conv : nullptr;
 
   /* [over.ics.rank]
 
@@ -1972,6 +1983,9 @@ reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags,
      there's no strictly viable candidate.  */
   if (!maybe_valid_p && (flags & LOOKUP_SHORTCUT_BAD_CONVS))
     {
+      if (bad_direct_conv)
+       return bad_direct_conv;
+
       conv = alloc_conversion (ck_deferred_bad);
       conv->bad_p = true;
       return conv;
@@ -1995,7 +2009,7 @@ reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags,
     conv = implicit_conversion (to, from, expr, c_cast_p,
                                flags, complain);
   if (!conv)
-    return NULL;
+    return bad_direct_conv ? bad_direct_conv : nullptr;
 
   if (conv->user_conv_p)
     {
@@ -2018,7 +2032,7 @@ reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags,
              = reference_binding (rto, ftype, NULL_TREE, c_cast_p,
                                   sflags, complain);
            if (!new_second)
-             return NULL;
+             return bad_direct_conv ? bad_direct_conv : nullptr;
            conv = merge_conversion_sequences (t, new_second);
            gcc_assert (maybe_valid_p || conv->bad_p);
            return conv;

diff --git a/gcc/testsuite/g++.dg/cpp0x/rv-conv4.C b/gcc/testsuite/g++.dg/cpp0x/rv-conv4.C
new file mode 100644 (file)
index 0000000..7ecd2dc
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/rv-conv4.C
@@ -0,0 +1,16 @@
+// PR c++/113064
+// { dg-do compile { target c++11 } }
+
+struct B { };
+
+struct A {
+  operator B() &;
+  operator B&&() &&;
+};
+
+void f(B&&);
+
+int main() {
+  A a;
+  f(a);
+}

diff --git a/gcc/testsuite/g++.dg/cpp0x/rv-conv5.C b/gcc/testsuite/g++.dg/cpp0x/rv-conv5.C
new file mode 100644 (file)
index 0000000..dcb6fc6
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/rv-conv5.C
@@ -0,0 +1,23 @@
+// PR c++/113064
+// { dg-do compile { target c++11 } }
+
+struct no_copy {
+  no_copy() = default;
+
+  no_copy(const no_copy&) = delete;
+  no_copy(no_copy&&);
+
+  no_copy& operator=(const no_copy&) = delete;
+  no_copy& operator=(no_copy&&);
+};
+
+struct A {
+  operator no_copy() &;
+  operator no_copy&&() && = delete;
+};
+
+int main() {
+  no_copy nc;
+  A a;
+  nc = a;
+}