Merge branch 'feature/any' into feature/type_erasure

# Conflicts:
#	include/boost/openmethod/interop/virtual_any.hpp

Author: jll63

include/boost/openmethod/interop/virtual_any.hpp

@@ -19,16 +19,48 @@ class virtual_any;
 template<class Any, class Registry = BOOST_OPENMETHOD_DEFAULT_REGISTRY>
 class virtual_any_ref;
 
-namespace detail {
+BOOST_OPENMETHOD_OPEN_NAMESPACE_DETAIL_UNLESS_MRDOCS
 
+//! Test if argument is a wide `any` (exposition only)
+//!
+//! Evaluates to `true` if `T` is a specialization of @ref virtual_any or of
+//! @ref virtual_any_ref, and `false` otherwise.
+//!
+//! This constrains the constructor and the assignment operator of
+//! @ref virtual_any that take a value, excluding both wide types - every
+//! specialization of them, not only the ones matching this `virtual_any`. A
+//! @ref virtual_any argument then selects the copy or move operation instead
+//! of being stored inside the `any`, and a @ref virtual_any_ref argument is
+//! rejected outright rather than stored: a handle is not a registered class,
+//! so its @ref registry::static_vptr would be null.
+//!
+//! @tparam T A type.
 template<typename T>
-struct is_virtual_any_aux : std::false_type {};
+constexpr bool IsVirtualAny = false;
 
+//! Recognize a virtual_any (exposition only)
+//!
+//! The specialization of @ref IsVirtualAny that matches a
+//! `virtual_any`, and evaluates to `true`.
+//!
+//! @tparam Any An `any` type.
+//! @tparam Registry A @ref registry.
 template<class Any, class Registry>
-struct is_virtual_any_aux<virtual_any<Any, Registry>> : std::true_type {};
+constexpr bool IsVirtualAny<virtual_any<Any, Registry>> = true;
 
+//! Recognize a virtual_any_ref (exposition only)
+//!
+//! The specialization of @ref IsVirtualAny that matches a
+//! `virtual_any_ref`, and evaluates to `true`.
+//!
+//! @tparam Any An `any` type, possibly const-qualified.
+//! @tparam Registry A @ref registry.
 template<class Any, class Registry>
-struct is_virtual_any_aux<virtual_any_ref<Any, Registry>> : std::true_type {};
+constexpr bool IsVirtualAny<virtual_any_ref<Any, Registry>> = true;
+
+BOOST_OPENMETHOD_CLOSE_NAMESPACE_DETAIL_UNLESS_MRDOCS
+
+namespace detail {
 
 // Common implementation for the use_*_any_types registrars: register Root
 // as a class, and each element of the Classes list as a class derived
@@ -139,7 +171,8 @@ class virtual_any {
     template<
         typename T,
         typename = std::enable_if_t<
-            !detail::is_virtual_any_aux<std::decay_t<T>>::value &&
+            !BOOST_OPENMETHOD_DETAIL_UNLESS_MRDOCS
+                IsVirtualAny<std::decay_t<T>> &&
             !std::is_same_v<std::decay_t<T>, Any> &&
             std::is_constructible_v<Any, T&&>>>
     virtual_any(T&& value)
@@ -214,7 +247,8 @@ class virtual_any {
     template<
         typename T,
         typename = std::enable_if_t<
-            !detail::is_virtual_any_aux<std::decay_t<T>>::value &&
+            !BOOST_OPENMETHOD_DETAIL_UNLESS_MRDOCS
+                IsVirtualAny<std::decay_t<T>> &&
             !std::is_same_v<std::decay_t<T>, Any> &&
             std::is_constructible_v<Any, T&&>>>
     auto operator=(T&& value) -> virtual_any& {

test/CMakeLists.txt

@@ -168,6 +168,24 @@ openmethod_compile_fail_test(
 openmethod_compile_fail_test(
     compile_fail_virtual_any_ref_by_ref
     "virtual_any_ref is a cheap handle, pass it by value")
+# Copy-initializing a virtual_any from a virtual_any_ref is ill-formed: the
+# value constructor is constrained away, so storing the handle inside the
+# `any` would take two user-defined conversions. The diagnostic is the
+# compiler's own, and the wording varies: "conversion from ... to non-scalar
+# type ... requested" on gcc, "no viable conversion from" on clang, C2440
+# "cannot convert from" on MSVC.
+#
+# MSVC needs /permissive- here. In its default mode - which `/std:c++17` does
+# not turn off - it accepts the extra user-defined conversion and compiles the
+# file, so the test would not fail. Note this means the constraint does not
+# actually protect MSVC users building in the default mode; only the
+# direct-initialization form, which no compiler rejects, is worse.
+openmethod_compile_fail_test(
+    compile_fail_virtual_any_from_ref "conversion from|cannot convert from")
+if (MSVC)
+    target_compile_options(
+        boost_openmethod-compile_fail_virtual_any_from_ref PRIVATE /permissive-)
+endif()
 # "use of a deleted function" on gcc, "call to deleted function" on clang,
 # "attempting to reference a deleted function" on MSVC.
 openmethod_compile_fail_test(

test/Jamfile

@@ -43,11 +43,18 @@ for local src in [ glob test_*.cpp ]
 run mix_release_debug/main.cpp mix_release_debug/lib.cpp unit_test_framework ;
 
 
-for local src in [ glob compile_fail_*.cpp ]
+for local src in [ glob compile_fail_*.cpp : compile_fail_virtual_any_from_ref.cpp ]
 {
   compile-fail $(src) ;
 }
 
+# Excluded from the glob above because it needs /permissive- on msvc: copy-
+# initializing a virtual_any from a virtual_any_ref takes two user-defined
+# conversions, which msvc accepts in its default mode, so the compile would
+# succeed and the test fail. See test/CMakeLists.txt for the details.
+compile-fail compile_fail_virtual_any_from_ref.cpp
+  : <toolset>msvc:<cxxflags>/permissive- ;
+
 build-project dynamic_loading ;
 build-project implicit_shared_libraries ;
 

test/compile_fail_virtual_any_from_ref.cpp

@@ -0,0 +1,34 @@
+// Copyright (c) 2018-2026 Jean-Louis Leroy
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <any>
+#include <string>
+
+#include <boost/openmethod.hpp>
+#include <boost/openmethod/interop/std_any.hpp>
+
+using namespace boost::openmethod;
+
+struct Dog {
+    std::string name;
+};
+
+BOOST_OPENMETHOD_REGISTER(use_std_any_types<Dog>);
+
+int main() {
+    std::any dog(Dog{"Snoopy"});
+    virtual_any_ref<std::any> ref(dog);
+
+    // A virtual_any cannot be copy-initialized from a virtual_any_ref. The
+    // value constructor is constrained to reject every wide type, so storing
+    // the handle inside the `any` would take two user-defined conversions -
+    // virtual_any_ref to std::any, then std::any to virtual_any - which is
+    // one more than an implicit conversion sequence allows. Were the handle
+    // stored, its static_vptr would be null: a handle is not a registered
+    // class.
+    virtual_std_any copy = ref;
+
+    return 0;
+}