Add variadic member set for @union

And fix the `is_fold_expression` implementation

Author: hsutter

regression-tests/pure2-union.cpp2

@@ -19,8 +19,7 @@ main: () = {
 
     x.print_name();
 
-    s: std::string = "xyzzy";
-    x.set_name( s );
+    x.set_name( "xyzzy", 3 as u8 );
 
     x.print_name();
 }

regression-tests/test-results/clang-12/pure2-print.cpp.output

@@ -1,7 +1,7 @@
-pure2-print.cpp2:50:80: warning: unused parameter 't' [-Wunused-parameter]
+pure2-print.cpp2:52:80: warning: unused parameter 't' [-Wunused-parameter]
         template<typename T> [[nodiscard]] auto outer::mytype::values(T const& t) const& -> values__ret{
                                                                                ^
-pure2-print.cpp2:61:53: warning: unused parameter 'x' [-Wunused-parameter]
+pure2-print.cpp2:63:53: warning: unused parameter 'x' [-Wunused-parameter]
         auto outer::mytype::variadic(auto const& ...x) -> void{}
                                                     ^
 2 warnings generated.

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

@@ -1,3 +1,3 @@
 sizeof(x) is 33
 (not a name)
-xyzzy
+xyz

regression-tests/test-results/gcc-10/pure2-print.cpp.output

@@ -1,6 +1,8 @@
 In file included from pure2-print.cpp:7:
+../../../include/cpp2util.h:10005:33: error: expected unqualified-id before ‘static_assert’
+pure2-print.cpp2:7:1: note: in expansion of macro ‘CPP2_REQUIRES_’
 ../../../include/cpp2util.h:10005:33: error: expected initializer before ‘static_assert’
-pure2-print.cpp2:80:1: note: in expansion of macro ‘CPP2_REQUIRES_’
-pure2-print.cpp2:79:37: error: no declaration matches ‘void outer::print(std::ostream&, const Args& ...) requires  cpp2::cmp_greater_eq(sizeof (Args)..., 0)’
-pure2-print.cpp2:79:37: note: no functions named ‘void outer::print(std::ostream&, const Args& ...) requires  cpp2::cmp_greater_eq(sizeof (Args)..., 0)’
+pure2-print.cpp2:89:1: note: in expansion of macro ‘CPP2_REQUIRES_’
+pure2-print.cpp2:88:37: error: no declaration matches ‘void outer::print(std::ostream&, const Args& ...) requires  cpp2::cmp_greater_eq(sizeof (Args)..., 0)’
+pure2-print.cpp2:88:37: note: no functions named ‘void outer::print(std::ostream&, const Args& ...) requires  cpp2::cmp_greater_eq(sizeof (Args)..., 0)’
 pure2-print.cpp2:4:7: note: ‘class outer’ defined here

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

@@ -1,3 +1,3 @@
 sizeof(x) is 33
 (not a name)
-xyzzy
+xyz

regression-tests/test-results/gcc-13/pure2-union.cpp.execution

@@ -1,3 +1,3 @@
 sizeof(x) is 33
 (not a name)
-xyzzy
+xyz

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

@@ -1,3 +1,3 @@
 sizeof(x) is 25
 (not a name)
-xyzzy
+xyz

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

@@ -20,10 +20,12 @@ private: std::array<std::byte,cpp2::max(sizeof(std::string), sizeof(cpp2::i32))>
 public: [[nodiscard]] auto get_name() const& -> auto&&;
 public: [[nodiscard]] auto get_name() & -> auto&&;
 public: auto set_name(cpp2::in<std::string> value) & -> void;
+public: auto set_name(auto&& ...args) & -> void;
 public: [[nodiscard]] auto is_num() const& -> bool;
 public: [[nodiscard]] auto get_num() const& -> auto&&;
 public: [[nodiscard]] auto get_num() & -> auto&&;
 public: auto set_num(cpp2::in<cpp2::i32> value) & -> void;
+public: auto set_num(auto&& ...args) & -> void;
 private: auto destroy() & -> void;
 public: ~name_or_number() noexcept;
 
@@ -52,12 +54,14 @@ auto main() -> int;
 [[nodiscard]] auto name_or_number::get_name() & -> auto&& { 
                                                                     cpp2::Default.expects(is_name(), "");return *cpp2::assert_not_null(reinterpret_cast<std::string*>(&storage__)); }
 auto name_or_number::set_name(cpp2::in<std::string> value) & -> void{if (!(is_name())) {destroy();std::construct_at(reinterpret_cast<std::string*>(&storage__), value);}else {*cpp2::assert_not_null(reinterpret_cast<std::string*>(&storage__)) = value;}discriminator__ = 0;}
+auto name_or_number::set_name(auto&& ...args) & -> void{if (!(is_name())) {destroy();std::construct_at(reinterpret_cast<std::string*>(&storage__), args...);}else {*cpp2::assert_not_null(reinterpret_cast<std::string*>(&storage__)) = std::string{args...};}discriminator__ = 0;}
 [[nodiscard]] auto name_or_number::is_num() const& -> bool { return discriminator__ == 1; }
 [[nodiscard]] auto name_or_number::get_num() const& -> auto&& { 
                                                             cpp2::Default.expects(is_num(), "");return *cpp2::assert_not_null(reinterpret_cast<cpp2::i32 const*>(&storage__)); }
 [[nodiscard]] auto name_or_number::get_num() & -> auto&& { 
                                                                   cpp2::Default.expects(is_num(), "");return *cpp2::assert_not_null(reinterpret_cast<cpp2::i32*>(&storage__)); }
 auto name_or_number::set_num(cpp2::in<cpp2::i32> value) & -> void{if (!(is_num())) {destroy();std::construct_at(reinterpret_cast<cpp2::i32*>(&storage__), value);}else {*cpp2::assert_not_null(reinterpret_cast<cpp2::i32*>(&storage__)) = value;}discriminator__ = 1;}
+auto name_or_number::set_num(auto&& ...args) & -> void{if (!(is_num())) {destroy();std::construct_at(reinterpret_cast<cpp2::i32*>(&storage__), args...);}else {*cpp2::assert_not_null(reinterpret_cast<cpp2::i32*>(&storage__)) = cpp2::i32{args...};}discriminator__ = 1;}
 auto name_or_number::destroy() & -> void{
     if (discriminator__ == 0) {std::destroy_at(reinterpret_cast<std::string*>(&storage__));}
     if (discriminator__ == 1) {std::destroy_at(reinterpret_cast<cpp2::i32*>(&storage__));}
@@ -80,8 +84,7 @@ auto main() -> int{
 
     CPP2_UFCS_0(print_name, x);
 
-    std::string s {"xyzzy"}; 
-    CPP2_UFCS(set_name, x, std::move(s));
+    CPP2_UFCS(set_name, x, "xyzzy", cpp2::as_<cpp2::u8, 3>());
 
     CPP2_UFCS_0(print_name, std::move(x));
 }

regression-tests/test-results/version

@@ -1,5 +1,5 @@
 
-cppfront compiler v0.2.1   Build 8917:1248
+cppfront compiler v0.2.1   Build 8918:1648
 Copyright(c) Herb Sutter   All rights reserved
 
 SPDX-License-Identifier: CC-BY-NC-ND-4.0

source/build.info

@@ -1 +1 @@
-"8917:1248"
+"8918:1648"

source/parse.h

@@ -145,8 +145,12 @@ struct primary_expression_node
         std::unique_ptr<literal_node>
     > expr;
 
+
     //  API
     //
+    auto is_fold_expression() const
+        -> bool;
+
     auto is_identifier() const
         -> bool;
 
@@ -230,6 +234,9 @@ struct prefix_expression_node
 
     //  API
     //
+    auto is_fold_expression() const
+        -> bool;
+
     auto is_identifier() const
         -> bool;
 
@@ -285,8 +292,21 @@ struct binary_expression_node
     };
     std::vector<term> terms;
 
+
     //  API
     //
+    auto is_fold_expression() const
+        -> bool
+    {
+        //  This is a fold-expression if any subexpression
+        //  has an identifier named "..."
+        auto ret = expr->is_fold_expression();
+        for (auto& x : terms) {
+            ret |= x.expr->is_fold_expression();
+        }
+        return ret;
+    }
+
     auto lhs_is_id_expression() const
         -> bool
     {
@@ -405,6 +425,7 @@ struct binary_expression_node
         return ret;
     }
 
+
     //  Internals
     //
     auto position() const
@@ -467,6 +488,14 @@ struct expression_node
 
     // API
     //
+    auto is_fold_expression() const
+        -> bool
+    {
+        //  This is a fold-expression if any subexpression
+        //  has an identifier named "..."
+        return expr->is_fold_expression();
+    }
+
     auto is_standalone_expression() const
         -> bool;
 
@@ -613,12 +642,13 @@ struct expression_list_node
     auto is_fold_expression() const
         -> bool
     {
-        auto found_ellipsis = false;
+        //  This is a fold-expression if any subexpression
+        //  has an identifier named "..."
+        auto ret = false;
         for (auto& x : expressions) {
-            auto s = x.expr->to_string();
-            found_ellipsis |= s.find("...") != s.npos;
+            ret |= x.expr->is_fold_expression();
         }
-        return found_ellipsis;
+        return ret;
     }
 
 
@@ -789,6 +819,14 @@ struct postfix_expression_node
 
     //  API
     //
+    auto is_fold_expression() const
+        -> bool
+    {
+        //  This is a fold-expression if any subexpression
+        //  has an identifier named "..."
+        return expr->is_fold_expression();
+    }
+
     auto is_identifier() const
         -> bool
     {
@@ -848,6 +886,14 @@ struct postfix_expression_node
     auto visit(auto& v, int depth) -> void;
 };
 
+auto prefix_expression_node::is_fold_expression() const
+    -> bool
+{
+    //  This is a fold-expression if any subexpression
+    //  has an identifier named "..."
+    return expr->is_fold_expression();
+}
+
 auto prefix_expression_node::is_identifier() const
     -> bool
 {
@@ -1269,8 +1315,17 @@ struct is_as_expression_node
     };
     std::vector<term> ops;
 
+
     //  API
     //
+    auto is_fold_expression() const
+        -> bool
+    {
+        //  This is a fold-expression if any subexpression
+        //  has an identifier named "..."
+        return expr->is_fold_expression();
+    }
+
     auto is_identifier() const
         -> bool
     {
@@ -1389,6 +1444,15 @@ struct id_expression_node
         return 0;
     }
 
+    auto is_fold_expression() const
+        -> bool
+    {
+        //  This is a fold-expression if any subexpression has
+        //  has an identifier named "..."
+        auto tok = get_token();
+        return tok && *tok == "...";
+    }
+
     auto is_empty() const
         -> bool
     {
@@ -1447,6 +1511,24 @@ struct id_expression_node
 };
 
 
+auto primary_expression_node::is_fold_expression() const
+    -> bool
+{
+    //  This is a fold-expression if any subexpression has
+    //  has an identifier named "..."
+    switch (expr.index()) {
+    break;case identifier:
+        return *std::get<identifier>(expr) == "...";
+    break;case expression_list:
+        return std::get<expression_list>(expr)->is_fold_expression();
+    break;case id_expression:
+        return std::get<id_expression>(expr)->is_fold_expression();
+    break;default: ; // the others can't contain folds
+    }
+    return false;
+}
+
+
 auto postfix_expression_node::get_first_token_ignoring_this() const
     -> token const*
 {

source/reflect.h

@@ -706,6 +706,8 @@ namespace cpp2 {
 auto parser::apply_type_meta_functions( declaration_node& n )
     -> bool
 {
+    assert(n.is_type());
+
     //  Get the reflection state ready to pass to the function
     auto cs = meta::compiler_services{ &errors, generated_tokens };
     auto rtype = meta::type_declaration{ &n, cs };
@@ -1690,8 +1692,8 @@ std::string comma = "";
         CPP2_UFCS(require, t, CPP2_UFCS(add_member, t, "    public set_" + cpp2::to_string(a.name) + ": (inout this, value: " + cpp2::to_string(a.type) + ") = { if !is_" + cpp2::to_string(a.name) + "() { destroy(); std::construct_at( reinterpret_cast<*" + cpp2::to_string(a.type) + ">(storage__&), value); } else { reinterpret_cast<*" + cpp2::to_string(a.type) + ">(storage__&)* = value; } discriminator__ = " + cpp2::to_string(a.value) + "; }\n"), 
                    "could not add set_" + a.name);
 
-        //t.require( t.add_member( "    public set_(a.name)$: (inout this, forward args...: _) = { if !is_(a.name)$() { destroy(); std::construct_at( reinterpret_cast<*(a.type)$>(storage__&), args...); } else { reinterpret_cast<*(a.type)$>(storage__&)* = value; } discriminator__ = :(a.type)$ = (args...); }\n"),
-        //           "could not add variadic set_" + a.name);
+        CPP2_UFCS(require, t, CPP2_UFCS(add_member, t, "    public set_" + cpp2::to_string(a.name) + ": (inout this, forward args...: _) = { if !is_" + cpp2::to_string(a.name) + "() { destroy(); std::construct_at( reinterpret_cast<*" + cpp2::to_string(a.type) + ">(storage__&), args...); } else { reinterpret_cast<*" + cpp2::to_string(a.type) + ">(storage__&)* = :" + cpp2::to_string(a.type) + " = (args...); } discriminator__ = " + cpp2::to_string(a.value) + "; }\n"), 
+                   "could not add variadic set_" + a.name);
     }
 {
 std::string destroy = "    private destroy: (inout this) = {\n";

source/reflect.h2

@@ -1152,8 +1152,8 @@ union: (inout t : meta::type_declaration)
         t.require( t.add_member( "    public set_(a.name)$: (inout this, value: (a.type)$) = { if !is_(a.name)$() { destroy(); std::construct_at( reinterpret_cast<*(a.type)$>(storage__&), value); } else { reinterpret_cast<*(a.type)$>(storage__&)* = value; } discriminator__ = (a.value)$; }\n"),
                    "could not add set_" + a.name);
 
-        //t.require( t.add_member( "    public set_(a.name)$: (inout this, forward args...: _) = { if !is_(a.name)$() { destroy(); std::construct_at( reinterpret_cast<*(a.type)$>(storage__&), args...); } else { reinterpret_cast<*(a.type)$>(storage__&)* = value; } discriminator__ = :(a.type)$ = (args...); }\n"),
-        //           "could not add variadic set_" + a.name);
+        t.require( t.add_member( "    public set_(a.name)$: (inout this, forward args...: _) = { if !is_(a.name)$() { destroy(); std::construct_at( reinterpret_cast<*(a.type)$>(storage__&), args...); } else { reinterpret_cast<*(a.type)$>(storage__&)* = :(a.type)$ = (args...); } discriminator__ = (a.value)$; }\n"),
+                   "could not add variadic set_" + a.name);
     }
 
     ////  Add operator<<