From 8110e0d155dc3615a16a2126bc2124c89cfc5559 Mon Sep 17 00:00:00 2001
From: Jan Varga <jvarga@mozilla.com>
Date: Tue, 30 Nov 2021 05:05:53 +0000
Subject: [PATCH] Bug 1732642 - Handle complex types in
 MOZ_TO_RESULT_INVOKE_MEMBER_TYPED; r=dom-storage-reviewers,jari

Differential Revision: https://phabricator.services.mozilla.com/D126785
---
 mfbt/ResultExtensions.h                   |  3 +-
 mfbt/tests/gtest/TestResultExtensions.cpp | 87 +++++++++++++++++++++++
 2 files changed, 89 insertions(+), 1 deletion(-)

diff --git a/mfbt/ResultExtensions.h b/mfbt/ResultExtensions.h
index 6783d4d98e29..97f197d800c0 100644
--- a/mfbt/ResultExtensions.h
+++ b/mfbt/ResultExtensions.h
@@ -13,6 +13,7 @@
 #include "mozilla/Assertions.h"
 #include "nscore.h"
 #include "prtypes.h"
+#include "mozilla/dom/quota/RemoveParen.h"
 
 namespace mozilla {
 
@@ -360,7 +361,7 @@ auto ToResultInvokeMember(const SmartPtr<const T>& aObj,
 //     auto existsOrErr =
 //         MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(nsCOMPtr<nsIFile>, file, Clone);
 #define MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(resultType, obj, methodname, ...) \
-  ::mozilla::ToResultInvoke<resultType>(                                    \
+  ::mozilla::ToResultInvoke<MOZ_REMOVE_PAREN(resultType)>(                  \
       ::std::mem_fn(                                                        \
           &::mozilla::detail::DerefedType<decltype(obj)>::methodname),      \
       (obj), ##__VA_ARGS__)
diff --git a/mfbt/tests/gtest/TestResultExtensions.cpp b/mfbt/tests/gtest/TestResultExtensions.cpp
index 844cb63e88c8..711e4f33e40f 100644
--- a/mfbt/tests/gtest/TestResultExtensions.cpp
+++ b/mfbt/tests/gtest/TestResultExtensions.cpp
@@ -38,6 +38,14 @@ class TestClass {
   }
   nsresult NonOverloadedNoInputFailsRef(int& aOut) { return NS_ERROR_FAILURE; }
 
+  nsresult NonOverloadedNoInputComplex(std::pair<int, int>* aOut) {
+    *aOut = std::pair{kTestValue, kTestValue};
+    return NS_OK;
+  }
+  nsresult NonOverloadedNoInputFailsComplex(std::pair<int, int>* aOut) {
+    return NS_ERROR_FAILURE;
+  }
+
   nsresult NonOverloadedWithInput(int aIn, int* aOut) {
     *aOut = aIn;
     return NS_OK;
@@ -233,6 +241,32 @@ TEST(ResultExtensions_ToResultInvokeMember, NoInput_Ref)
   }
 }
 
+TEST(ResultExtensions_ToResultInvokeMember, NoInput_Complex)
+{
+  TestClass foo;
+
+  // success
+  {
+    auto valOrErr =
+        ToResultInvokeMember(foo, &TestClass::NonOverloadedNoInputComplex);
+    static_assert(std::is_same_v<decltype(valOrErr),
+                                 Result<std::pair<int, int>, nsresult>>);
+    ASSERT_TRUE(valOrErr.isOk());
+    ASSERT_EQ((std::pair{TestClass::kTestValue, TestClass::kTestValue}),
+              valOrErr.unwrap());
+  }
+
+  // failure
+  {
+    auto valOrErr =
+        ToResultInvokeMember(foo, &TestClass::NonOverloadedNoInputFailsComplex);
+    static_assert(std::is_same_v<decltype(valOrErr),
+                                 Result<std::pair<int, int>, nsresult>>);
+    ASSERT_TRUE(valOrErr.isErr());
+    ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
+  }
+}
+
 TEST(ResultExtensions_ToResultInvokeMember, WithInput)
 {
   TestClass foo;
@@ -343,6 +377,33 @@ TEST(ResultExtensions_ToResultInvokeMember, NoInput_Ref_Macro)
   }
 }
 
+TEST(ResultExtensions_ToResultInvokeMember, NoInput_Complex_Macro)
+{
+  TestClass foo;
+
+  // success
+  {
+    auto valOrErr =
+        MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedNoInputComplex);
+    static_assert(std::is_same_v<decltype(valOrErr),
+                                 Result<std::pair<int, int>, nsresult>>);
+    ASSERT_TRUE(valOrErr.isOk());
+    ASSERT_EQ((std::pair{TestClass::kTestValue, TestClass::kTestValue}),
+              valOrErr.unwrap());
+  }
+
+  // failure
+  {
+    auto valOrErr =
+        MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedNoInputFailsComplex);
+
+    static_assert(std::is_same_v<decltype(valOrErr),
+                                 Result<std::pair<int, int>, nsresult>>);
+    ASSERT_TRUE(valOrErr.isErr());
+    ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
+  }
+}
+
 TEST(ResultExtensions_ToResultInvokeMember, WithInput_Macro)
 {
   TestClass foo;
@@ -388,6 +449,32 @@ TEST(ResultExtensions_ToResultInvokeMember, NoOutput_Macro)
   }
 }
 
+TEST(ResultExtensions_ToResultInvokeMember, NoInput_Complex_Macro_Typed)
+{
+  TestClass foo;
+
+  // success
+  {
+    auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(
+        (std::pair<int, int>), foo, NonOverloadedNoInputComplex);
+    static_assert(std::is_same_v<decltype(valOrErr),
+                                 Result<std::pair<int, int>, nsresult>>);
+    ASSERT_TRUE(valOrErr.isOk());
+    ASSERT_EQ((std::pair{TestClass::kTestValue, TestClass::kTestValue}),
+              valOrErr.unwrap());
+  }
+
+  // failure
+  {
+    auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(
+        (std::pair<int, int>), foo, NonOverloadedNoInputFailsComplex);
+    static_assert(std::is_same_v<decltype(valOrErr),
+                                 Result<std::pair<int, int>, nsresult>>);
+    ASSERT_TRUE(valOrErr.isErr());
+    ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
+  }
+}
+
 TEST(ResultExtensions_ToResultInvokeMember, RefPtr_NoInput)
 {
   auto foo = MakeRefPtr<RefCountedTestClass>();