Add mandatory explicit discard, closes hsutter#305

Support `_ =` as a discard operation
	- for example,  `_ = vec.emplace_back(a,b,c);`
	- emitted as `(void)`, not `std::ignore =` because the latter doesn't work with `void` returns and we want to support generic code where there might or might not be a return value in a given template instantiation

Make UFCS calls unconditionally add [[nodiscard]] always
	- note: only added on compilers that support C++23's P2173

Take back `_ :=` as an anonymous deduced variable syntax - the name can be anonymous or the type can be anonymous, but not both
	- yes, it would be easy to support making both anonymous (it did work before this commit, which had to explicitly add a check to disable it)
	- rationale: if that were allowed to keep the returned object alive, that syntax would be dangerously close to '_ = f();' to discard the returned object, which is exactly opposite in a fundamentally important way (lifetime!) and such importantly opposite meanings deserve more than a one-character typo distance
	- explicit discarding gets the nice syntax because it's likely more common
	- but this shouldn't be any hardship because cases that use a type are still just as easy, e.g., `lock_guard`; before this commit `_ := lock_guard(mut);` worked, and after this commit that's disallowed but it's just as easy to write `_: lock_guard = mut;`
	- to make this natural also for `finally`, I just got rid of the `finally` and `finally_success` helper functions, and gave those names to the types... it's a simpler design and I think an improvement in its own right, and `_: finally = code;` is slightly simpler to write (e.g., saves `(` `)` `;`, for example see `pure2-types-order-independence-and-nesting.cpp2`)

Remove return type from `contract_group::set_handler`
	- not needed, since we already have `get_handler` if the current value is of interest

Add reflection `default_to_*` functions for `make_*` functions that ignore the returned bool
	- arguably a clearer API, makes calling code intent more readable

Author: hsutter

include/cpp2util.h

@@ -325,8 +325,8 @@ class contract_group {
     using handler = void (*)(CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM);
 
     constexpr contract_group  (handler h = {})  : reporter(h) { }
-    constexpr auto set_handler(handler h) -> handler;
-    constexpr auto get_handler() const    -> handler { return reporter; }
+    constexpr auto set_handler(handler h);
+    constexpr auto get_handler() const -> handler { return reporter; }
     constexpr auto expects    (bool b, CPP2_MESSAGE_PARAM msg = "" CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT)
                                           -> void { if (!b) reporter(msg CPP2_SOURCE_LOCATION_ARG); }
 private:
@@ -374,11 +374,9 @@ auto inline Testing = contract_group(
     }
 );
 
