Parse an expression to initialize an object, not any statement

regression-tests/pure2-object-init-expression.cpp2

@@ -0,0 +1,19 @@
+v : std::any = 12;
+
+main: () = {
+    // object initializer must be an expression, not a statement
+    // inspect only allows a result type when it is an expression
+    i: int = inspect v -> int {
+        is 12 = 12;
+        is _ = 0;
+    };
+    [[assert: i == 12]]
+
+    // inference
+    s := inspect v -> std::string {
+        is 5 = "five";
+        is int = "some other integer";
+        is _ = "not an integer";
+    };
+    [[assert: s == "some other integer"]]
+}

regression-tests/test-results/pure2-object-init-expression.cpp

@@ -0,0 +1,38 @@
+
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+extern std::any v;
+
+auto main() -> int;
+
+
+//=== Cpp2 function definitions =================================================
+
+std::any v {12}; 
+
+auto main() -> int{
+    // object initializer must be an expression, not a statement
+    // inspect only allows a result type when it is an expression
+    int i {[&] () -> int { auto&& _expr = v;
+        if (cpp2::is(_expr, 12)) { if constexpr( requires{12;} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((12)),int> ) return 12; else return int{}; else return int{}; }
+        else return 0; }
+    ()}; 
+    cpp2::Default.expects(std::move(i) == 12, "");
+
+    // inference
+    auto s {[&] () -> std::string { auto&& _expr = v;
+        if (cpp2::is(_expr, 5)) { if constexpr( requires{"five";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("five")),std::string> ) return "five"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is<int>(_expr)) { if constexpr( requires{"some other integer";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("some other integer")),std::string> ) return "some other integer"; else return std::string{}; else return std::string{}; }
+        else return "not an integer"; }
+    ()}; 
+    cpp2::Default.expects(std::move(s) == "some other integer", "");
+}
+

source/parse.h

@@ -8025,7 +8025,19 @@ class parser
                     }
                 }
 
-                if (!(n->initializer = statement(semicolon_required, n->equal_sign))) {
+                if (n->is_object()) {
+                    //  An object initializer must be an expression
+                    auto es = expression_statement(semicolon_required);
+                    if (es) {
+                        n->initializer = std::make_unique<statement_node>();
+                        n->initializer->statement = std::move(es);
+                    } else {
+                        error("ill-formed object initializer", true, {}, true);
+                        next();
+                        return {};
+                    }
+                }
+                else if (!(n->initializer = statement(semicolon_required, n->equal_sign))) {
                     error(
                         "ill-formed initializer",
                         true, {}, true

source/sema.h

@@ -1018,18 +1018,13 @@ class sema
         }
 
         //  An object initializer must be an expression
-        if (
-            n.is_object()
-            && n.initializer
-            && !n.initializer->is_expression()
+        assert(
+            !n.is_object()
+            || (
+                !n.initializer
+                || n.initializer->is_expression()
             )
-        {
-            errors.emplace_back(
-                n.position(),
-                "an object initializer must be an expression"
-            );
-            return false;
-        }
+        );
 
         //  A namespace must be initialized with a compound expression
         if (