Add enum and flag_enum type metafunctions - initial checkin

`enum` and `flag_enum` are implemented entirely using type metafunctions; they are not special hardwired language features, each is just a subset of the universe of general C++ classes. An `enum` is a `value`, and a `flag_enum` additionally has bitwise operations to set/test the flags in the usual way.

To specify each enumerator, just declare it as a member - the `:` is not required if you don't want to specify the underlying type or the enumerator's value. It will default to `public static constexpr`.

> Note: This is using the other recent [checkin that generalizes object aliases](9d86794) to allow `var :== value;` and `var: some_type = value;` to write `static constexpr` objects. Handy for enumerators.

The underlying type defaults to the minimum-sized signed integer that can represent the values, one of `i8`, `i16`, `i32`, or `i64`. To explicitly specify the underlying type, name it on the first member (only). For example: `color: @enum type = { red: u16 = 0; green; blue; }`. Enums larger than 64 bits are not currently supported.

When an enumerator's value is not specified, it defaults to the next consecutive value for `enum` and the next power-of-two value for `flag_enum`.

TODO: `is value` is working for `enum` but not yet for `flag_enum`

Pasting new feature test case `pure2-enum.cpp2`:

```
@@ -0,0 +1,81 @@

skat_game: @enum type = {
    diamonds := 9;
    hearts;  // 10
    spades;  // 11
    clubs;   // 12
    grand    := 20;
    null     := 23;
}

rgb: @enum type = {
    red;     // 0
    green;   // 1
    blue;    // 2
}

file_attributes: @flag_enum type = {
    cached;   // 1
    current;  // 2
    obsolete; // 4
}

main: () = {
    // x : skat_game = 9;               // error, can't construct skat_game from integer

    x := skat_game::clubs;

    // if x == 9 { }                    // error, can't compare skat_game and integer
    // if x == rgb::red { }             // error, can't compare skat_game and rgb color

    std::cout << "with if else: ";
    if x == skat_game::diamonds {       // ok, can compare two skat_games
        std::cout << "diamonds";
    }
    else if skat_game::hearts == x {    // ok, in either order
        std::cout << "hearts";
    }
    else if x is (skat_game::spades) {  // ok, using is
        std::cout << "spades";
    }
    else if skat_game::clubs is (x) {   // ok, using is
        std::cout << "clubs";
    }
    else {
        std::cout << "not a suit";
    }

    std::cout << "\nwith inspect: " << inspect x -> std::string {
        is (skat_game::diamonds) = "diamonds";
        is (skat_game::hearts  ) = "hearts";
        is (skat_game::spades  ) = "spades";
        is (skat_game::clubs   ) = "clubs";
        is _ = "not a suit";
    } << std::endl;

    // x = 9;                           // error, can't assign skat_game from integer
    // x = rgb::red;                    // error, can't assign skat_game from rgb color

    x = skat_game::diamonds;        // ok, can assign one skat_game from another

    f := file_attributes::current | file_attributes::cached;
    f &= file_attributes::cached  | file_attributes::obsolete;
    f |= file_attributes::current;

    f2 := file_attributes::cached;

    std::cout << "f  as int  is (f  as int )$\n";
    std::cout << "f2 as int  is (f2 as int )$\n";
    std::cout << "f  == f2   is (f  == f2  )$\n";

    // The following are still in progress

    // std::cout << "f  is (f2) is (f  is (f2))$\n";
    // std::cout << "f2 is (f ) is (f2 is (f ))$\n";

    // if f is (file_attributes::cached  ) { std::cout << "cached ";   }
    // if f is (file_attributes::current ) { std::cout << "current ";  }
    // if f is (file_attributes::obsolete) { std::cout << "obsolete "; }
    // if f is (file_attributes::none    ) { std::cout << "none ";     }
    // std::cout << "\n";
}
```

Author: hsutter

include/cpp2util.h

