Add support for default member initializers in constructors

If the constructor doesn't explicitly initialize a data member, use the member initializer

Also, fix a bug where initially I was emitting just a single-token initializer... initialization with general expressions should all work now

Author: hsutter

regression-tests/pure2-types-basics.cpp2

@@ -5,20 +5,27 @@ myclass : type = {
 
     operator=: (implicit out this, x: int) = {
         data = x;
-        more = "xyzzy";
+        // use default initializer for this.more
         std::cout << "myclass: implicit constructor from int\n";
+        print();
     }
 
     operator=: (out this, s: std::string) = {
         this.data = 99;
         this.more = "plugh";
         std::cout << "myclass: explicit constructor from string\n";
+        print();
     }
 
     operator=: (out this) = {
-        data = -3;
-        more = "-3";
+        // use default initializer for this.data
+        more = std::to_string(3.14159);
         std::cout << "myclass: default constructor\n";
+        print();
+    }
+
+    print: (this) = {
+        std::cout << "    data: (data)$, more: (more)$\n";
     }
 
     operator=: (move this) = {
@@ -29,8 +36,8 @@ myclass : type = {
         std::cout << "N::myclass::f with (x)$\n";
     }
 
-    data: int;
-    more: std::string;
+    data: int         = 42 * 12;
+    more: std::string = std::to_string(42 * 12);
 
     nested : type = {
         g: () = std::cout << "N::myclass::nested::g\n";

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

@@ -1,12 +1,15 @@
 myclass: implicit constructor 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
+    data: 504, more: 3.141590
 myclass: destructor
 myclass: destructor
 myclass: destructor

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

@@ -1,12 +1,15 @@
 myclass: implicit constructor 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
+    data: 504, more: 3.141590
 myclass: destructor
 myclass: destructor
 myclass: destructor

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

@@ -1,12 +1,15 @@
 myclass: implicit constructor 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
+    data: 504, more: 3.141590
 myclass: destructor
 myclass: destructor
 myclass: destructor

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

@@ -8,7 +8,7 @@
 namespace N   {
 class myclass;
 };
-#line 48 "pure2-types-basics.cpp2"
+#line 55 "pure2-types-basics.cpp2"
 auto main() -> int;
 
 //=== Cpp2 definitions ==========================================================
@@ -21,29 +21,36 @@ class myclass   {
 
     public: myclass(cpp2::in<int> x)
         : data{ x }
-        , more{ "xyzzy" }
+        , more{ std::to_string(42 * 12) }
 #line 7 "pure2-types-basics.cpp2"
 {
-
+        // use default initializer for this.more
         std::cout << "myclass: implicit constructor from int\n";
+        print();
     }
 
     public: explicit myclass(cpp2::in<std::string> s)
         : data{ 99 }
         , more{ "plugh" }
-#line 13 "pure2-types-basics.cpp2"
+#line 14 "pure2-types-basics.cpp2"
 {
 
         std::cout << "myclass: explicit constructor from string\n";
+        print();
     }
 
     public: myclass()
-        : data{ 3 }
-        , more{ "-3" }
-#line 19 "pure2-types-basics.cpp2"
-{
+        : data{ 42 * 12 }
+        , more{ std::to_string(3.14159) }
+#line 21 "pure2-types-basics.cpp2"
+{       // use default initializer for this.data
 
         std::cout << "myclass: default constructor\n";
+        print();
+    }
+
+    public: auto print() const -> void{
+        std::cout << "    data: " + cpp2::to_string(data) + ", more: " + cpp2::to_string(more) + "\n";
     }
 
     public: ~myclass(){
@@ -54,8 +61,8 @@ class myclass   {
         std::cout << "N::myclass::f with " + cpp2::to_string(x) + "\n";
     }
 
-    private: int data; 
-    private: std::string more; 
+    private: int data {42 * 12}; 
+    private: std::string more {std::to_string(42 * 12)}; 
 
     public: class nested {
         public: static auto g() -> void { std::cout << "N::myclass::nested::g\n"; }

source/cppfront.cpp

@@ -3715,7 +3715,10 @@ class cppfront
                         auto exprs = (*statement)->get_lhs_rhs_if_simple_assignment();
 
                         assert(!exprs.lhs || exprs.lhs->expr);
-                        auto is_match = false;
+                        auto is_match    = false;
+                        auto stmt_pos    = (*statement)->position();
+                        auto initializer = std::string{};
+
                         if (exprs.lhs)
                         {
                             //  First, see if it's an assignment 'name = something'
@@ -3734,30 +3737,47 @@ class cppfront
                                     is_match = true;
                                 }
                             }
-                        } 
+
+                            if (is_match)
+                            {
+                                assert(exprs.rhs);
+                                initializer = print_to_string( *exprs.rhs );
+
+                                //  We've used this statement, so note that
+                                //  and move 'statement' forward
+                                (*statement)->emitted = true;
+                                ++statement;
+                            }
+                        }
+
+                        //  Otherwise, if the member has an initializer, we can use that
+                        if (!is_match &&
+                            (*object)->initializer
+                            )
+                        {
+                            is_match = true;
+                            initializer = print_to_string( *(*object)->initializer, false );
+                        }
 
                         //  If this is not an assignment to *object, complain
                         if (!is_match)
                         {
                             errors.emplace_back(
-                                (*statement)->position(),
+                                stmt_pos,
                                 "expected '" + (*object)->name()->to_string(true) + " = ...' initialization statement - " + error_msg
                             );
                             return;
                         }
 
-                        assert(exprs.rhs && exprs.rhs->expr);
                         current_function_info.back().prolog.mem_inits.push_back(
                             separator +
                             (*object)->name()->to_string(true) +
                             "{ " +
-                            exprs.rhs->expr->get_token()->to_string(true) +
+                            initializer +
                             " }"
                         );
-                        (*statement)->emitted = true;
 
                         ++object;
-                        ++statement;
                         separator = ", ";
                     }
 

source/parse.h

@@ -179,8 +179,8 @@ struct literal_node {
 struct postfix_expression_node;
 
 struct postfix_expression_node_pair {
-    postfix_expression_node const* lhs;
-    postfix_expression_node const* rhs;
+    postfix_expression_node * lhs;
+    postfix_expression_node * rhs;
 };
 
 
@@ -190,7 +190,7 @@ struct prefix_expression_node
     std::unique_ptr<postfix_expression_node> expr;
 
     auto get_postfix_expression_node() const
-        -> postfix_expression_node const*
+        -> postfix_expression_node *
     {
         assert(expr);
         return expr.get();
@@ -218,15 +218,15 @@ struct binary_expression_node
 
     //  Get left-hand postfix-expression
     auto get_postfix_expression_node() const
-        -> postfix_expression_node const*
+        -> postfix_expression_node *
     {
         assert(expr);
         return expr->get_postfix_expression_node();
     }
 
     //  Get first right-hand postfix-expression, if there is one
     auto get_second_postfix_expression_node() const
-        -> postfix_expression_node const*
+        -> postfix_expression_node *
     {
         if (!terms.empty()) {
             assert(terms.front().expr);
@@ -756,7 +756,7 @@ struct is_as_expression_node
     std::vector<term> ops;
 
     auto get_postfix_expression_node() const
-        -> postfix_expression_node const*
+        -> postfix_expression_node *
     {
         assert(expr);
         return expr->get_postfix_expression_node();