[libc++] Implement LWG3973(Monadic operations should be ADL-proof)

wenhuiNi · wenhuiNi · commit b6ffcb161cb9 · 2024-03-12T06:05:20.000+08:00
Signed-off-by: nwh &lt;nwh_work@foxmail.com&gt;
diff --git a/libcxx/docs/Status/Cxx2cIssues.csv b/libcxx/docs/Status/Cxx2cIssues.csv
@@ -34,7 +34,7 @@
 "`3957 <https://wg21.link/LWG3957>`__","[container.alloc.reqmts] The value category of v should be claimed","Kona November 2023","","",""
 "`3965 <https://wg21.link/LWG3965>`__","Incorrect example in [format.string.escaped] p3 for formatting of combining characters","Kona November 2023","","","|format|"
 "`3970 <https://wg21.link/LWG3970>`__","[mdspan.syn] Missing definition of ``full_extent_t`` and ``full_extent``","Kona November 2023","","",""
-"`3973 <https://wg21.link/LWG3973>`__","Monadic operations should be ADL-proof","Kona November 2023","","",""
+"`3973 <https://wg21.link/LWG3973>`__","Monadic operations should be ADL-proof","Kona November 2023","|Complete|","19.0",""
 "`3974 <https://wg21.link/LWG3974>`__","``mdspan::operator[]`` should not copy ``OtherIndexTypes``","Kona November 2023","","",""
 "`3987 <https://wg21.link/LWG3987>`__","Including ``<flat_foo>`` doesn't provide ``std::begin``/``end``","Kona November 2023","","","|flat_containers|"
 "`3990 <https://wg21.link/LWG3990>`__","Program-defined specializations of ``std::tuple`` and ``std::variant`` can't be properly supported","Kona November 2023","","",""
diff --git a/libcxx/include/__expected/expected.h b/libcxx/include/__expected/expected.h
@@ -920,9 +920,9 @@ class expected : private __expected_base<_Tp, _Err> {
     requires is_constructible_v<_Err, _Err&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & {
     using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&>>;
-    static_assert(__is_std_expected<_Up>::value, "The result of f(**this) must be a specialization of std::expected");
+    static_assert(__is_std_expected<_Up>::value, "The result of f(value()) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Up::error_type, _Err>,
-                  "The result of f(**this) must have the same error_type as this expected");
+                  "The result of f(value()) must have the same error_type as this expected");
     if (has_value()) {
       return std::invoke(std::forward<_Func>(__f), this->__val());
     }
@@ -933,9 +933,9 @@ class expected : private __expected_base<_Tp, _Err> {
     requires is_constructible_v<_Err, const _Err&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& {
     using _Up = remove_cvref_t<invoke_result_t<_Func, const _Tp&>>;
-    static_assert(__is_std_expected<_Up>::value, "The result of f(**this) must be a specialization of std::expected");
+    static_assert(__is_std_expected<_Up>::value, "The result of f(value()) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Up::error_type, _Err>,
-                  "The result of f(**this) must have the same error_type as this expected");
+                  "The result of f(value()) must have the same error_type as this expected");
     if (has_value()) {
       return std::invoke(std::forward<_Func>(__f), this->__val());
     }
@@ -947,9 +947,9 @@ class expected : private __expected_base<_Tp, _Err> {
   _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && {
     using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&&>>;
     static_assert(
-        __is_std_expected<_Up>::value, "The result of f(std::move(**this)) must be a specialization of std::expected");
+        __is_std_expected<_Up>::value, "The result of f(std::move(value())) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Up::error_type, _Err>,
-                  "The result of f(std::move(**this)) must have the same error_type as this expected");
+                  "The result of f(std::move(value())) must have the same error_type as this expected");
     if (has_value()) {
       return std::invoke(std::forward<_Func>(__f), std::move(this->__val()));
     }
@@ -961,9 +961,9 @@ class expected : private __expected_base<_Tp, _Err> {
   _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
     using _Up = remove_cvref_t<invoke_result_t<_Func, const _Tp&&>>;
     static_assert(
-        __is_std_expected<_Up>::value, "The result of f(std::move(**this)) must be a specialization of std::expected");
+        __is_std_expected<_Up>::value, "The result of f(std::move(value())) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Up::error_type, _Err>,
-                  "The result of f(std::move(**this)) must have the same error_type as this expected");
+                  "The result of f(std::move(value())) must have the same error_type as this expected");
     if (has_value()) {
       return std::invoke(std::forward<_Func>(__f), std::move(this->__val()));
     }
diff --git a/libcxx/test/libcxx/utilities/expected/expected.expected/and_then.mandates.verify.cpp b/libcxx/test/libcxx/utilities/expected/expected.expected/and_then.mandates.verify.cpp
@@ -11,22 +11,22 @@
 // Test the mandates
 // template<class F> constexpr auto and_then(F&& f) &;
 // Mandates:
-//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(**this)>>
+//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(value())>>
 //  U is a specialization of std::expected and std::is_same_v<U:error_type, E> is true
 
 // template<class F> constexpr auto and_then(F&& f) const &;
 // Mandates:
-//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(**this)>>
+//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(value())>>
 //  U is a specialization of std::expected and std::is_same_v<U:error_type, E> is true
 
 // template<class F> constexpr auto and_then(F&& f) &&;
 // Mandates:
-//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(**this)>>
+//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(value())>>
 //  U is a specialization of std::expected and std::is_same_v<U:error_type, E> is true
 
 // template<class F> constexpr auto and_then(F&& f) const &&;
 // Mandates:
-//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(**this)>>
+//  Let U be std::remove_cvref_t<std::invoke_result<F, decltype(value())>>
 //  U is a specialization of std::expected and std::is_same_v<U:error_type, E> is true
 
 #include <expected>
@@ -52,7 +52,7 @@ void test() {
     {
       std::expected<int, int> f1(1);
       f1.and_then(lval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<int (&)(int &)>' requested here}}
-      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(**this) must be a specialization of std::expected}}
+      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(value()) must be a specialization of std::expected}}
       // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}}
       // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}}
     }