@@ -860,15 +860,20 @@ auto is( X const& x ) -> bool {
 //
 inline constexpr auto is( auto const& x, auto const& value ) -> bool
 {
+    //  Value with customized operator_is case
+    if constexpr (requires{ x.op_is(value); }) {
+        return x.op_is(value);
+    }
+
     //  Predicate case
-    if constexpr (requires{ bool{ value(x) }; }) {
+    else if constexpr (requires{ bool{ value(x) }; }) {
         return value(x);
     }
     else if constexpr (std::is_function_v<decltype(value)> || requires{ &value.operator(); }) {
         return false;
     }
 
-    //  Value case
+    //  Value equality case
     else if constexpr (requires{ bool{x == value}; }) {
         return x == value;
     }
@@ -1534,6 +1539,19 @@ template<typename T>
 using alien_memory = T volatile;
 
 
+//-----------------------------------------------------------------------
+//
+//  An implementation of GSL's narrow_cast with a clearly 'unsafe' name
+//
+//-----------------------------------------------------------------------
+//
+template <typename C, typename X>
+constexpr auto unsafe_narrow( X&& x ) noexcept -> decltype(auto)
+{
+    return static_cast<C>(CPP2_FORWARD(x));
+}
+
+
 //-----------------------------------------------------------------------
 //
 //  strict_value: a strong typedef-like helper for value types
@@ -1550,18 +1568,30 @@ using alien_memory = T volatile;
 //
 template <typename T, typename Tag>
 class strict_value {
-    T t;
+    T t = {};
 public:
-    template <typename U> requires std::is_same_v<T,U>
-    explicit constexpr strict_value(U const& u) : t{u} { }
+    explicit constexpr strict_value() { }
 
-    template <typename U> requires std::is_same_v<T,U>
+    template <typename U>
+    explicit constexpr strict_value(U const& u) : t{unsafe_narrow<T>(u)} { }
+
+    template <typename U> requires std::is_convertible_v<T,U>
     explicit constexpr operator U() const { return t; }
 
-    template <typename U> requires std::is_same_v<T,U>
+    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;
+
+    auto operator|=( strict_value const& that ) -> strict_value { t |= that.t; return *this; }
+    auto operator&=( strict_value const& that ) -> strict_value { t &= that.t; return *this; }
+    auto operator^=( strict_value const& that ) -> strict_value { t ^= that.t; return *this; }
+
+    auto operator|( strict_value const& that ) const -> strict_value { return strict_value(t | that.t); }
+    auto operator&( strict_value const& that ) const -> strict_value { return strict_value(t & that.t); }
+    auto operator^( strict_value const& that ) const -> strict_value { return strict_value(t ^ that.t); }
+
+    auto is_default_value() const -> bool { return t == T{}; }
 };
 
 
@@ -1627,19 +1657,6 @@ inline auto fopen( const char* filename, const char* mode ) {
 //  with cpp2::fopen as a starting example.
 
 
-//-----------------------------------------------------------------------
-//
-//  An implementation of GSL's narrow_cast with a clearly 'unsafe' name
-//
-//-----------------------------------------------------------------------
-//
-template <typename C, typename X>
-auto unsafe_narrow( X&& x ) noexcept -> decltype(auto)
-{
-    return static_cast<C>(CPP2_FORWARD(x));
-}
-
-
 //-----------------------------------------------------------------------
 //
 //  Signed/unsigned comparison checks

regression-tests/pure2-enum.cpp2

@@ -0,0 +1,81 @@
+
+skat_game: @enum type = {
+    diamonds := 9;
+    hearts;  // 10
+    spades;  // 11
+    clubs;   // 12
+    grand    := 20;
+    null     := 23;
+}
+
+rgb: @enum type = {
+    red;     // 0
+    green;   // 1
+    blue;    // 2
+}
+
+file_attributes: @flag_enum type = {
+    cached;   // 1
+    current;  // 2
+    obsolete; // 4
+}
+
+main: () = {
+    // x : skat_game = 9;               // error, can't construct skat_game from integer
+
+    x := skat_game::clubs;
+
+    // if x == 9 { }                    // error, can't compare skat_game and integer
+    // if x == rgb::red { }             // error, can't compare skat_game and rgb color
+
+    std::cout << "with if else: ";
+    if x == skat_game::diamonds {       // ok, can compare two skat_games
+        std::cout << "diamonds";
+    }
+    else if skat_game::hearts == x {    // ok, in either order
+        std::cout << "hearts";
+    }
+    else if x is (skat_game::spades) {  // ok, using is
+        std::cout << "spades";
+    }
+    else if skat_game::clubs is (x) {   // ok, using is
+        std::cout << "clubs";
+    }
+    else {
+        std::cout << "not a suit";
+    }
+
+    std::cout << "\nwith inspect: " << inspect x -> std::string {
+        is (skat_game::diamonds) = "diamonds";
+        is (skat_game::hearts  ) = "hearts";
+        is (skat_game::spades  ) = "spades";
+        is (skat_game::clubs   ) = "clubs";
+        is _ = "not a suit";
+    } << std::endl;
+
+    // x = 9;                           // error, can't assign skat_game from integer
+    // x = rgb::red;                    // error, can't assign skat_game from rgb color
+
+    x = skat_game::diamonds;        // ok, can assign one skat_game from another
+
+    f := file_attributes::current | file_attributes::cached;
+    f &= file_attributes::cached  | file_attributes::obsolete;
+    f |= file_attributes::current;
+
+    f2 := file_attributes::cached;
+
+    std::cout << "f  as int  is (f  as int )$\n";
+    std::cout << "f2 as int  is (f2 as int )$\n";
+    std::cout << "f  == f2   is (f  == f2  )$\n";
+
+    // The following are still in progress
+
+    // std::cout << "f  is (f2) is (f  is (f2))$\n";
+    // std::cout << "f2 is (f ) is (f2 is (f ))$\n";
+
+    // if f is (file_attributes::cached  ) { std::cout << "cached ";   }
+    // if f is (file_attributes::current ) { std::cout << "current ";  }
+    // if f is (file_attributes::obsolete) { std::cout << "obsolete "; }
+    // if f is (file_attributes::none    ) { std::cout << "none ";     }
+    // std::cout << "\n";
+}

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

@@ -0,0 +1,5 @@
+with if else: clubs
+with inspect: clubs
+f  as int  is 3
+f2 as int  is 1
+f  == f2   is 0

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

@@ -1,13 +1,13 @@
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:36: error: expected ‘;’ at end of member declaration
 In file included from pure2-bugfix-for-requires-clause-in-forward-declaration.cpp:7:
-../../../include/cpp2util.h:1770:47: error: static assertion failed: GCC 11 or higher is required to support variables and type-scope functions that have a 'requires' clause. This includes a type-scope 'forward' parameter of non-wildcard type, such as 'func: (this, forward s: std::string)', which relies on being able to add a 'requires' clause - in that case, use 'forward s: _' instead if you need the result to compile with GCC 10.
- 1770 |     #define CPP2_REQUIRES_(...) static_assert(false, "GCC 11 or higher is required to support variables and type-scope functions that have a 'requires' clause. This includes a type-scope 'forward' parameter of non-wildcard type, such as 'func: (this, forward s: std::string)', which relies on being able to add a 'requires' clause - in that case, use 'forward s: _' instead if you need the result to compile with GCC 10.")
+../../../include/cpp2util.h:1787:47: error: static assertion failed: GCC 11 or higher is required to support variables and type-scope functions that have a 'requires' clause. This includes a type-scope 'forward' parameter of non-wildcard type, such as 'func: (this, forward s: std::string)', which relies on being able to add a 'requires' clause - in that case, use 'forward s: _' instead if you need the result to compile with GCC 10.
+ 1787 |     #define CPP2_REQUIRES_(...) static_assert(false, "GCC 11 or higher is required to support variables and type-scope functions that have a 'requires' clause. This includes a type-scope 'forward' parameter of non-wildcard type, such as 'func: (this, forward s: std::string)', which relies on being able to add a 'requires' clause - in that case, use 'forward s: _' instead if you need the result to compile with GCC 10.")
       |                                               ^~~~~
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:4:1: note: in expansion of macro ‘CPP2_REQUIRES_’
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:46: error: expected ‘;’ at end of member declaration
 In file included from pure2-bugfix-for-requires-clause-in-forward-declaration.cpp:7:
-../../../include/cpp2util.h:1770:47: error: static assertion failed: GCC 11 or higher is required to support variables and type-scope functions that have a 'requires' clause. This includes a type-scope 'forward' parameter of non-wildcard type, such as 'func: (this, forward s: std::string)', which relies on being able to add a 'requires' clause - in that case, use 'forward s: _' instead if you need the result to compile with GCC 10.
- 1770 |     #define CPP2_REQUIRES_(...) static_assert(false, "GCC 11 or higher is required to support variables and type-scope functions that have a 'requires' clause. This includes a type-scope 'forward' parameter of non-wildcard type, such as 'func: (this, forward s: std::string)', which relies on being able to add a 'requires' clause - in that case, use 'forward s: _' instead if you need the result to compile with GCC 10.")
+../../../include/cpp2util.h:1787:47: error: static assertion failed: GCC 11 or higher is required to support variables and type-scope functions that have a 'requires' clause. This includes a type-scope 'forward' parameter of non-wildcard type, such as 'func: (this, forward s: std::string)', which relies on being able to add a 'requires' clause - in that case, use 'forward s: _' instead if you need the result to compile with GCC 10.
+ 1787 |     #define CPP2_REQUIRES_(...) static_assert(false, "GCC 11 or higher is required to support variables and type-scope functions that have a 'requires' clause. This includes a type-scope 'forward' parameter of non-wildcard type, such as 'func: (this, forward s: std::string)', which relies on being able to add a 'requires' clause - in that case, use 'forward s: _' instead if you need the result to compile with GCC 10.")
       |                                               ^~~~~
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:4:1: note: in expansion of macro ‘CPP2_REQUIRES_’
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:3: error: no declaration matches ‘element::element(auto:80&&) requires  is_same_v<typename std::remove_cv<typename std::remove_reference<decltype(element::__ct ::n)>::type>::type, std::__cxx11::string>’

regression-tests/test-results/gcc-10/pure2-bugfix-for-requires-clause-in-forward-declaration.cpp.output

@@ -0,0 +1,5 @@
+with if else: clubs
+with inspect: clubs
+f  as int  is 3
+f2 as int  is 1
+f  == f2   is 0

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

@@ -1,5 +1,5 @@
 In file included from pure2-requires-clauses.cpp:7:
-../../../include/cpp2util.h:1770:33: error: expected unqualified-id before ‘static_assert’
- 1770 |     #define CPP2_REQUIRES_(...) static_assert(false, "GCC 11 or higher is required to support variables and type-scope functions that have a 'requires' clause. This includes a type-scope 'forward' parameter of non-wildcard type, such as 'func: (this, forward s: std::string)', which relies on being able to add a 'requires' clause - in that case, use 'forward s: _' instead if you need the result to compile with GCC 10.")
+../../../include/cpp2util.h:1787:33: error: expected unqualified-id before ‘static_assert’
+ 1787 |     #define CPP2_REQUIRES_(...) static_assert(false, "GCC 11 or higher is required to support variables and type-scope functions that have a 'requires' clause. This includes a type-scope 'forward' parameter of non-wildcard type, such as 'func: (this, forward s: std::string)', which relies on being able to add a 'requires' clause - in that case, use 'forward s: _' instead if you need the result to compile with GCC 10.")
       |                                 ^~~~~~~~~~~~~
 pure2-requires-clauses.cpp2:19:1: note: in expansion of macro ‘CPP2_REQUIRES_’

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

@@ -0,0 +1,5 @@
+with if else: clubs
+with inspect: clubs
+f  as int  is 3
+f2 as int  is 1
+f  == f2   is 0