考虑以下等式运算符的实现，使用C++20编译（在godbolt上运行）：

#include <optional>

template <class T>
struct MyOptional{
    bool has_value() const { return false;}
    T const & operator*() const { return t; }
    T t{};
};

template <class T>
bool operator==(MyOptional<T> const & lhs, std::nullopt_t)
{
    return !lhs.has_value();
}

template <class U, class T>
bool operator==(U const & lhs, MyOptional<T> const & rhs)
{
    // gcc error: no match for 'operator==' (operand types are 'const std::nullopt_t' and 'const int')
    return rhs.has_value() ? lhs == *rhs : false;
}

int main(){
    MyOptional<int> o1;
    bool compiles = o1 == std::nullopt;
    bool doesNotCompile = std::nullopt == o1; // gcc fails
}

clang 15和MSVC 19.33编译此代码时都没有错误，但gcc 12.2给出了

<source>: In instantiation of 'bool operator==(const U&, const MyOptional<T>&) [with U = std::nullopt_t; T = int]':
<source>:26:43:   required from here
<source>:20:34: error: no match for 'operator==' (operand types are 'const std::nullopt_t' and 'const int')
   20 |     return rhs.has_value() ? lhs == *rhs : false;
      |                              ~~~~^~~~~~~
<source>:11:6: note: candidate: 'template<class T> bool operator==(const MyOptional<T>&, std::nullopt_t)' (reversed)
   11 | bool operator==(MyOptional<T> const & lhs, std::nullopt_t)
      |      ^~~~~~~~
<source>:11:6: note:   template argument deduction/substitution failed:
<source>:20:34: note:   mismatched types 'const MyOptional<T>' and 'const int'
   20 |     return rhs.has_value() ? lhs == *rhs : false;
      |                              ~~~~^~~~~~~
<source>:17:6: note: candidate: 'template<class U, class T> bool operator==(const U&, const MyOptional<T>&)' (reversed)
   17 | bool operator==(U const & lhs, MyOptional<T> const & rhs)
      |      ^~~~~~~~
<source>:17:6: note:   template argument deduction/substitution failed:
<source>:20:34: note:   'const std::nullopt_t' is not derived from 'const MyOptional<T>'
   20 |     return rhs.has_value() ? lhs == *rhs : false;
      |

gcc显然认为第二个重载与std::nullopt == o1更匹配，并试图调用它。
对我来说，并不清楚哪个编译器是正确的。C++20引入了在比较等式时参数的自动反转。据我所知，当编译器看到std::nullopt == o1时，它也会考虑o1 == std::nullopt。然而，当考虑参数的反转顺序时，我找不到任何语句。
1.编译器是否应该首先搜索std::nullopt == o1的有效调用，如果找到了，就直接使用它，而不搜索o1 == std::nullopt？在这种情况下，我想gcc是正确的？
1.或者，编译器总是考虑std::nullopt == o1和反向参数o1 == std::nullopt，并从可行函数集中选择“最佳”匹配（如果原始参数和反向参数匹配不同的重载，则无论“最佳”在这里是什么意思）？我猜，在这种情况下MSVC和clang是正确的？
所以，问题是：哪种编译器是正确的，在匹配过程中什么时候考虑参数的逆序？