Finish unifying the built-in "as" functions to remove the non-const overload

See discussion in #1057

Closes #961

Closes #1057 - with thanks to @soukatch for pointing out the offending code region to narrow the bug diagnosis, appreciated!

Closes #1061

Author: hsutter

include/cpp2util.h

@@ -1467,8 +1467,27 @@ inline constexpr auto as() -> auto
     }
 }
 
-template< typename C, typename X >
-auto as(X const& x CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT) -> decltype(auto) {
+template< typename C, auto x >
+    requires (std::is_same_v<C, std::string> && std::is_integral_v<CPP2_TYPEOF(x)>)
+inline constexpr auto as() -> auto
+{
+    return cpp2::to_string(CPP2_FORWARD(x));
+}
+
+template< typename C >
+auto as(auto&& x CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT) -> decltype(auto)
+    //  This "requires" list may need to be tweaked further. The idea is to have
+    //  this function used for all the cases it's supposed to cover, but not
+    //  hide user-supplied extensions (such as the ones later in this file for
+    //  std:: polymorphic types like any/optional/variant)
+    requires (
+                (std::is_scalar_v<CPP2_TYPEOF(x)> && !std::is_enum_v<CPP2_TYPEOF(x)>)
+            ||  std::is_floating_point_v<CPP2_TYPEOF(x)>
+            ||  std::is_base_of_v<C, CPP2_TYPEOF(x)>
+            ||  std::is_base_of_v<CPP2_TYPEOF(x), C>
+            ||  requires { C{CPP2_FORWARD(x)}; }
+            )
+{
     if constexpr (
         std::is_floating_point_v<C> &&
         std::is_floating_point_v<CPP2_TYPEOF(x)> &&
@@ -1487,65 +1506,57 @@ auto as(X const& x CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT) -> decltype(auto) {
         sizeof(CPP2_TYPEOF(x)) <= sizeof(C)
     )
     {
-        const C c = static_cast<C>(x);
+        const C c = static_cast<C>(CPP2_FORWARD(x));
         type_safety.enforce(   // precondition check: must be round-trippable => not lossy
             static_cast<CPP2_TYPEOF(x)>(c) == x && (c < C{}) == (x < CPP2_TYPEOF(x){}),
             "dynamic lossy narrowing conversion attempt detected" CPP2_SOURCE_LOCATION_ARG
         );
         return CPP2_COPY(c);
     }
-    else if constexpr (std::is_same_v<C, std::string> && std::is_integral_v<X>) {
-        return cpp2::to_string(x);
+    else if constexpr (std::is_same_v<C, std::string> && std::is_integral_v<CPP2_TYPEOF(x)>) {
+        return cpp2::to_string(CPP2_FORWARD(x));
     }
-    else if constexpr (std::is_same_v<C, X>) {
-        return x;
+    else if constexpr (std::is_same_v<C, CPP2_TYPEOF(x)>) {
+        return CPP2_FORWARD(x);
     }
-    else if constexpr (std::is_base_of_v<C, X>) {
-        return static_cast<C const&>(x);
+    else if constexpr (std::is_base_of_v<C, CPP2_TYPEOF(x)>) {
+        if constexpr (std::is_const_v<std::remove_reference_t<decltype(x)>>) {
+            return static_cast<C const&>(CPP2_FORWARD(x));
+        } else {
+            return static_cast<C&>(CPP2_FORWARD(x));
+        }
     }
-    else if constexpr (std::is_base_of_v<X, C>) {
-        return Dynamic_cast<C const&>(x);
+    else if constexpr (std::is_base_of_v<CPP2_TYPEOF(x), C>) {
+        if constexpr (std::is_const_v<std::remove_reference_t<decltype(x)>>) {
+            return Dynamic_cast<C const&>(CPP2_FORWARD(x));
+        } else {
+            return Dynamic_cast<C&>(CPP2_FORWARD(x));
+        }
     }
     else if constexpr (
         std::is_pointer_v<C>
-        && std::is_pointer_v<X>
-        && requires { requires std::is_base_of_v<deref_t<X>, deref_t<C>>; }
+        && std::is_pointer_v<CPP2_TYPEOF(x)>
+        && requires { requires std::is_base_of_v<deref_t<CPP2_TYPEOF(x)>, deref_t<C>>; }
     )
     {
-        return Dynamic_cast<C>(x);
+        return Dynamic_cast<C>(CPP2_FORWARD(x));
     }
-    else if constexpr (requires { C{x}; }) {
+    else if constexpr (requires { C{CPP2_FORWARD(x)}; }) {
         //  Experiment: Recognize the nested `::value_type` pattern for some dynamic library types
         //  like std::optional, and try to prevent accidental narrowing conversions even when
         //  those types themselves don't defend against them
-        if constexpr( requires { requires std::is_convertible_v<X, typename C::value_type>; } ) {
-            if constexpr( is_narrowing_v<typename C::value_type, X>) {
+        if constexpr( requires { requires std::is_convertible_v<CPP2_TYPEOF(x), typename C::value_type>; } ) {
+            if constexpr( is_narrowing_v<typename C::value_type, CPP2_TYPEOF(x)>) {
                 return nonesuch;
             }
         }
-        return C{x};
+        return C{CPP2_FORWARD(x)};
     }
     else {
         return nonesuch;
     }
 }
 
-template< typename C, typename X >
-auto as( X& x ) -> decltype(auto) {
-    if constexpr (std::is_same_v<C, X>) {
-        return x;
-    }
-    else if constexpr (std::is_base_of_v<C, X>) {
-        return static_cast<C&>(x);
-    }
-    else if constexpr (std::is_base_of_v<X, C>) {
-        return Dynamic_cast<C&>(x);
-    }
-    else {
-        return as<C>(std::as_const(x));
-    }
-}
-
 
 //-------------------------------------------------------------------------------------------------------------
 //  std::variant is and as

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

@@ -6,12 +6,12 @@ pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:46: error: expect
 In file included from pure2-bugfix-for-requires-clause-in-forward-declaration.cpp:7:
 ../../../include/cpp2util.h:10005: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.
 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:91&&) requires  is_same_v<std::__cxx11::string, typename std::remove_cv<typename std::remove_reference<decltype(element::__ct ::n)>::type>::type>’
+pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:3: error: no declaration matches ‘element::element(auto:92&&) requires  is_same_v<std::__cxx11::string, typename std::remove_cv<typename std::remove_reference<decltype(element::__ct ::n)>::type>::type>’
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:5:11: note: candidates are: ‘element::element(const element&)’
-pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:20: note:                 ‘template<class auto:89> element::element(auto:89&&)’
+pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:20: note:                 ‘template<class auto:90> element::element(auto:90&&)’
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:1:7: note: ‘class element’ defined here
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:5:78: error: expected unqualified-id before ‘{’ token
-pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:8: error: no declaration matches ‘element& element::operator=(auto:92&&) requires  is_same_v<std::__cxx11::string, typename std::remove_cv<typename std::remove_reference<decltype(element::operator=::n)>::type>::type>’
+pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:8: error: no declaration matches ‘element& element::operator=(auto:93&&) requires  is_same_v<std::__cxx11::string, typename std::remove_cv<typename std::remove_reference<decltype(element::operator=::n)>::type>::type>’
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:6:16: note: candidates are: ‘void element::operator=(const element&)’
-pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:16: note:                 ‘template<class auto:90> element& element::operator=(auto:90&&)’
+pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:16: note:                 ‘template<class auto:91> element& element::operator=(auto:91&&)’
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:1:7: note: ‘class element’ defined here

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

@@ -9,8 +9,8 @@ pure2-print.cpp2:68:1: note: in expansion of macro ‘CPP2_REQUIRES_’
 pure2-print.cpp2:97:1: note: in expansion of macro ‘CPP2_REQUIRES_’
 pure2-print.cpp2:9:41: error: ‘constexpr const T outer::object_alias’ is not a static data member of ‘class outer’
 pure2-print.cpp2:9:48: error: template definition of non-template ‘constexpr const T outer::object_alias’
-pure2-print.cpp2:67:14: error: no declaration matches ‘void outer::mytype::variadic(const auto:90& ...) requires (is_convertible_v<typename std::remove_cv<typename std::remove_reference<decltype(outer::mytype::variadic::x)>::type>::type, int> && ...)’
-pure2-print.cpp2:67:29: note: candidate is: ‘template<class ... auto:89> static void outer::mytype::variadic(const auto:89& ...)’
+pure2-print.cpp2:67:14: error: no declaration matches ‘void outer::mytype::variadic(const auto:91& ...) requires (is_convertible_v<typename std::remove_cv<typename std::remove_reference<decltype(outer::mytype::variadic::x)>::type>::type, int> && ...)’
+pure2-print.cpp2:67:29: note: candidate is: ‘template<class ... auto:90> static void outer::mytype::variadic(const auto:90& ...)’
 pure2-print.cpp2:10:19: note: ‘class outer::mytype’ defined here
 pure2-print.cpp2:96:37: error: no declaration matches ‘void outer::print(std::ostream&, const Args& ...) requires  cpp2::impl::cmp_greater_eq(sizeof ... (Args ...), 0)’
 pure2-print.cpp2:96:37: note: no functions named ‘void outer::print(std::ostream&, const Args& ...) requires  cpp2::impl::cmp_greater_eq(sizeof ... (Args ...), 0)’