PR c++/89381 - implicit copy and using-declaration.

Here the used base<int>::operator= gets into the list of foo's bindings for
operator=, but it shouldn't make the copy ctor deleted.

	* class.c (classtype_has_move_assign_or_move_ctor_p): Don't consider
	op= brought in by a using-declaration.

From-SVN: r269442

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index b0c1f88c6a2dbd74313002422d4552818f819c28..0667dd7b2f9a5eb3845977fd797675dbfee7f4f4 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,9 @@
+2019-03-06  Jason Merrill  <jason@redhat.com>
+
+       PR c++/89381 - implicit copy and using-declaration.
+       * class.c (classtype_has_move_assign_or_move_ctor_p): Don't consider
+       op= brought in by a using-declaration.
+
 2019-03-06  Jakub Jelinek  <jakub@redhat.com>
 
        PR c++/87148

diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index 0d4d35bd690acdd69d0d2e9c5ea560dc1863f503..a70a852424ed7c820f624c4d36169fc76ef586d0 100644 (file)
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -5220,7 +5220,9 @@ classtype_has_move_assign_or_move_ctor_p (tree t, bool user_p)
     for (ovl_iterator iter (get_class_binding_direct
                            (t, assign_op_identifier));
         iter; ++iter)
-      if ((!user_p || !DECL_ARTIFICIAL (*iter)) && move_fn_p (*iter))
+      if ((!user_p || !DECL_ARTIFICIAL (*iter))
+         && DECL_CONTEXT (*iter) == t
+         && move_fn_p (*iter))
        return true;
   
   return false;

diff --git a/gcc/testsuite/g++.dg/cpp0x/implicit16.C b/gcc/testsuite/g++.dg/cpp0x/implicit16.C
new file mode 100644 (file)
index 0000000..229f2b4
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/implicit16.C
@@ -0,0 +1,37 @@
+// PR c++/89381
+// { dg-do compile { target c++11 } }
+
+template<typename T>
+struct base
+{
+  base() { }
+  base(const base&) { }
+  base(base&&) { }
+  base& operator=(const base&) { return *this; }
+  base& operator=(base&&) { return *this; }
+};
+
+struct foo : base<int>
+{
+    using base<int>::base;
+    using base<int>::operator=;
+};
+
+//using workaround = decltype(foo{*static_cast<foo const*>(0)});
+
+struct bar
+{
+    bar& operator=(foo ve)
+    {
+        value = ve;
+        return *this;
+    }
+
+    foo value;
+};
+
+int main()
+{
+    foo a;
+    foo b{a};
+}