Generate assignment operator from operator=(out this, with_one: additional_parameter)

hsutter · hsutter · commit 482bac81ee34 · 2023-03-11T22:16:34.000-05:00
diff --git a/regression-tests/pure2-types-basics.cpp2 b/regression-tests/pure2-types-basics.cpp2
@@ -6,21 +6,28 @@ myclass : type = {
     operator=: (implicit out this, x: int) = {
         data = x;
         // use default initializer for this.more
-        std::cout << "myclass: implicit constructor from int\n";
+        std::cout << "myclass: implicit from int\n";
         print();
     }
 
     operator=: (out this, s: std::string) = {
         this.data = 99;
-        this.more = "plugh";
-        std::cout << "myclass: explicit constructor from string\n";
+        this.more = s;
+        std::cout << "myclass: explicit from string\n";
+        print();
+    }
+
+    operator=: (out this, x: int, s: std::string) = {
+        this.data = 77;
+        this.more = s + " plugh";
+        std::cout << "myclass: from int and string\n";
         print();
     }
 
     operator=: (out this) = {
         // use default initializer for this.data
         more = std::to_string(3.14159);
-        std::cout << "myclass: default constructor\n";
+        std::cout << "myclass: default\n";
         print();
     }
 
@@ -62,4 +69,13 @@ main: () = {
     std::cout << "f4: (x.f4<4,4>())$\n";
     x2: N::myclass = "abracadabra";
     x3: N::myclass = ();
+    x4: N::myclass = (1, "hair");
+
+    // Invoke the single-param operator=s as actual assignments
+    std::cout << "x's state before assignments: ";
+    x.print();
+    x = 84;
+    x = "syzygy";
+    x = 84;
+    x = "syzygy";
 }
diff --git a/regression-tests/test-results/clang-12/pure2-types-basics.cpp.execution b/regression-tests/test-results/clang-12/pure2-types-basics.cpp.execution
@@ -1,15 +1,27 @@
-myclass: implicit constructor from int
+myclass: implicit from int
     data: 1, more: 504
 N::myclass::f with 53
 N::myclass::nested::g
 f1: 2
 f2: 4
 f3: 6
 f4: 8
-myclass: explicit constructor from string
-    data: 99, more: plugh
-myclass: default constructor
+myclass: explicit from string
+    data: 99, more: abracadabra
+myclass: default
     data: 504, more: 3.141590
+myclass: from int and string
+    data: 77, more: hair plugh
+x's state before assignments:     data: 1, more: 504
+myclass: implicit from int
+    data: 84, more: 504
+myclass: explicit from string
+    data: 99, more: syzygy
+myclass: implicit from int
+    data: 84, more: syzygy
+myclass: explicit from string
+    data: 99, more: syzygy
+myclass: destructor
 myclass: destructor
 myclass: destructor
 myclass: destructor
diff --git a/regression-tests/test-results/gcc-10/pure2-types-basics.cpp.execution b/regression-tests/test-results/gcc-10/pure2-types-basics.cpp.execution
@@ -1,15 +1,27 @@
-myclass: implicit constructor from int
+myclass: implicit from int
     data: 1, more: 504
 N::myclass::f with 53
 N::myclass::nested::g
 f1: 2
 f2: 4
 f3: 6
 f4: 8
-myclass: explicit constructor from string
-    data: 99, more: plugh
-myclass: default constructor
+myclass: explicit from string
+    data: 99, more: abracadabra
+myclass: default
     data: 504, more: 3.141590
+myclass: from int and string
+    data: 77, more: hair plugh
+x's state before assignments:     data: 1, more: 504
+myclass: implicit from int
+    data: 84, more: 504
+myclass: explicit from string
+    data: 99, more: syzygy
+myclass: implicit from int
+    data: 84, more: syzygy
+myclass: explicit from string
+    data: 99, more: syzygy
+myclass: destructor
 myclass: destructor
 myclass: destructor
 myclass: destructor
diff --git a/regression-tests/test-results/msvc-2022/pure2-types-basics.cpp.execution b/regression-tests/test-results/msvc-2022/pure2-types-basics.cpp.execution
@@ -1,15 +1,27 @@
-myclass: implicit constructor from int
+myclass: implicit from int
     data: 1, more: 504
 N::myclass::f with 53
 N::myclass::nested::g
 f1: 2
 f2: 4
 f3: 6
 f4: 8
-myclass: explicit constructor from string
-    data: 99, more: plugh
-myclass: default constructor
+myclass: explicit from string
+    data: 99, more: abracadabra
+myclass: default
     data: 504, more: 3.141590
+myclass: from int and string
+    data: 77, more: hair plugh
+x's state before assignments:     data: 1, more: 504
+myclass: implicit from int
+    data: 84, more: 504
+myclass: explicit from string
+    data: 99, more: syzygy
+myclass: implicit from int
+    data: 84, more: syzygy
+myclass: explicit from string
+    data: 99, more: syzygy
+myclass: destructor
 myclass: destructor
 myclass: destructor
 myclass: destructor
diff --git a/regression-tests/test-results/pure2-types-basics.cpp b/regression-tests/test-results/pure2-types-basics.cpp
@@ -8,7 +8,7 @@
 namespace N   {
 class myclass;
 };
-#line 55 "pure2-types-basics.cpp2"
+#line 62 "pure2-types-basics.cpp2"
 auto main() -> int;
 
 //=== Cpp2 definitions ==========================================================
@@ -25,27 +25,37 @@ class myclass   {
 #line 7 "pure2-types-basics.cpp2"
 {
         // use default initializer for this.more
-        std::cout << "myclass: implicit constructor from int\n";
+        std::cout << "myclass: implicit from int\n";
         print();
-    }
+    }public: auto operator=(cpp2::in<int> x) -> void{data = x;std::cout << "myclass: implicit from int\n";print();}
 
     public: explicit myclass(cpp2::in<std::string> s)
         : data{ 99 }
-        , more{ "plugh" }
+        , more{ s }
 #line 14 "pure2-types-basics.cpp2"
 {
 
-        std::cout << "myclass: explicit constructor from string\n";
+        std::cout << "myclass: explicit from string\n";
+        print();
+    }public: auto operator=(cpp2::in<std::string> s) -> void{(*this).data = 99;(*this).more = s;std::cout << "myclass: explicit from string\n";print();}
+
+    public: myclass(cpp2::in<int> x, cpp2::in<std::string> s)
+        : data{ 77 }
+        , more{ s + " plugh" }
+#line 21 "pure2-types-basics.cpp2"
+{
+
+        std::cout << "myclass: from int and string\n";
         print();
     }
 
     public: myclass()
         : data{ 42 * 12 }
         , more{ std::to_string(3.14159) }
-#line 21 "pure2-types-basics.cpp2"
+#line 28 "pure2-types-basics.cpp2"
 {       // use default initializer for this.data
 
-        std::cout << "myclass: default constructor\n";
+        std::cout << "myclass: default\n";
         print();
     }
 
@@ -84,8 +94,17 @@ auto main() -> int{
     std::cout << "f1: " + cpp2::to_string(CPP2_UFCS(f1, x, 1, 1)) + "\n";
     std::cout << "f2: " + cpp2::to_string(CPP2_UFCS(f2, x, 2, 2)) + "\n";
     std::cout << "f3: " + cpp2::to_string(CPP2_UFCS_TEMPLATE_0(f3, (<3,3>), x)) + "\n";
-    std::cout << "f4: " + cpp2::to_string(CPP2_UFCS_TEMPLATE_0(f4, (<4,4>), std::move(x))) + "\n";
+    std::cout << "f4: " + cpp2::to_string(CPP2_UFCS_TEMPLATE_0(f4, (<4,4>), x)) + "\n";
     N::myclass x2 {"abracadabra"}; 
     N::myclass x3 {}; 
+    N::myclass x4 {1, "hair"}; 
+
+    // Invoke the single-param operator=s as actual assignments
+    std::cout << "x's state before assignments: ";
+    CPP2_UFCS_0(print, x);
+    x = 84;
+    x = "syzygy";
+    x = 84;
+    x = "syzygy";
 }
 
diff --git a/source/cppfront.cpp b/source/cppfront.cpp
@@ -1356,6 +1356,7 @@ class cppfront
         {
             if (auto decl = sema.get_declaration_of(*n.identifier);
                 is_local_name
+                && !(*n.identifier == "this")
                 && decl
                 //  note pointer equality: if we're not in the actual declaration of n.identifier
                 && (
@@ -3598,10 +3599,13 @@ class cppfront
     //
     auto emit(
         declaration_node const& n,
-        std::string const&      capture_intro = {}
+        std::string const&      capture_intro                  = {},
+        bool                    emit_constructor_as_assignment = false
     )
         -> void
     {
+        auto do_recursive_call_for_assignment = false;
+
         auto is_main =
             !n.parent_declaration
             && n.has_name("main")
@@ -3778,7 +3782,7 @@ class cppfront
                     break;case passing_style::inout:
                         ;
                     break;case passing_style::out:
-                        ; // TODO: constructor
+                        ; // constructor is handled below
                     break;case passing_style::move:
                         suffix1 += " &&";
 
@@ -3803,6 +3807,7 @@ class cppfront
                         if (
                             func->is_constructor()
                             && func->parameters->ssize() == 2
+                            && !emit_constructor_as_assignment
                             )
                         {
                             prefix += "explicit ";
@@ -3823,13 +3828,12 @@ class cppfront
 
                 //  Now we have all the pieces we need for the Cpp1 function declaration
 
-                //  This flag is because certain operator= functions are emitted twice,
-                //  once as a constructor and once as an assignment operator
-                auto done_emitting_this_function = false;
-
                 //  For a constructor, we need to do more work to translate in-body
                 //  initialization statements to the Cpp1 mem-init-list syntax
-                if (n.is_constructor())
+                if (
+                    n.is_constructor()
+                    && !emit_constructor_as_assignment
+                    )
                 {
                     assert(
                         !is_main
@@ -3987,6 +3991,12 @@ class cppfront
                     printer.print_cpp2( prefix, n.position() );
                     printer.print_cpp2( *n.parent_declaration->name(), n.position() );
                     emit( *func, n.name(), false, true);
+
+                    //  If this operator= has two parameters, do a recursive
+                    //  call to also emit it as a Cpp1 assignment operator
+                    if (func->parameters->ssize() == 2) {
+                        do_recursive_call_for_assignment = true;
+                    }
                 }
 
                 //  For a destructor, we need to translate
@@ -4199,6 +4209,19 @@ class cppfront
 
             printer.print_cpp2( "; ", n.position() );
         }
+
+        //  Finally, if this was a constructor and we want also want to emit
+        //  it as an assignemnt operator, do it via a recusive call
+        if (do_recursive_call_for_assignment)
+        {
+            //  Reset the 'emitted' flags
+            for (auto& statement : n.get_initializer_statements()) {
+                statement->emitted = false;
+            }
+
+            //  Then do the recursive call
+            emit( n, capture_intro, true );
+        }
     }
 
 
