+2018-06-12 Marek Polacek <polacek@redhat.com>
+
+ Core issue 1331 - const mismatch with defaulted copy constructor
+ * class.c (check_bases_and_members): When checking a defaulted
+ function, mark it as deleted rather than giving an error.
+
2018-06-11 Jason Merrill <jason@redhat.com>
PR c++/85792 -Wctor-dtor-privacy and inherited constructor.
if (fn_const_p && !imp_const_p)
/* If the function is defaulted outside the class, we just
- give the synthesis error. */
- error ("%q+D declared to take const reference, but implicit "
- "declaration would take non-const", fn);
+ give the synthesis error. Core Issue #1331 says this is
+ no longer ill-formed, it is defined as deleted instead. */
+ DECL_DELETED_FN (fn) = true;
}
defaulted_late_check (fn);
}
+2018-06-12 Marek Polacek <polacek@redhat.com>
+
+ Core issue 1331 - const mismatch with defaulted copy constructor
+ * g++.dg/cpp0x/defaulted15.C (struct F): Remove dg-error.
+ * g++.dg/cpp0x/defaulted52.C: New test.
+ * g++.dg/cpp0x/defaulted53.C: New test.
+ * g++.dg/cpp0x/defaulted54.C: New test.
+ * g++.dg/cpp0x/defaulted55.C: New test.
+ * g++.dg/cpp0x/defaulted56.C: New test.
+ * g++.dg/cpp0x/defaulted57.C: New test.
+ * g++.dg/cpp0x/defaulted58.C: New test.
+ * g++.dg/cpp0x/defaulted59.C: New test.
+ * g++.dg/cpp0x/defaulted60.C: New test.
+
2018-06-12 David Malcolm <dmalcolm@redhat.com>
PR other/69968
struct G: public F
{
- // Can't be const because F copy ctor isn't.
- G(const G&) = default; // { dg-error "const" }
+ G(const G&) = default;
};
struct H
--- /dev/null
+// Core Issue #1331 (const mismatch with defaulted copy constructor)
+// { dg-do compile { target c++11 } }
+
+struct M
+{
+ M();
+ // So that W wouldn't have had "const W&" copy ctor if it were
+ // implicitly declared.
+ M(M&);
+};
+
+template<typename T> struct W
+{
+ W();
+ // This should now compile and be =deleted.
+ W(const W&) = default;
+ T t;
+};
+
+W<M> w;
--- /dev/null
+// Core Issue #1331 (const mismatch with defaulted copy constructor)
+// { dg-do compile { target c++11 } }
+
+struct M
+{
+ M& operator=(M&);
+};
+
+struct R
+{
+ R& operator=(R&) = default;
+ M m;
+};
+
+struct S
+{
+ S& operator=(const S&) = default;
+ M m;
+};
+
+struct T
+{
+ // If F is an assignment operator, and the return type of T1
+ // differs from the return type of T2 the program is ill-formed.
+ T operator=(T&) = default; // { dg-error "defaulted" }
+ M m;
+};
+
+struct U
+{
+ // If F is an assignment operator, and T1's parameter type is
+ // not a reference, the program is ill-formed.
+ U& operator=(U) = default; // { dg-error "defaulted" }
+ M m;
+};
--- /dev/null
+// Core Issue #1331 (const mismatch with defaulted copy constructor)
+// { dg-do compile { target c++11 } }
+
+struct M
+{
+ M();
+ M(M&);
+};
+
+template<typename T> struct W
+{
+ W();
+ W(const W&) = default; // { dg-error "binding" }
+ T t;
+};
+
+W<M> w;
+W<M> w2 = w; // { dg-error "use of deleted function" }
--- /dev/null
+// Core Issue #1331 (const mismatch with defaulted copy constructor)
+// { dg-do compile { target c++11 } }
+
+struct M
+{
+ M();
+ M(M&);
+};
+
+template<typename T> struct W
+{
+ W();
+ W(W&) = default;
+ // T1 and T2 may have differing ref-qualifiers (copy assign op).
+ constexpr W& operator=(const W&) && = default; // { dg-error "defaulted" "" { target c++11_down } }
+ T t;
+};
+
+W<M> w;
--- /dev/null
+// Core Issue #1331 (const mismatch with defaulted copy constructor)
+// { dg-do compile { target c++11 } }
+
+// If T2 (what would be the implicit declaration) has a parameter of
+// type const C&, the corresponding parameter of T1 may be of type C&.
+
+struct S
+{
+ constexpr S(S &) = default;
+};
+
+struct T
+{
+ constexpr T(volatile T &) = default; // { dg-error "defaulted" }
+};
+
+struct U
+{
+ constexpr U(const volatile U &) = default; // { dg-error "defaulted" }
+};
+
+struct V
+{
+ constexpr V(const V &) = default;
+};
--- /dev/null
+// Core Issue #1331 (const mismatch with defaulted copy constructor)
+// { dg-do compile { target c++11 } }
+
+// If T2 (what would be the implicit declaration) has a parameter of
+// type const C&, the corresponding parameter of T1 may be of type C&.
+
+struct S
+{
+ S& operator=(S &) = default;
+};
+
+struct T
+{
+ T& operator=(volatile T &) = default; // { dg-error "defaulted" }
+};
+
+struct U
+{
+ U& operator=(const volatile U &) = default; // { dg-error "defaulted" }
+};
+
+struct V
+{
+ V& operator=(const V &) = default;
+};
--- /dev/null
+// Core Issue #1331 (const mismatch with defaulted copy constructor)
+// { dg-do compile { target c++11 } }
+
+struct M
+{
+ M() = default;
+ M& operator=(M&);
+};
+
+template<typename T> struct W
+{
+ W() = default;
+ W& operator=(const W&) = default; // { dg-error "binding" }
+ T t;
+};
+
+int
+main ()
+{
+ W<M> w1, w2;
+ w1 = w2; // { dg-error "use of deleted function" }
+}
--- /dev/null
+// Core Issue #1331 (const mismatch with defaulted copy constructor)
+// { dg-do compile { target c++11 } }
+
+struct M
+{
+ M(M&) = default;
+};
+
+struct W : public M
+{
+ W(const W&) = default;
+};
--- /dev/null
+// Core Issue #1331 (const mismatch with defaulted copy constructor)
+// { dg-do compile { target c++11 } }
+
+struct M
+{
+ M(M&);
+};
+
+struct W
+{
+ W();
+ W(const W&);
+ M m;
+};
+
+// Not first declaration.
+W::W(const W&) = default; // { dg-error "binding" }
+W w;
projects / gcc.git / commitdiff