You are referring to CWG3938. This core issue does not exist (yet), we're at least 1000 core issues away from that. Maybe you meant to refer to LWG3938.

In any case, your concerns appear to be non-editorial in nature: If a type computation prescribed by the standard yields an incorrect type, that's not for the editors to fix. Please file an LWG issue with your concerns.

You are referring to CWG3938. This core issue does not exist (yet), we're at least 1000 core issues away from that. Maybe you meant to refer to LWG3938.

In any case, your concerns appear to be non-editorial in nature: If a type computation prescribed by the standard yields an incorrect type, that's not for the editors to fix. Please file an LWG issue with your concerns.

I'm so sorry, that is a typo, I'm referring to LWG3938, and thanks for your tips.

template <class _Func>
  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, decltype(**this)>>;
  static_assert(
      __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(value())) must have the same error_type as this expected");
  if (has_value()) {
    return std::invoke(std::forward<_Func>(__f), std::move(**this));
  }
  return _Up(unexpect, std::move(error()));
}

It seems to me that you detected a wrong type. _Up should be remove_cvref_t<invoke_result_t<_Func, decltype(std::move(**this))>> in this overload.
(Anyway, I think the status quo of type detection of these overloads in libc++ ((1), (2), (3), (4)) is fine. We should just change the message in static_assert.)

2. invalid use of 'this' outside of a non-static member function

The standard wording:

template<class F> constexpr auto or_else(F&& f) &;
template<class F> constexpr auto or_else(F&& f) const &;
...
Constraints: is_constructible_v<T, decltype(**this)> is true.

template<class F> constexpr auto transform_error(F&& f) &;
template<class F> constexpr auto transform_error(F&& f) const &;
...
Constraints: is_constructible_v<T, decltype(**this)> is true.

The wording is specifying non-static member functions, isn't it?

Yes.
But maybe they're trying to use a requires clause to implement that constraint.
It seems that you can use this in requires clauses that are trailing only: https://compiler-explorer.com/z/b6GPf41d4.

But maybe they're trying to use a requires clause to implement that constraint.

I guess it's unnecessary to make Constraints conform to requires-clauses. In the standard wording, IMO it's better to specify conditions in Mandates and Constraints in the same contexts.

invalid use of 'this' outside of a non-static member function

This is not-a-defect. We're describing a non-static member function here, and this certainly has a this pointer. Maybe you can't implement those "constraints" the most obvious way, but that's your problem as an implementer, not a specification problem.

I'm working on address LWG3938(https://wg21.link/LWG3938) in libc++, there maybe 2 issues in the wording:

1. `*this` always produces an Lvalue http://eel.is/c++draft/expr.unary.op#1.sentence-3 , so the type of `decltype(**this)` is `const _Tp &` but not `const _Tp &&`

The wording clearly says

Let U be remove_cvref_t<invoke_result_t<F, decltype(std::move(**this))>>.

But you forgot the move when declaring _Up:

template <class _Func>
  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, decltype(**this)>>;
  static_assert(
      __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(value())) must have the same error_type as this expected");
  if (has_value()) {
    return std::invoke(std::forward<_Func>(__f), std::move(**this));
  }
  return _Up(unexpect, std::move(error()));
}

This is just an implementation bug.

2. invalid use of 'this' outside of a non-static member function

The standard wording:

template<class F> constexpr auto or_else(F&& f) &;
template<class F> constexpr auto or_else(F&& f) const &;
...
Constraints: is_constructible_v<T, decltype(**this)> is true.

template<class F> constexpr auto transform_error(F&& f) &;
template<class F> constexpr auto transform_error(F&& f) const &;
...
Constraints: is_constructible_v<T, decltype(**this)> is true.

This wording is fine too. If you use this outside the member function definition that's just another implementation bug.

Feel free to replace decltype(**this) with T& for the first overload and const T& for the second overload, you don't have to spell it the same way as the standard does.

Thanks for the clarification and advice, the first question was my mistake.