Let metafunctions replace specific members, and apply to basic_enum

Before, `basic_enum` was just removing all the statements in a type's body, not just the object declarations it was replacing. This  has two problems:
- It masked programmer errors that would normally have been diagnosed in sema, such as writing an assignment statement by accident (e.g., `wrong: @enum type = { oops = assignment; /* intended to write := here, but the errant statement was just silently removed */ }`
- It disabled the ability for programmers to do things like write member functions of enumeration types

Now that `basic_enum` removes only the data members that it processes, any other code inside the body will be diagnosed or allowed, as appropriate.

Author: hsutter

regression-tests/pure2-enum.cpp2

@@ -8,10 +8,19 @@ skat_game: @enum type = {
     null     := 23;
 }
 
-rgb: @enum type = {
-    red;     // 0
-    green;   // 1
-    blue;    // 2
+duality: @enum type = {
+    first;
+    second;
+
+    flip: (inout this, val: duality) = {
+        if val == first {
+            value__ = second.value__;
+        }
+        else {
+            [[assert: value__ == second.value__]]
+            value__ = first.value__;
+        }
+    }
 }
 
 file_attributes: @flag_enum<u8> type = {
@@ -22,6 +31,11 @@ file_attributes: @flag_enum<u8> type = {
 }
 
 main: () = {
+    janus := duality::second;
+    std::cout << "janus is initially (janus.to_string())$\n";
+    janus.flip( janus );
+    std::cout << "janus is flipped to (janus.to_string())$\n";
+
     // x : skat_game = 9;               // error, can't construct skat_game from integer
 
     x: skat_game = skat_game::clubs;

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

@@ -1,3 +1,5 @@
+janus is initially second
+janus is flipped to first
 x.to_string() is clubs
 x2.to_string() is clubs
 using << prints clubs

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

@@ -1,3 +1,5 @@
+janus is initially second
+janus is flipped to first
 x.to_string() is clubs
 x2.to_string() is clubs
 using << prints clubs

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

@@ -1,3 +1,5 @@
+janus is initially second
+janus is flipped to first
 x.to_string() is clubs
 x2.to_string() is clubs
 using << prints clubs

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

@@ -1,3 +1,5 @@
+janus is initially second
+janus is flipped to first
 x.to_string() is clubs
 x2.to_string() is clubs
 using << prints clubs

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

@@ -12,10 +12,10 @@ class skat_game;
 
 
 #line 11 "pure2-enum.cpp2"
-class rgb;
+class duality;
 
 
-#line 17 "pure2-enum.cpp2"
+#line 26 "pure2-enum.cpp2"
 class file_attributes;
 
 
@@ -51,28 +51,27 @@ public: friend auto operator<<(std::ostream& o, cpp2::in<skat_game> val) -> std:
 #line 9 "pure2-enum.cpp2"
 };
 
-class rgb {
-public: static const cpp2::i8 enumeration_count;
-private: cpp2::i8 value__; private: constexpr rgb(auto const& val);
+class duality {
+
+#line 15 "pure2-enum.cpp2"
+    public: auto flip(cpp2::in<duality> val) & -> void;
+        
+        public: static const cpp2::i8 enumeration_count;
+private: cpp2::i8 value__; private: constexpr duality(auto const& val);
 
-private: constexpr auto operator=(auto const& val) -> rgb& ;
+private: constexpr auto operator=(auto const& val) -> duality& ;
 public: [[nodiscard]] constexpr auto get_raw_value() const& -> cpp2::i8;
-public: constexpr rgb(rgb const& that);
-public: constexpr auto operator=(rgb const& that) -> rgb& ;
-public: constexpr rgb(rgb&& that) noexcept;
-public: constexpr auto operator=(rgb&& that) noexcept -> rgb& ;
-public: [[nodiscard]] auto operator<=>(rgb const& that) const& -> std::strong_ordering = default;
-public: static const rgb red;
-public: static const rgb green;
-public: static const rgb blue;
+public: constexpr duality(duality const& that);
+public: constexpr auto operator=(duality const& that) -> duality& ;
+public: constexpr duality(duality&& that) noexcept;
+public: constexpr auto operator=(duality&& that) noexcept -> duality& ;
+public: [[nodiscard]] auto operator<=>(duality const& that) const& -> std::strong_ordering = default;
+public: static const duality first;
+public: static const duality second;
 public: [[nodiscard]] auto to_string() const& -> std::string;
-public: friend auto operator<<(std::ostream& o, cpp2::in<rgb> val) -> std::ostream&;
+public: friend auto operator<<(std::ostream& o, cpp2::in<duality> val) -> std::ostream&;
 
-#line 12 "pure2-enum.cpp2"
-             // 0
-             // 1
-             // 2
-#line 15 "pure2-enum.cpp2"
+#line 24 "pure2-enum.cpp2"
 };
 
 class file_attributes {
@@ -103,12 +102,12 @@ public: static const file_attributes none;
 public: [[nodiscard]] auto to_string() const& -> std::string;
 public: friend auto operator<<(std::ostream& o, cpp2::in<file_attributes> val) -> std::ostream&;
 
-#line 18 "pure2-enum.cpp2"
+#line 27 "pure2-enum.cpp2"
                 // 1
                 // 2
                 // 4
 
-#line 22 "pure2-enum.cpp2"
+#line 31 "pure2-enum.cpp2"
 };
 
 auto main() -> int;
@@ -159,38 +158,48 @@ inline constexpr skat_game skat_game::null = 23;
     }
 
     [[nodiscard]] auto operator<<(std::ostream& o, cpp2::in<skat_game> val) -> std::ostream&{o << CPP2_UFCS_0(to_string, val);return o; }
-inline constexpr cpp2::i8 rgb::enumeration_count = 3;
+#line 15 "pure2-enum.cpp2"
+    auto duality::flip(cpp2::in<duality> val) & -> void{
+        if (val == first) {
+            value__ = second.value__;
+        }
+        else {
+            cpp2::Default.expects(value__ == second.value__, "");
+            value__ = first.value__;
+        }
+    }
 
-constexpr rgb::rgb(auto const& val)
+    inline constexpr cpp2::i8 duality::enumeration_count = 2;
+
+
+constexpr duality::duality(auto const& val)
                                                     : value__{ cpp2::unsafe_narrow<cpp2::i8>(val) } {  }
-constexpr auto rgb::operator=(auto const& val) -> rgb&  { 
+
+constexpr auto duality::operator=(auto const& val) -> duality&  { 
                                                     value__ = cpp2::unsafe_narrow<cpp2::i8>(val);
                                                     return *this; }
-[[nodiscard]] constexpr auto rgb::get_raw_value() const& -> cpp2::i8 { return value__; }
-constexpr rgb::rgb(rgb const& that)
+[[nodiscard]] constexpr auto duality::get_raw_value() const& -> cpp2::i8 { return value__; }
+constexpr duality::duality(duality const& that)
                                               : value__{ that.value__ }{}
-constexpr auto rgb::operator=(rgb const& that) -> rgb& {
+constexpr auto duality::operator=(duality const& that) -> duality& {
                                               value__ = that.value__;
                                               return *this;}
-constexpr rgb::rgb(rgb&& that) noexcept
+constexpr duality::duality(duality&& that) noexcept
                                               : value__{ std::move(that).value__ }{}
-constexpr auto rgb::operator=(rgb&& that) noexcept -> rgb& {
+constexpr auto duality::operator=(duality&& that) noexcept -> duality& {
                                               value__ = std::move(that).value__;
                                               return *this;}
-inline constexpr rgb rgb::red = 0;
+inline constexpr duality duality::first = 0;
 
-inline constexpr rgb rgb::green = 1;
+inline constexpr duality duality::second = 1;
 
-inline constexpr rgb rgb::blue = 2;
-
-[[nodiscard]] auto rgb::to_string() const& -> std::string{
-    if ((*this) == red) {return "red"; }
-    if ((*this) == green) {return "green"; }
-    if ((*this) == blue) {return "blue"; }
-    return "invalid rgb value"; 
+[[nodiscard]] auto duality::to_string() const& -> std::string{
+    if ((*this) == first) {return "first"; }
+    if ((*this) == second) {return "second"; }
+    return "invalid duality value"; 
     }
 
-    [[nodiscard]] auto operator<<(std::ostream& o, cpp2::in<rgb> val) -> std::ostream&{o << CPP2_UFCS_0(to_string, val);return o; }
+    [[nodiscard]] auto operator<<(std::ostream& o, cpp2::in<duality> val) -> std::ostream&{o << CPP2_UFCS_0(to_string, val);return o; }
 inline constexpr cpp2::u8 file_attributes::enumeration_count = 4;
 
 constexpr file_attributes::file_attributes(auto const& val)
@@ -242,8 +251,13 @@ inline constexpr file_attributes file_attributes::none = 0;
     }
 
     [[nodiscard]] auto operator<<(std::ostream& o, cpp2::in<file_attributes> val) -> std::ostream&{o << CPP2_UFCS_0(to_string, val);return o; }
-#line 24 "pure2-enum.cpp2"
+#line 33 "pure2-enum.cpp2"
 auto main() -> int{
+    auto janus {duality::second}; 
+    std::cout << "janus is initially " + cpp2::to_string(CPP2_UFCS_0(to_string, janus)) + "\n";
+    CPP2_UFCS(flip, janus, janus);
+    std::cout << "janus is flipped to " + cpp2::to_string(CPP2_UFCS_0(to_string, std::move(janus))) + "\n";
+
     // x : skat_game = 9;               // error, can't construct skat_game from integer
 
     skat_game x {skat_game::clubs}; 

regression-tests/test-results/version

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

source/build.info

@@ -1 +1 @@
-"8923:1137"
+"8923:1630"

source/parse.h

@@ -2546,19 +2546,39 @@ struct declaration_node
         return false;
     }
 
+    auto type_remove_marked_members()
+        -> void
+    {
+        assert (is_type() && initializer && initializer->is_compound());
+        auto compound_stmt = initializer->get_if<compound_statement_node>();
+        assert (compound_stmt);
+
+        //  Note: This loop is a careful use of the brittle STL "erase" idiom. Do not change this
+        //        loop without carefully ensuring it remains safe against iterator invalidation.
+        //        (Especially don't change this to a for loop with a "++i" iteration-expression.)
+        auto i = compound_stmt->statements.begin();
+        while (i != compound_stmt->statements.end())
+        {
+            if ((*i)->marked_for_removal) {
+                i = compound_stmt->statements.erase(i); // these two branches ...
+            }
+            else {
+                ++i;                                    // ... must stay together
+            }
+        }
+    }
+
     auto type_remove_all_members()
         -> void
     {
-        assert (is_type() && initializer->is_compound());
+        assert (is_type() && initializer && initializer->is_compound());
         auto body = initializer->get_if<compound_statement_node>();
         assert (body);
 
-        //  Drop all statements in the body
+        //  Drop all statements in the body, which should self-deregister all our 'captures'
+        //  - (only) statements in the body should have been able to refer to 'captures'
         body->statements.clear();
-
-        //  Then also drop captures - (only) statements in
-        //  the body should have been able to refer to it
-        captures = {};
+        assert(captures.members.empty());
     }
 
     auto type_disable_member_function_generation()