@@ -61,7 +61,7 @@ void test() {
     {
       std::expected<int, int> f1(1);
       f1.and_then(lval_error_type_not_same_as_int);  // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<std::expected<int, NotSameAsInt> (&)(int &)>' requested here}}
-      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(**this) must have the same error_type as this expected}}
+      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(value()) must have the same error_type as this expected}}
     }
   }
 
@@ -71,7 +71,7 @@ void test() {
     {
       const std::expected<int, int> f1(1);
       f1.and_then(clval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<int (&)(const int &)>' requested here}}
-      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(**this) must be a specialization of std::expected}}
+      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(value()) must be a specialization of std::expected}}
       // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}}
       // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}}
     }
@@ -80,7 +80,7 @@ void test() {
     {
       const std::expected<int, int> f1(1);
       f1.and_then(clval_error_type_not_same_as_int);  // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<std::expected<int, NotSameAsInt> (&)(const int &)>' requested here}}
-      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(**this) must have the same error_type as this expected}}
+      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(value()) must have the same error_type as this expected}}
 
     }
   }
@@ -91,7 +91,7 @@ void test() {
     {
       std::expected<int, int> f1(1);
       std::move(f1).and_then(rval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<int (&)(int &&)>' requested here}}
-      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(**this)) must be a specialization of std::expected}}
+      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(value())) must be a specialization of std::expected}}
       // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}}
       // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}}
     }
@@ -100,7 +100,7 @@ void test() {
     {
       std::expected<int, int> f1(1);
       std::move(f1).and_then(rval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<std::expected<int, NotSameAsInt> (&)(int &&)>' requested here}}
-      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(**this)) must have the same error_type as this expected}}
+      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(value())) must have the same error_type as this expected}}
     }
   }
 
@@ -110,7 +110,7 @@ void test() {
     {
       const std::expected<int, int> f1(1);
       std::move(f1).and_then(crval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<int (&)(const int &&)>' requested here}}
-      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(**this)) must be a specialization of std::expected}}
+      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(value())) must be a specialization of std::expected}}
       // expected-error-re@*:* {{{{.*}}cannot be used prior to '::' because it has no members}}
       // expected-error-re@*:* {{no matching constructor for initialization of{{.*}}}}
     }
