Fix ReSharper/IntelliSense error

Author: saki7

include/iris/rvariant/rvariant.hpp

@@ -150,11 +150,14 @@ inline constexpr primary_construct_t primary_construct{};
 //     being an assignment operator at all ([class.copy.assign]/1).
 //   - A `= default` assignment operator whose constraints are not satisfied makes them declare an
 //     implicit move assignment, and the implicit assignment operators of a derived class are
-//     computed from it. A deleted declaration that is selected exactly when neither of the other two
-//     is prevents this.
+//     computed from it. An additional declaration that is selected exactly when neither of the
+//     other two is prevents this: a deleted copy assignment, and a move assignment that forwards to
+//     the copy assignment (or a deleted one if the copy assignment is not usable either), because
+//     a move assignment that does not participate must fall back to the copy assignment.
 // Constructors and destructors are not affected.
 struct rvariant_not_copy_assignable { rvariant_not_copy_assignable() = delete; };
 struct rvariant_not_move_assignable { rvariant_not_move_assignable() = delete; };
+struct rvariant_not_move_assignable_fallback { rvariant_not_move_assignable_fallback() = delete; };
 #endif
 
 template<class... Ts>
@@ -359,10 +362,29 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
     }
 
 #if defined(__INTELLISENSE__) || defined(__RESHARPER__)
+    constexpr rvariant& operator=(
+        std::conditional_t<
+            (!detail::rvariant_trivially_move_assignable<Ts...>) &&
+            (!detail::rvariant_move_assignable<Ts...>) &&
+            detail::rvariant_copy_assignable<Ts...>,
+            rvariant,
+            detail::rvariant_not_move_assignable_fallback
+        >&& rhs
+    )
+        noexcept(detail::rvariant_nothrow_copy_assignable<Ts...>)
+        requires
+            (!detail::rvariant_trivially_move_assignable<Ts...>) &&
+            (!detail::rvariant_move_assignable<Ts...>) &&
+            detail::rvariant_copy_assignable<Ts...>
+    {
+        return *this = static_cast<rvariant const&>(rhs);
+    }
+
     constexpr rvariant& operator=(rvariant&&)
         requires
             (!detail::rvariant_trivially_move_assignable<Ts...>) &&
-            (!detail::rvariant_move_assignable<Ts...>)
+            (!detail::rvariant_move_assignable<Ts...>) &&
+            (!detail::rvariant_copy_assignable<Ts...>)
         = delete;
 #endif
 

test/rvariant/iris_rvariant_test.hpp

@@ -76,7 +76,16 @@ struct MC_Thrower : detail::Thrower_base
 {
 public:
     using MC_Thrower::Thrower_base::Thrower_base;
-    using MC_Thrower::Thrower_base::operator=;
+
+    // Not `using Thrower_base::operator=;` because IntelliSense/ReSharper's `std::is_assignable`
+    // does not see assignment operators brought in by a using-declaration
+    template<class Tag>
+        requires (!std::is_same_v<Tag, MC_Thrower>) && std::is_assignable_v<Thrower_base&, Tag const&>
+    MC_Thrower& operator=(Tag const& tag) noexcept(std::is_nothrow_assignable_v<Thrower_base&, Tag const&>)
+    {
+        Thrower_base::operator=(tag);
+        return *this;
+    }
 
     MC_Thrower() noexcept : Thrower_base() {}
     MC_Thrower(MC_Thrower const&) noexcept : Thrower_base() {}
@@ -130,21 +139,19 @@ struct HashForwarded
 }  // unit_test
 
 
-namespace std {
-
 template<class T>
-struct hash<::unit_test::HashForwarded<T>>
+struct std::hash<::unit_test::HashForwarded<T>>  // NOLINT(bugprone-std-namespace-modification)
 {
-    size_t operator()(::unit_test::HashForwarded<T> const& v) const
+    std::size_t operator()(::unit_test::HashForwarded<T> const& v) const
     {
         return std::hash<T>{}(v.value);
     }
 };
 
 template<class charT>
-struct formatter<::unit_test::MC_Thrower, charT>  // NOLINT(cert-dcl58-cpp)
+struct std::formatter<::unit_test::MC_Thrower, charT>  // NOLINT(cert-dcl58-cpp)
 {
-    static constexpr typename std::basic_format_parse_context<charT>::const_iterator
+    static constexpr std::basic_format_parse_context<charT>::const_iterator
     parse(std::basic_format_parse_context<charT>& ctx)
     {
         if (ctx.begin() == ctx.end()) return ctx.begin();
@@ -159,6 +166,4 @@ struct formatter<::unit_test::MC_Thrower, charT>  // NOLINT(cert-dcl58-cpp)
     }
 };
 
-} // std
-
 #endif