Add protected copying functions to @interface

Thanks to Jeroen Van Antwerpen for reminding me that it is possible to have a polymorphic type that is copyable/movable (in fact, I do that a lot in the Cpp2 reflection API), and so it makes sense for an @interface to have _protected_ copying functions - this way the interface is not copyable by default (correct), but a type that implements the interface has the option of defining copy/move if it wants to

Made @interface generate protected copy/move construction/assignment

Similarly, removed the restriction that @polymorphic_base types cannot be copyable

Made operator= "A1" generation work also for polymorphic types - until now it was restricted to only monomorphic types, but it really should work anytime operator= exists - this permits @interface to just define the general operator= as per usual Cpp2 style and get all four functions

No change to the "A3" rule, that tends to work great for non-polymorphic types - but while doing this PR I tried applying it also to polymorphic types and noticed it would frequently cause problems in the presence of polymorphic base types, so leaving A3 alone seems useful and right

Made the polymorphic reflection API types @copy_constructible instead of @copyable so as not to require generating assignment (they are current inherently non-assignable because some members are not assignable)

Author: hsutter

docs/cpp2/generalized-copy-move-construction-assignment.png

@@ -148,13 +148,13 @@ As mentioned above:
 
 This graphic summarizes these generalizations. For convenience I've numbered the (A)ssignment and (M)ove defaults.
 
-![image](https://github.com/user-attachments/assets/311f27df-17df-48c4-b0c9-b820afb5be0c)
+![image](generalized-copy-move-construction-assignment.png)
 
 In Cpp1 terms, they can be described as follows:
 
 - **(M)ove, M1, M2:** If you write a copy constructor or assignment operator, but not a corresponding move constructor or assignment operator, the latter is generated.
 
-- **(A)ssignment, A1, A3:** If you write a generalized constructor, but none of the three more-specific copy/move constructor/assignment functions, the latter three get generated. If you write a converting copy constructor, but no converting assignment operator for the same type, the latter is generated.
+- **(A)ssignment, A1, A3:** If you write a generalized constructor, but none of the three more-specific copy/move constructor/assignment functions, the latter three get generated. If you write a converting copy constructor, but no converting assignment operator for the same type and this is not a polymorphic type, the latter is generated.
 
 - **The arrows are transitive.** For example, if you write a copy constructor and nothing else, the move constructor, copy assignment operator, and move assignment operator are generated.
 

docs/cpp2/types.md

@@ -37,6 +37,8 @@ class Derived: public Base {
 
   public: explicit Derived();
   public: Derived(Derived const& that);
+#line 10 "pure2-bugfix-for-memberwise-base-assignment.cpp2"
+  public: Derived(Derived&& that) noexcept;
   public: auto operator=(Derived&& that) noexcept -> Derived& ;
 };
 
@@ -70,6 +72,9 @@ auto main() -> int;
 #line 10 "pure2-bugfix-for-memberwise-base-assignment.cpp2"
   Derived::Derived(Derived const& that)
                                     : Base{ static_cast<Base const&>(that) }{}
+#line 10 "pure2-bugfix-for-memberwise-base-assignment.cpp2"
+  Derived::Derived(Derived&& that) noexcept
+                                    : Base{ static_cast<Base&&>(that) }{}
 #line 11 "pure2-bugfix-for-memberwise-base-assignment.cpp2"
   auto Derived::operator=(Derived&& that) noexcept -> Derived& {
                                          Base::operator= ( static_cast<Base&&>(that) );

regression-tests/test-results/pure2-bugfix-for-memberwise-base-assignment.cpp

@@ -45,6 +45,12 @@ struct values_ret { int offset; std::string name; };
         public: explicit mytype();
 
         public: mytype([[maybe_unused]] mytype const& that);
+#line 63 "pure2-print.cpp2"
+        public: auto operator=([[maybe_unused]] mytype const& that) -> mytype& ;
+#line 63 "pure2-print.cpp2"
+        public: mytype([[maybe_unused]] mytype&& that) noexcept;
+#line 63 "pure2-print.cpp2"
+        public: auto operator=([[maybe_unused]] mytype&& that) noexcept -> mytype& ;
 
         public: mytype([[maybe_unused]] cpp2::impl::in<int> unnamed_param_2);
 
@@ -160,6 +166,14 @@ requires (true) inline CPP2_CONSTEXPR T outer::object_alias{ 42 };
 
 #line 63 "pure2-print.cpp2"
         outer::mytype::mytype([[maybe_unused]] mytype const& that){}
+#line 63 "pure2-print.cpp2"
+        auto outer::mytype::operator=([[maybe_unused]] mytype const& that) -> mytype& {
+                                        return *this; }
+#line 63 "pure2-print.cpp2"
+        outer::mytype::mytype([[maybe_unused]] mytype&& that) noexcept{}
+#line 63 "pure2-print.cpp2"
+        auto outer::mytype::operator=([[maybe_unused]] mytype&& that) noexcept -> mytype& {
+                                        return *this; }
 
 #line 65 "pure2-print.cpp2"
         outer::mytype::mytype([[maybe_unused]] cpp2::impl::in<int> unnamed_param_2){}

regression-tests/test-results/pure2-print.cpp

@@ -30,11 +30,13 @@ class Cyborg;
 #line 2 "pure2-types-inheritance.cpp2"
 class Human {
     public: virtual auto speak() const -> void = 0;
-    public: virtual ~Human() noexcept;
+    public: explicit Human();
+protected: Human([[maybe_unused]] Human const& that);
 
-    public: Human() = default;
-    public: Human(Human const&) = delete; /* No 'that' constructor, suppress copy */
-    public: auto operator=(Human const&) -> void = delete;
+protected: auto operator=([[maybe_unused]] Human const& that) -> Human& ;
+protected: Human([[maybe_unused]] Human&& that) noexcept;
+protected: auto operator=([[maybe_unused]] Human&& that) noexcept -> Human& ;
+public: virtual ~Human() noexcept;
 
 #line 4 "pure2-types-inheritance.cpp2"
 };
@@ -91,6 +93,13 @@ auto main() -> int;
 #line 1 "pure2-types-inheritance.cpp2"
 
 
+Human::Human(){}
+Human::Human([[maybe_unused]] Human const& that){}
+auto Human::operator=([[maybe_unused]] Human const& that) -> Human& {
+                                          return *this;}
+Human::Human([[maybe_unused]] Human&& that) noexcept{}
+auto Human::operator=([[maybe_unused]] Human&& that) noexcept -> Human& {
+                                          return *this;}
 Human::~Human() noexcept{}
 #line 6 "pure2-types-inheritance.cpp2"
 namespace N {

regression-tests/test-results/pure2-types-inheritance.cpp

@@ -1,4 +1,4 @@
 
-cppfront compiler v0.8.2 Build A705:2012
+cppfront compiler v0.8.2 Build A706:1407
 SPDX-License-Identifier  Apache-2.0 WITH LLVM-exception
 Copyright (c) 2022-2024  Herb Sutter

regression-tests/test-results/version

@@ -1 +1 @@
-"A705:2012"
+"A706:1407"