@@ -119,7 +119,7 @@ void test() {
     {
       const std::expected<int, int> f1(1);
       std::move(f1).and_then(crval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<std::expected<int, NotSameAsInt> (&)(const int &&)>' requested here}}
-      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(**this)) must have the same error_type as this expected}}
+      // expected-error-re@*:* {{static assertion failed {{.*}}The result of f(std::move(value())) must have the same error_type as this expected}}
     }
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -11,22 +11,22 @@`
`11`	`11`	`// Test the mandates`
`12`	`12`	`// template<class F> constexpr auto and_then(F&& f) &;`
`13`	`13`	`// Mandates:`
`14`		`-// Let U be std::remove_cvref_t<std::invoke_result<F, decltype(**this)>>`
	`14`	`+// Let U be std::remove_cvref_t<std::invoke_result<F, decltype(value())>>`
`15`	`15`	`// U is a specialization of std::expected and std::is_same_v<U:error_type, E> is true`
`16`	`16`
`17`	`17`	`// template<class F> constexpr auto and_then(F&& f) const &;`
`18`	`18`	`// Mandates:`
`19`		`-// Let U be std::remove_cvref_t<std::invoke_result<F, decltype(**this)>>`
	`19`	`+// Let U be std::remove_cvref_t<std::invoke_result<F, decltype(value())>>`
`20`	`20`	`// U is a specialization of std::expected and std::is_same_v<U:error_type, E> is true`
`21`	`21`
`22`	`22`	`// template<class F> constexpr auto and_then(F&& f) &&;`
`23`	`23`	`// Mandates:`
`24`		`-// Let U be std::remove_cvref_t<std::invoke_result<F, decltype(**this)>>`
	`24`	`+// Let U be std::remove_cvref_t<std::invoke_result<F, decltype(value())>>`
`25`	`25`	`// U is a specialization of std::expected and std::is_same_v<U:error_type, E> is true`
`26`	`26`
`27`	`27`	`// template<class F> constexpr auto and_then(F&& f) const &&;`
`28`	`28`	`// Mandates:`
`29`		`-// Let U be std::remove_cvref_t<std::invoke_result<F, decltype(**this)>>`
	`29`	`+// Let U be std::remove_cvref_t<std::invoke_result<F, decltype(value())>>`
`30`	`30`	`// U is a specialization of std::expected and std::is_same_v<U:error_type, E> is true`
`31`	`31`
`32`	`32`	`#include <expected>`
`@@ -52,7 +52,7 @@ void test() {`
`52`	`52`	`{`
`53`	`53`	`std::expected<int, int> f1(1);`
`54`	`54`	`f1.and_then(lval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<int (&)(int &)>' requested here}}`
`55`		`- // expected-error-re@: {{static assertion failed {{.}}The result of f(*this) must be a specialization of std::expected}}`
	`55`	`+ // expected-error-re@: {{static assertion failed {{.*}}The result of f(value()) must be a specialization of std::expected}}`
