[libcxx/variant] Correctly propagate return type of the visitor.

[mpark]

Summary

The tests for it were missing so I've added them.

[EricWF]

LGTM, this fixes some build failures at Google.

Thanks for the fix!

libcxx/include/variant

#undef _LIBCPP_VARIANT_CASE
   }
 
   template <size_t... _Is, class _Vis, class... _Vs>
   inline _LIBCPP_INLINE_VISIBILITY
   static constexpr decltype(auto)
   __visit_alt_impl(index_sequence<_Is...>, _Vis&& __vis, _Vs&&... __vs) {
     using __multi = __multi<__uncvref_t<_Vs>::__size()...>;
     constexpr auto __dispatch = [](auto... __is) {
-      return +[](_Vis&& __vis_, _Vs&&... __vs_) {
+      return +[](_Vis&& __vis_, _Vs&&... __vs_) -> decltype(auto) {
         return __invoke_constexpr(
             _VSTD::forward<_Vis>(__vis_),
             __access::__base::__get_alt<decltype(__is)::value>(
                 _VSTD::forward<_Vs>(__vs_))...);
       };
     };
 #define _LIBCPP_VARIANT_CASE(_Ip)                                              \
   case _Ip: {                                                                  \

libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp

 
 inline constexpr CallType operator|(CallType LHS, CallType RHS) {
   return static_cast<CallType>(static_cast<unsigned>(LHS) |
                                static_cast<unsigned>(RHS));
 }
 
 struct ForwardingCallObject {
 
-  template <class... Args> bool operator()(Args &&...) & {
+  template <class... Args>
+  ForwardingCallObject& operator()(Args&&...) & {
     set_call<Args &&...>(CT_NonConst | CT_LValue);
-    return true;
+    return *this;
   }
 
-  template <class... Args> bool operator()(Args &&...) const & {
+  template <class... Args>
+  const ForwardingCallObject& operator()(Args&&...) const & {
     set_call<Args &&...>(CT_Const | CT_LValue);
-    return true;
+    return *this;
   }
 
-  // Don't allow the call operator to be invoked as an rvalue.
-  template <class... Args> bool operator()(Args &&...) && {
+  template <class... Args>
+  ForwardingCallObject&& operator()(Args&&...) && {
     set_call<Args &&...>(CT_NonConst | CT_RValue);
-    return true;
+    return std::move(*this);
   }
 
-  template <class... Args> bool operator()(Args &&...) const && {
+  template <class... Args>
+  const ForwardingCallObject&& operator()(Args&&...) const && {
     set_call<Args &&...>(CT_Const | CT_RValue);
-    return true;
+    return std::move(*this);
   }
 
   template <class... Args> static void set_call(CallType type) {
     assert(last_call_type == CT_None);
     assert(last_call_args == nullptr);
     last_call_type = type;
     last_call_args = std::addressof(makeArgumentID<Args...>());
   }
#endif
     V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
     std::visit(obj, v1, v2, v3, v4);
     assert((Fn::check_call<long &, std::string &, int *&, double &>(Val)));
     std::visit(obj, std::as_const(v1), std::as_const(v2), std::move(v3), std::move(v4));
     assert((Fn::check_call<const long &, const std::string &, int *&&, double &&>(Val)));
   }
 }
 
+void test_return_type() {
+  using Fn = ForwardingCallObject;
+  Fn obj{};
+  const Fn &cobj = obj;
+  { // test call operator forwarding - no variant
+    static_assert(std::is_same_v<decltype(std::visit(obj)), Fn&>);
+    static_assert(std::is_same_v<decltype(std::visit(cobj)), const Fn&>);
+    static_assert(std::is_same_v<decltype(std::visit(std::move(obj))), Fn&&>);
+    static_assert(std::is_same_v<decltype(std::visit(std::move(cobj))), const Fn&&>);
+  }
+  { // test call operator forwarding - single variant, single arg
+    using V = std::variant<int>;
+    V v(42);
+    static_assert(std::is_same_v<decltype(std::visit(obj, v)), Fn&>);
+    static_assert(std::is_same_v<decltype(std::visit(cobj, v)), const Fn&>);
+    static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v)), Fn&&>);
+    static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v)), const Fn&&>);
+  }
+  { // test call operator forwarding - single variant, multi arg
+    using V = std::variant<int, long, double>;
+    V v(42l);
+    static_assert(std::is_same_v<decltype(std::visit(obj, v)), Fn&>);
+    static_assert(std::is_same_v<decltype(std::visit(cobj, v)), const Fn&>);
+    static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v)), Fn&&>);
+    static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v)), const Fn&&>);
+  }
+  { // test call operator forwarding - multi variant, multi arg
+    using V = std::variant<int, long, double>;
+    using V2 = std::variant<int *, std::string>;
+    V v(42l);
+    V2 v2("hello");
+    static_assert(std::is_same_v<decltype(std::visit(obj, v, v2)), Fn&>);
+    static_assert(std::is_same_v<decltype(std::visit(cobj, v, v2)), const Fn&>);
+    static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v, v2)), Fn&&>);
+    static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v, v2)), const Fn&&>);
+  }
+  {
+    using V = std::variant<int, long, double, std::string>;
+    V v1(42l), v2("hello"), v3(101), v4(1.1);
+    static_assert(std::is_same_v<decltype(std::visit(obj, v1, v2, v3, v4)), Fn&>);
+    static_assert(std::is_same_v<decltype(std::visit(cobj, v1, v2, v3, v4)), const Fn&>);
+    static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v1, v2, v3, v4)), Fn&&>);
+    static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v1, v2, v3, v4)), const Fn&&>);
+  }
+  {
+    using V = std::variant<int, long, double, int*, std::string>;
+    V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
+    static_assert(std::is_same_v<decltype(std::visit(obj, v1, v2, v3, v4)), Fn&>);
+    static_assert(std::is_same_v<decltype(std::visit(cobj, v1, v2, v3, v4)), const Fn&>);
+    static_assert(std::is_same_v<decltype(std::visit(std::move(obj), v1, v2, v3, v4)), Fn&&>);
+    static_assert(std::is_same_v<decltype(std::visit(std::move(cobj), v1, v2, v3, v4)), const Fn&&>);
+  }
+}
+
 struct ReturnFirst {
   template <class... Args> constexpr int operator()(int f, Args &&...) const {
     return f;
   }
 };
 
 struct ReturnArity {
   template <class... Args> constexpr int operator()(Args &&...) const {
void test_caller_accepts_nonconst() {
   };
   std::variant<A> v;
   std::visit(Visitor{}, v);
 }
 
 int main(int, char**) {
   test_call_operator_forwarding();
   test_argument_forwarding();
+  test_return_type();
   test_constexpr();
   test_exceptions();
   test_caller_accepts_nonconst();
 
   return 0;
 }