Added support for that parameters

Must be `in` or `move`, and only allowed as the second parameter of `operator=`

`that` has special powers, including that every use of a `move that` parameter is a move, including memberwise `that.member` uses... to make that safer, added checks for attempts to double move the same member (or the whole object and a member)

And fixed some bugs, such as correcting the code gen when a constructor uses default initializers to initialize all members

Author: hsutter

regression-tests/pure2-types-that-parameters.cpp2

@@ -0,0 +1,38 @@
+
+myclass : type = {
+
+    operator=: (out this) = { }
+
+    operator=: (out this, that) = {
+        name = that.name;
+        addr = that.addr;
+    }
+
+    operator=: (out this, move that) = {
+        name = that.name;
+        addr = that.addr;
+    }
+
+    print: (this) = {
+        std::cout << "name '(name)$', addr '(addr)$'\n";
+    }
+
+    name: std::string = "Henry";
+    addr: std::string = "123 Ford Dr.";
+
+}
+
+main: () = {
+    x: myclass = ();
+    x.print();
+
+    std::cout << "-----\n";
+    y := x;
+    x.print();
+    y.print();
+
+    std::cout << "-----\n";
+    z := (move x);
+    x.print();
+    z.print();
+}

regression-tests/test-results/clang-12/pure2-types-that-parameters.cpp.execution

@@ -0,0 +1,7 @@
+name 'Henry', addr '123 Ford Dr.'
+-----
+name 'Henry', addr '123 Ford Dr.'
+name 'Henry', addr '123 Ford Dr.'
+-----
+name '', addr ''
+name 'Henry', addr '123 Ford Dr.'

regression-tests/test-results/clang-12/pure2-types-that-parameters.cpp.output

@@ -0,0 +1,7 @@
+name 'Henry', addr '123 Ford Dr.'
+-----
+name 'Henry', addr '123 Ford Dr.'
+name 'Henry', addr '123 Ford Dr.'
+-----
+name '', addr ''
+name 'Henry', addr '123 Ford Dr.'

regression-tests/test-results/gcc-10/pure2-types-that-parameters.cpp.execution

@@ -0,0 +1,7 @@
+name 'Henry', addr '123 Ford Dr.'
+-----
+name 'Henry', addr '123 Ford Dr.'
+name 'Henry', addr '123 Ford Dr.'
+-----
+name '', addr ''
+name 'Henry', addr '123 Ford Dr.'

regression-tests/test-results/gcc-10/pure2-types-that-parameters.cpp.output

@@ -0,0 +1 @@
+pure2-types-that-parameters.cpp

regression-tests/test-results/msvc-2022/pure2-types-that-parameters.cpp.execution

@@ -0,0 +1,62 @@
+
+#define CPP2_USE_MODULES         Yes
+
+#include "cpp2util.h"
+
+
+#line 2 "pure2-types-that-parameters.cpp2"
+class myclass;
+#line 25 "pure2-types-that-parameters.cpp2"
+auto main() -> int;
+
+//=== Cpp2 definitions ==========================================================
+
+#line 1 "pure2-types-that-parameters.cpp2"
+
+class myclass   {
+
+    public: myclass()         
+                              : name{ "Henry" }
+                              , addr{ "123 Ford Dr." }
+#line 5 "pure2-types-that-parameters.cpp2"
+{}
+    public: explicit myclass(myclass const& that)
+        : name{ that.name }
+        , addr{ that.addr }
+#line 7 "pure2-types-that-parameters.cpp2"
+{
+
+    }public: auto operator=(myclass const& that) -> void{name = that.name;addr = that.addr;}
+
+    public: explicit myclass(myclass&& that)
+        : name{ std::move(that).name }
+        , addr{ std::move(that).addr }
+#line 12 "pure2-types-that-parameters.cpp2"
+{
+
+    }public: auto operator=(myclass&& that) -> void{name = std::move(that).name;addr = std::move(that).addr;}
+
+    public: auto print() const -> void{
+        std::cout << "name '" + cpp2::to_string(name) + "', addr '" + cpp2::to_string(addr) + "'\n";
+    }
+
+    private: std::string name {"Henry"}; 
+    private: std::string addr {"123 Ford Dr."}; 
+
+};
+
+auto main() -> int{
+    myclass x {}; 
+    CPP2_UFCS_0(print, x);
+
+    std::cout << "-----\n";
+    auto y {x}; 
+    CPP2_UFCS_0(print, x);
+    CPP2_UFCS_0(print, std::move(y));
+
+    std::cout << "-----\n";
+    auto z {std::move(x)}; 
+    CPP2_UFCS_0(print, std::move(x));
+    CPP2_UFCS_0(print, std::move(z));
+}
+

regression-tests/test-results/msvc-2022/pure2-types-that-parameters.cpp.output

@@ -0,0 +1,2 @@
+pure2-types-that-parameters.cpp2... ok (all Cpp2, passes safety checks)
+

regression-tests/test-results/pure2-types-that-parameters.cpp

@@ -825,6 +825,9 @@ class cppfront
     bool violates_initialization_safety = false;
     bool suppress_move_from_last_use    = false;
 
+    bool in_move_that_function          = false;
+    std::vector<token const*> already_moved_that_members = {};
+
     struct arg_info {
         passing_style pass   = passing_style::in;
         token const*  ptoken = {};
@@ -1318,6 +1321,14 @@ class cppfront
                 )
             && !in_non_rvalue_context.back();
 