`56`	`56`	`// expected-error-re@: {{{{.*}}cannot be used prior to '::' because it has no members}}`
`57`	`57`	`// expected-error-re@: {{no matching constructor for initialization of{{.*}}}}`
`58`	`58`	`}`
`@@ -61,7 +61,7 @@ void test() {`
`61`	`61`	`{`
`62`	`62`	`std::expected<int, int> f1(1);`
`63`	`63`	`f1.and_then(lval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<std::expected<int, NotSameAsInt> (&)(int &)>' requested here}}`
`64`		`- // expected-error-re@: {{static assertion failed {{.}}The result of f(*this) must have the same error_type as this expected}}`
	`64`	`+ // expected-error-re@: {{static assertion failed {{.*}}The result of f(value()) must have the same error_type as this expected}}`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`
`@@ -71,7 +71,7 @@ void test() {`
`71`	`71`	`{`
`72`	`72`	`const std::expected<int, int> f1(1);`
`73`	`73`	`f1.and_then(clval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<int (&)(const int &)>' requested here}}`
`74`		`- // expected-error-re@: {{static assertion failed {{.}}The result of f(*this) must be a specialization of std::expected}}`
	`74`	`+ // expected-error-re@: {{static assertion failed {{.*}}The result of f(value()) must be a specialization of std::expected}}`
`75`	`75`	`// expected-error-re@: {{{{.*}}cannot be used prior to '::' because it has no members}}`
`76`	`76`	`// expected-error-re@: {{no matching constructor for initialization of{{.*}}}}`
`77`	`77`	`}`
`@@ -80,7 +80,7 @@ void test() {`
`80`	`80`	`{`
`81`	`81`	`const std::expected<int, int> f1(1);`
`82`	`82`	`f1.and_then(clval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<std::expected<int, NotSameAsInt> (&)(const int &)>' requested here}}`
`83`		`- // expected-error-re@: {{static assertion failed {{.}}The result of f(*this) must have the same error_type as this expected}}`
	`83`	`+ // expected-error-re@: {{static assertion failed {{.*}}The result of f(value()) must have the same error_type as this expected}}`
`84`	`84`
`85`	`85`	`}`
`86`	`86`	`}`
`@@ -91,7 +91,7 @@ void test() {`
`91`	`91`	`{`
`92`	`92`	`std::expected<int, int> f1(1);`
`93`	`93`	`std::move(f1).and_then(rval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<int (&)(int &&)>' requested here}}`
`94`		`- // expected-error-re@: {{static assertion failed {{.}}The result of f(std::move(*this)) must be a specialization of std::expected}}`
	`94`	`+ // expected-error-re@: {{static assertion failed {{.*}}The result of f(std::move(value())) must be a specialization of std::expected}}`
`95`	`95`	`// expected-error-re@: {{{{.*}}cannot be used prior to '::' because it has no members}}`
`96`	`96`	`// expected-error-re@: {{no matching constructor for initialization of{{.*}}}}`
`97`	`97`	`}`
`@@ -100,7 +100,7 @@ void test() {`
`100`	`100`	`{`
`101`	`101`	`std::expected<int, int> f1(1);`
`102`	`102`	`std::move(f1).and_then(rval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<std::expected<int, NotSameAsInt> (&)(int &&)>' requested here}}`
`103`		`- // expected-error-re@: {{static assertion failed {{.}}The result of f(std::move(*this)) must have the same error_type as this expected}}`
	`103`	`+ // expected-error-re@: {{static assertion failed {{.*}}The result of f(std::move(value())) must have the same error_type as this expected}}`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`
`@@ -110,7 +110,7 @@ void test() {`
`110`	`110`	`{`
`111`	`111`	`const std::expected<int, int> f1(1);`
`112`	`112`	`std::move(f1).and_then(crval_return_not_std_expected); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<int (&)(const int &&)>' requested here}}`
`113`		`- // expected-error-re@: {{static assertion failed {{.}}The result of f(std::move(*this)) must be a specialization of std::expected}}`
	`113`	`+ // expected-error-re@: {{static assertion failed {{.*}}The result of f(std::move(value())) must be a specialization of std::expected}}`
`114`	`114`	`// expected-error-re@: {{{{.*}}cannot be used prior to '::' because it has no members}}`
`115`	`115`	`// expected-error-re@: {{no matching constructor for initialization of{{.*}}}}`
`116`	`116`	`}`
`@@ -119,7 +119,7 @@ void test() {`
`119`	`119`	`{`
`120`	`120`	`const std::expected<int, int> f1(1);`
`121`	`121`	`std::move(f1).and_then(crval_error_type_not_same_as_int); // expected-note{{in instantiation of function template specialization 'std::expected<int, int>::and_then<std::expected<int, NotSameAsInt> (&)(const int &&)>' requested here}}`
`122`		`- // expected-error-re@: {{static assertion failed {{.}}The result of f(std::move(*this)) must have the same error_type as this expected}}`
	`122`	`+ // expected-error-re@: {{static assertion failed {{.*}}The result of f(std::move(value())) must have the same error_type as this expected}}`
`123`	`123`	`}`
`124`	`124`	`}`
`125`	`125`	`}`