Allow arbitrary expressions as enumerator initializers

Example: `cached_and_current := cached | current;`

However, because we're not actually evaluating expressions:
- They are required to be last
- Using them requires specifying the underlying type (note this is desirable in general, because arbitrary expressions could change value over time and we wouldn't want the size of the type to depend on possibly-distant changes that change those values)

Author: hsutter

include/cpp2util.h

@@ -1613,26 +1613,26 @@ class strict_value {
     template <typename U> requires std::is_convertible_v<T,U>
     explicit constexpr operator U()       { return t; }
 
-    auto operator<=>( strict_value const& ) const -> std::strong_ordering = default;
+    constexpr auto operator<=>( strict_value const& ) const -> std::strong_ordering = default;
 
     auto to_string() const -> std::string { return Tag::to_string(*this); }
 
     friend auto operator<<(std::ostream& o, strict_value const& v) -> std::ostream& { return o << v.to_string(); }
 
     //  Bitwise operations
 
-    auto operator|=( strict_value const& that )       -> strict_value requires BitwiseOps { t |= that.t; return *this; }
-    auto operator&=( strict_value const& that )       -> strict_value requires BitwiseOps { t &= that.t; return *this; }
-    auto operator^=( strict_value const& that )       -> strict_value requires BitwiseOps { t ^= that.t; return *this; }
+    constexpr auto operator|=( strict_value const& that )       -> strict_value requires BitwiseOps { t |= that.t; return *this; }
+    constexpr auto operator&=( strict_value const& that )       -> strict_value requires BitwiseOps { t &= that.t; return *this; }
+    constexpr auto operator^=( strict_value const& that )       -> strict_value requires BitwiseOps { t ^= that.t; return *this; }
 
-    auto operator| ( strict_value const& that ) const -> strict_value requires BitwiseOps { return strict_value(t | that.t); }
-    auto operator& ( strict_value const& that ) const -> strict_value requires BitwiseOps { return strict_value(t & that.t); }
-    auto operator^ ( strict_value const& that ) const -> strict_value requires BitwiseOps { return strict_value(t ^ that.t); }
+    constexpr auto operator| ( strict_value const& that ) const -> strict_value requires BitwiseOps { return strict_value(t | that.t); }
+    constexpr auto operator& ( strict_value const& that ) const -> strict_value requires BitwiseOps { return strict_value(t & that.t); }
+    constexpr auto operator^ ( strict_value const& that ) const -> strict_value requires BitwiseOps { return strict_value(t ^ that.t); }
 
-    auto has       ( strict_value const& that ) const -> bool         requires BitwiseOps { return t & that.t; }
+    constexpr auto has       ( strict_value const& that ) const -> bool         requires BitwiseOps { return t & that.t; }
 
-    auto set       ( strict_value const& that )       -> void         requires BitwiseOps { t |=  that.t; }
-    auto clear     ( strict_value const& that )       -> void         requires BitwiseOps { t &= ~that.t; }
+    constexpr auto set       ( strict_value const& that )       -> void         requires BitwiseOps { t |=  that.t; }
+    constexpr auto clear     ( strict_value const& that )       -> void         requires BitwiseOps { t &= ~that.t; }
 };
 
 template <typename T, typename Tag>

regression-tests/pure2-enum.cpp2

@@ -15,10 +15,10 @@ rgb: @enum type = {
 }
 
 file_attributes: @flag_enum type = {
-    cached;   // 1
-    current;  // 2
-    obsolete; // 4
-    cached_and_current := 3;
+    cached: u8; // 1
+    current;    // 2
+    obsolete;   // 4
+    cached_and_current := cached | current;
 }
 
 main: () = {

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

@@ -67,17 +67,17 @@ public: file_attributes(cpp2::in<cpp2::strict_value<cpp2::u8,file_attributes,tru
 public: auto static constexpr cached = cpp2::strict_value<cpp2::u8,file_attributes,true>(1);
 public: auto static constexpr current = cpp2::strict_value<cpp2::u8,file_attributes,true>(2);
 public: auto static constexpr obsolete = cpp2::strict_value<cpp2::u8,file_attributes,true>(4);
-public: auto static constexpr cached_and_current = cpp2::strict_value<cpp2::u8,file_attributes,true>(3);
+public: auto static constexpr cached_and_current = cpp2::strict_value<cpp2::u8,file_attributes,true>(cached | current);
 public: auto static constexpr none = cpp2::strict_value<cpp2::u8,file_attributes,true>(0);
 public: [[nodiscard]] static auto size() -> auto;
 public: [[nodiscard]] static auto to_string(cpp2::in<cpp2::strict_value<cpp2::u8,file_attributes,true>> value) -> std::string;
 public: [[nodiscard]] auto to_string() const& -> std::string;
 public: file_attributes(file_attributes const& that);
 public: explicit file_attributes();
 
-              // 1
-              // 2
-              // 4
+                // 1
+                // 2
+                // 4
 
 #line 22 "pure2-enum.cpp2"
 };

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

@@ -19,20 +19,19 @@ class name_or_number {
 private: std::array<std::byte,cpp2::max(sizeof(std::string), sizeof(cpp2::i32))> storage__ {}; private: cpp2::i8 discriminator__ {-1}; public: [[nodiscard]] auto is_name() const& -> bool;
 public: [[nodiscard]] auto get_name() const& -> auto&&;
 public: [[nodiscard]] auto get_name() & -> auto&&;
-public: auto set_name(auto&& value) & -> void
-CPP2_REQUIRES_ (std::is_same_v<CPP2_TYPEOF(value), std::string>);
+public: auto set_name(cpp2::in<std::string> value) & -> 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(auto&& value) & -> void
-CPP2_REQUIRES_ (std::is_same_v<CPP2_TYPEOF(value), cpp2::i32>);
+public: auto set_num(cpp2::in<cpp2::i32> value) & -> void;
 private: auto destroy() & -> void;
 public: ~name_or_number() noexcept;
 
     public: name_or_number() = default;
     public: name_or_number(name_or_number const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(name_or_number const&) -> void = delete;
 
+
 #line 5 "pure2-union.cpp2"
 };
 
@@ -52,15 +51,13 @@ auto main() -> int;
                                                               cpp2::Default.expects(is_name(), "");return *cpp2::assert_not_null(reinterpret_cast<std::string const*>(&storage__)); }
 [[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(auto&& value) & -> void
-requires (std::is_same_v<CPP2_TYPEOF(value), std::string>){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(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;}
 [[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(auto&& value) & -> void
-requires (std::is_same_v<CPP2_TYPEOF(value), cpp2::i32>){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(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::destroy() & -> void{
     if (discriminator__ == 0) {std::destroy_at(reinterpret_cast<std::string*>(&storage__));}
     if (discriminator__ == 1) {std::destroy_at(reinterpret_cast<cpp2::i32*>(&storage__));}

regression-tests/test-results/version

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

source/build.info

@@ -1 +1 @@
-"8913:1723"
+"8914:0944"

source/common.h

@@ -478,6 +478,20 @@ auto to_upper_and_underbar(std::string_view s)
 }
 
 
+auto is_empty_or_a_decimal_number(std::string_view s)
+    -> bool
+{
+    auto size = std::ssize(s);
+    if (size == 0) { return true; }
+
+    auto i = 0;
+    while (i < size && isspace(s[i]) ) { ++i; }
+    while (i < size && isdigit(s[i]) ) { ++i; }
+    while (i < size && isspace(s[i]) ) { ++i; }
+    return i == size;
+}
+
+
 auto starts_with(
     std::string const& s,
     std::string_view   sv