-constexpr auto contract_group::set_handler(handler h) -> handler {
+constexpr auto contract_group::set_handler(handler h) {
     Default.expects(h);
-    auto old = reporter;
     reporter = h;
-    return old;
 }
 
 
@@ -685,16 +683,33 @@ class out {
 #ifdef _MSC_VER
     #define CPP2_FORCE_INLINE        __forceinline
     #define CPP2_FORCE_INLINE_LAMBDA [[msvc::forceinline]]
+    #define CPP2_LAMBDA_NO_DISCARD
 #else
     #define CPP2_FORCE_INLINE        __attribute__((always_inline))
     #define CPP2_FORCE_INLINE_LAMBDA __attribute__((always_inline))
+
+    #if defined(__clang_major__)
+        #if (__clang_major__ > 13 || (__clang_major__ == 13 && __clang_minor__ >= 2))
+            #define CPP2_LAMBDA_NO_DISCARD   [[nodiscard]]
+        #else
+            #define CPP2_LAMBDA_NO_DISCARD
+        #endif
+    #elif defined(__GNUC__)
+        #if __GNUC__ >= 9
+            #define CPP2_LAMBDA_NO_DISCARD   [[nodiscard]]
+        #else
+            #define CPP2_LAMBDA_NO_DISCARD
+        #endif
+    #else
+        #define CPP2_LAMBDA_NO_DISCARD
+    #endif
 #endif
 
 
 //  Note: [&] is because a nested UFCS might be viewed as trying to capture 'this'
 
 #define CPP2_UFCS(FUNCNAME,PARAM1,...) \
-[&](auto&& obj, auto&& ...params) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
+[&] CPP2_LAMBDA_NO_DISCARD (auto&& obj, auto&& ...params) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
     if constexpr (requires{ CPP2_FORWARD(obj).FUNCNAME(CPP2_FORWARD(params)...); }) { \
         return CPP2_FORWARD(obj).FUNCNAME(CPP2_FORWARD(params)...); \
     } else { \
@@ -703,7 +718,7 @@ class out {
 }(PARAM1, __VA_ARGS__)
 
 #define CPP2_UFCS_0(FUNCNAME,PARAM1) \
-[&](auto&& obj) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
+[&] CPP2_LAMBDA_NO_DISCARD (auto&& obj) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
     if constexpr (requires{ CPP2_FORWARD(obj).FUNCNAME(); }) { \
         return CPP2_FORWARD(obj).FUNCNAME(); \
     } else { \
@@ -714,7 +729,7 @@ class out {
 #define CPP2_UFCS_REMPARENS(...) __VA_ARGS__
 
 #define CPP2_UFCS_TEMPLATE(FUNCNAME,TEMPARGS,PARAM1,...) \
-[&](auto&& obj, auto&& ...params) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
+[&] CPP2_LAMBDA_NO_DISCARD (auto&& obj, auto&& ...params) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
     if constexpr (requires{ CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (CPP2_FORWARD(params)...); }) { \
         return CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (CPP2_FORWARD(params)...); \
     } else { \
@@ -723,7 +738,7 @@ class out {
 }(PARAM1, __VA_ARGS__)
 
 #define CPP2_UFCS_TEMPLATE_0(FUNCNAME,TEMPARGS,PARAM1) \
-[&](auto&& obj) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
+[&] CPP2_LAMBDA_NO_DISCARD (auto&& obj) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
     if constexpr (requires{ CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (); }) { \
         return CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (); \
     } else { \
@@ -735,7 +750,7 @@ class out {
 //  But for non-local lambdas [&] is not allowed
 
 #define CPP2_UFCS_NONLOCAL(FUNCNAME,PARAM1,...) \
-[](auto&& obj, auto&& ...params) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
+[] CPP2_LAMBDA_NO_DISCARD (auto&& obj, auto&& ...params) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
     if constexpr (requires{ CPP2_FORWARD(obj).FUNCNAME(CPP2_FORWARD(params)...); }) { \
         return CPP2_FORWARD(obj).FUNCNAME(CPP2_FORWARD(params)...); \
     } else { \
@@ -744,7 +759,7 @@ class out {
 }(PARAM1, __VA_ARGS__)
 
 #define CPP2_UFCS_0_NONLOCAL(FUNCNAME,PARAM1) \
-[](auto&& obj) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
+[] CPP2_LAMBDA_NO_DISCARD (auto&& obj) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
     if constexpr (requires{ CPP2_FORWARD(obj).FUNCNAME(); }) { \
         return CPP2_FORWARD(obj).FUNCNAME(); \
     } else { \
@@ -753,7 +768,7 @@ class out {
 }(PARAM1)
 
 #define CPP2_UFCS_TEMPLATE_NONLOCAL(FUNCNAME,TEMPARGS,PARAM1,...) \
-[](auto&& obj, auto&& ...params) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
+[] CPP2_LAMBDA_NO_DISCARD (auto&& obj, auto&& ...params) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
     if constexpr (requires{ CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (CPP2_FORWARD(params)...); }) { \
         return CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (CPP2_FORWARD(params)...); \
     } else { \
@@ -762,7 +777,7 @@ class out {
 }(PARAM1, __VA_ARGS__)
 
 #define CPP2_UFCS_TEMPLATE_0_NONLOCAL(FUNCNAME,TEMPARGS,PARAM1) \
-[](auto&& obj) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
+[] CPP2_LAMBDA_NO_DISCARD (auto&& obj) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
     if constexpr (requires{ CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (); }) { \
         return CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (); \
     } else { \
@@ -1347,70 +1362,60 @@ constexpr auto as( X const& x ) -> decltype(auto)
 //
 
 template <class F>
-class final_action_success
+class finally_success
 {
 public:
-    explicit final_action_success(const F& ff) noexcept : f{ff} { }
-    explicit final_action_success(F&& ff) noexcept : f{std::move(ff)} { }
+    explicit finally_success(const F& ff) noexcept : f{ff} { }
+    explicit finally_success(F&& ff) noexcept : f{std::move(ff)} { }
 
-    ~final_action_success() noexcept
+    ~finally_success() noexcept
     {
         if (invoke && ecount == std::uncaught_exceptions()) {
             f();
         }
     }
 
-    final_action_success(final_action_success&& that) noexcept
+    finally_success(finally_success&& that) noexcept
         : f(std::move(that.f)), invoke(std::exchange(that.invoke, false))
     { }
 
-    final_action_success(final_action_success const&) = delete;
-    void operator=      (final_action_success const&) = delete;
-    void operator=      (final_action_success&&)      = delete;
+    finally_success(finally_success const&) = delete;
+    void operator= (finally_success const&) = delete;
+    void operator= (finally_success&&)      = delete;
 
 private:
     F f;
     int  ecount = std::uncaught_exceptions();
     bool invoke = true;
 };
 
-[[nodiscard]] auto finally_success(auto&& f) noexcept
-{
-    return final_action_success<CPP2_TYPEOF(f)>{CPP2_FORWARD(f)};
-}
-
 
 //
 //  Same, but clean up also on exceptional paths
 //
 
 template <class F>
-class final_action
+class finally
 {
 public:
-    explicit final_action(const F& ff) noexcept : f{ff} { }
-    explicit final_action(F&& ff) noexcept : f{std::move(ff)} { }
+    explicit finally(const F& ff) noexcept : f{ff} { }
+    explicit finally(F&& ff) noexcept : f{std::move(ff)} { }
 
-    ~final_action() noexcept { f(); }
+    ~finally() noexcept { f(); }
 
-    final_action(final_action&& that) noexcept
+    finally(finally&& that) noexcept
         : f(std::move(that.f)), invoke(std::exchange(that.invoke, false))
     { }
 
-    final_action  (final_action const&) = delete;
-    void operator=(final_action const&) = delete;
-    void operator=(final_action&&)      = delete;
+    finally       (finally const&) = delete;
+    void operator=(finally const&) = delete;
+    void operator=(finally&&)      = delete;
 
 private:
     F f;
     bool invoke = true;
 };
 
-[[nodiscard]] auto finally(auto&& f) noexcept
-{
-    return final_action<CPP2_TYPEOF(f)>{CPP2_FORWARD(f)};
-}
-
 
 //-----------------------------------------------------------------------
 //

regression-tests/mixed-captures-in-expressions-and-postconditions.cpp2

@@ -20,5 +20,5 @@ insert_at: (where: int, val: int)
     [[pre:  0 <= where && where <= vec.ssize()]]
     [[post: vec.ssize() == vec.ssize()$ + 1]]
 = {
-    vec.insert( vec.begin()+where, val );
+    _ = vec.insert( vec.begin()+where, val );
 }

regression-tests/pure2-inspect-expression-in-generic-function-multiple-types.cpp2

@@ -8,7 +8,7 @@ main: () -> int = {
     test_generic(a,    "any");
     test_generic(o,    "optional<int>");
 
-    v.emplace<0>(1);
+    _ = v.emplace<0>(1);
     a = 2;
     o = 3;
     test_generic(42,   "int");

regression-tests/pure2-stdio-with-raii.cpp2

@@ -4,5 +4,5 @@
 main: () -> int = {
     s: std::string = "Freddy";
     myfile := cpp2::fopen("xyzzy", "w");
-    myfile.fprintf( "Hello %s with UFCS!", s.c_str() );
+    _ = myfile.fprintf( "Hello %s with UFCS!", s.c_str() );
 }

regression-tests/pure2-stdio.cpp2

@@ -4,7 +4,7 @@
 main: () -> int = {
     s: std::string = "Fred";
     myfile := fopen("xyzzy", "w");
-    myfile.fprintf( "Hello %s with UFCS!", s.c_str() );
-    myfile.fclose();
+    _ = myfile.fprintf( "Hello %s with UFCS!", s.c_str() );
+    _ = myfile.fclose();
 }
 

regression-tests/pure2-type-safety-1.cpp2

@@ -12,7 +12,7 @@ main: () -> int =
 
     std::cout << "\n";
 
-    v.emplace<1>(1);
+    _ = v.emplace<1>(1);
     a = 2;
     o = 3;
     test_generic(42,   "int");

regression-tests/pure2-type-safety-2-with-inspect-expression.cpp2

@@ -8,7 +8,7 @@ main: () -> int = {
     test_generic(a,    "any");
     test_generic(o,    "optional<int>");
 
-    v.emplace<2>(1);
+    _ = v.emplace<2>(1);
     a = 2;
     o = 3;
     test_generic(42,   "int");

regression-tests/pure2-types-order-independence-and-nesting.cpp2

@@ -34,7 +34,7 @@ X: type = {
     //  X::exx member function description here
     exx: (this, count: int) = {
         //  Exercise '_' anonymous objects too while we're at it
-        _ := finally( :()= std::cout << "leaving call to 'why((count)$)'\n"; );
+        _: finally = :()= std::cout << "leaving call to 'why((count)$)'\n";
         if count < 5 {
             py*.why( count+1 );     // use Y object from X
         }

regression-tests/pure2-ufcs-member-access-and-chaining.cpp2

@@ -1,24 +1,28 @@
 main: () -> int = {
     i := 42;
-    i.ufcs();
+    _ = i.ufcs();
 
     j := fun();
-    j.i.ufcs();
+    _ = j.i.ufcs();
 
-    fun().i.ufcs();
+    _ = fun().i.ufcs();
 
     k := fun().i;
-    k.ufcs();
+    _ = k.ufcs();
 
-    get_i(j).ufcs();
+    _ = get_i(j).ufcs();
 
-    get_i(fun()).ufcs();
+    _ = get_i(fun()).ufcs();
 
     res := (42).ufcs();
 
-    (j.i).ufcs();
+    _ = (j.i).ufcs();
+
+    _ = 42.no_return();
 }
 
+no_return: (x: int) = { }
+
 ufcs: (i:int) -> int = {
     return i+2;
 }

regression-tests/test-results/mixed-captures-in-expressions-and-postconditions.cpp

@@ -48,6 +48,6 @@ auto insert_at(cpp2::in<int> where, cpp2::in<int> val) -> void
     cpp2::Default.expects(cpp2::cmp_less_eq(0,where) && cpp2::cmp_less_eq(where,CPP2_UFCS_0(ssize, vec)), "");
     auto post_21_5 = cpp2::finally_success([_0 = CPP2_UFCS_0(ssize, vec)]{cpp2::Default.expects(CPP2_UFCS_0(ssize, vec)==_0 + 1, "");} );
 #line 23 "mixed-captures-in-expressions-and-postconditions.cpp2"
-    CPP2_UFCS(insert, vec, CPP2_UFCS_0(begin, vec) + where, val);
+    (void) CPP2_UFCS(insert, vec, CPP2_UFCS_0(begin, vec) + where, val);
 }