+        if (
+            in_move_that_function
+            && *n.identifier == "that"
+            )
+        {
+            add_move = true;
+        }
+
         //  For an explicit 'forward' apply forwarding to correct identifier
         assert (!current_args.empty());
         if (current_args.back().pass == passing_style::forward) {
@@ -1357,10 +1368,11 @@ class cppfront
             if (auto decl = sema.get_declaration_of(*n.identifier);
                 is_local_name
                 && !(*n.identifier == "this")
+                && !(*n.identifier == "that")
                 && decl
-                //  note pointer equality: if we're not in the actual declaration of n.identifier
                 && (
                     in_synthesized_multi_return
+                    //  note pointer equality: if we're not in the actual declaration of n.identifier
                     || decl->identifier != n.identifier
                     )
                 //  and this variable was uninitialized
@@ -2252,6 +2264,51 @@ class cppfront
         assert(n.expr);
         last_postfix_expr_was_pointer = false;
 
+        //  For a 'move that' parameter, track the members we already moved from
+        //  so we can diagnose attempts to move from the same member twice
+        if (
+            in_move_that_function
+            && *n.expr->get_token() == "that"
+            )
+        {
+            if (n.ops.empty()) {
+                if (!already_moved_that_members.empty()) {
+                    errors.emplace_back(
+                        n.position(),
+                        "attempting to move from whole 'that' object after a 'that.member' was already moved from"
+                    );
+                    return;
+                }
+                //  push a sentinel for "all members"
+                already_moved_that_members.push_back(nullptr);
+            }
+            else {
+                auto member = n.ops[0].id_expr->get_token();
+                assert(member);
+
+                for (
+                    auto i = already_moved_that_members.begin();
+                    i != already_moved_that_members.end();
+                    ++i
+                    )
+                {
+                    if (
+                        !*i
+                        || **i == *member
+                        )
+                    {
+                        errors.emplace_back(
+                            n.position(),
+                            "attempting to move twice from 'that." + member->to_string(true) + "'"
+                        );
+                        return;
+                    }
+                }
+
+                already_moved_that_members.push_back(member);
+            }
+        }
+
         //  Ensure that forwarding postfix-expressions start with a forwarded parameter name
         //
         assert (!current_args.empty());
@@ -3235,6 +3292,43 @@ class cppfront
             //  Since we're skipping "out this," plus possibly "implicit " and
             //  whitespace, any following parameters on the same line can shift left
             printer.add_pad_in_this_line(-18);
+
+            return;
+        }
+
+        //-----------------------------------------------------------------------
+        //  Handle 'that' parameters
+
+        if (n.declaration->has_name("that"))
+        {
+            assert(
+                n.pass == passing_style::in
+                || n.pass == passing_style::move
+            );
+            auto pass = std::string{" const&"};
+            if (n.pass == passing_style::move) {
+                pass = "&&";
+                in_move_that_function = true;
+            }
+
+            auto func_name = get_enclosing_function_name();
+            assert(func_name);
+
+            if (*func_name != "operator=") {
+                errors.emplace_back(
+                    n.position(),
+                    "only an operator= function may have a 'that' parameter"
+                );
+                return;
+            }
+
+            auto type_name = get_enclosing_type_name();
+            assert(type_name);
+
+            printer.print_cpp2(
+                type_name->to_string(true) + pass + " that",
+                n.position()
+            );
             return;
         }
 
@@ -3669,6 +3763,68 @@ class cppfront
     }
 
 
+    //-----------------------------------------------------------------------
+    //
+    auto get_enclosing_type_name()
+        -> token const*
+    {
+        //  Navigate to the enclosing type, if there is one...
+        for (auto parent = current_declarations.rbegin();
+            parent != current_declarations.rend();
+            ++parent
+            )
+        {
+            if (
+                *parent
+                && (*parent)->is_namespace()
+                )
+            {
+                break;
+            }
+            //  ... and here it is, so...
+            if (
+                *parent
+                && (*parent)->is_type()
+                )
+            {
+                return (*parent)->name();
+            }
+        }
+        return {};
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto get_enclosing_function_name()
+        -> token const*
+    {
+        //  Navigate to the enclosing function, if there is one...
+        for (auto parent = current_declarations.rbegin();
+            parent != current_declarations.rend();
+            ++parent
+            )
+        {
+            if (
+                *parent
+                && (*parent)->is_namespace()
+                )
+            {
+                break;
+            }
+            //  ... and here it is, so...
+            if (
+                *parent
+                && (*parent)->is_function()
+                )
+            {
+                return (*parent)->name();
+            }
+        }
+        return {};
+    }
+
+
     //-----------------------------------------------------------------------
     //
     auto emit(
@@ -3680,6 +3836,15 @@ class cppfront
     {
         auto do_recursive_call_for_assignment = false;
 
+        if (
+            n.is_function()
+            && n.has_name()
+            )
+        {   // reset the 'we have a move-that on this function' flag
+            in_move_that_function = false;
+            already_moved_that_members = {};
+        }
+
         auto is_main =
             !n.parent_declaration
             && n.has_name("main")
@@ -3913,6 +4078,15 @@ class cppfront
                     && !emit_constructor_as_assignment
                     )
                 {
+                    if (
+                        func->parameters->ssize() > 1
+                        && (*func->parameters)[1]->has_name("that")
+                        && (*func->parameters)[1]->pass == passing_style::move
+                        )
+                    {
+                        in_move_that_function = true;
+                    }
+
                     assert(
                         !is_main
                         // prefix can be "explicit "
@@ -4035,6 +4209,7 @@ class cppfront
                                 initializer +
                                 " }"
                             );
+                            separator = ", ";
                         }
                         else
                         {