[over.match.oper] Refactor the <=> rewrite candidate rules for clarity.

Author: zygoloid

source/overloading.tex

@@ -975,10 +975,12 @@
 \tcode{T1}
 and a right operand of a type whose cv-unqualified version is
 \tcode{T2},
-three sets of candidate functions, designated
+four sets of candidate functions, designated
 \defnx{member candidates}{member candidate},
-\defnx{non-member candidates}{non-member candidate}
-and \defnx{built-in candidates}{built-in candidate},
+\defnx{non-member candidates}{non-member candidate},
+\defnx{built-in candidates}{built-in candidate},
+and
+\defnx{rewritten candidates}{rewritten candidate},
 are constructed as follows:
 \begin{itemize}
 \item
@@ -1033,6 +1035,37 @@
 do not have the same parameter-type-list as any non-member candidate
 that is not a function template specialization.
 \end{itemize}
+
+\item
+For the
+relational\iref{expr.rel} and
+equality\iref{expr.eq} operators,
+the rewritten candidates include
+all member, non-member, and built-in candidates
+for the operator \tcode{<=>}
+for which the rewritten expression
+\tcode{(x <=> y) @ 0} is well-formed using that \tcode{operator<=>}.
+For the
+relational\iref{expr.rel},
+equality\iref{expr.eq},
+and
+three-way comparison\iref{expr.spaceship}
+operators,
+the rewritten candidates also include
+a synthesized candidate,
+with the order of the two parameters reversed,
+for each member, non-member, and built-in candidate
+for the operator \tcode{<=>}
+for which the rewritten expression
+\tcode{0 @ (y <=> x)} is well-formed using that \tcode{operator<=>}.
+\begin{note}
+A candidate synthesized from a member candidate has its implicit
+object parameter as the second parameter, thus implicit conversions
+are considered for the first, but not for the second, parameter.
+\end{note}
+In each case, rewritten candidates are not considered
+in the context of the rewritten expression.
+For all other operators, the rewritten candidate set is empty.
 \end{itemize}
 
 \pnum
@@ -1054,41 +1087,12 @@
 The set of candidate functions for overload resolution
 for some operator \tcode{@}
 is the
-union of the member candidates, the non-member candidates, and
-the built-in candidates for that operator \tcode{@}.
-If that operator is a
-relational\iref{expr.rel},
-equality\iref{expr.eq},
-or three-way comparison\iref{expr.spaceship}
-operator
-with operands \tcode{x} and \tcode{y},
-then for each member, non-member, or built-in candidate
-for the operator \tcode{<=>}:
-\begin{itemize}
-\item
-that operator is added to the set of candidate functions for overload resolution
-if \tcode{@} is not \tcode{<=>}
-and \tcode{(x <=> y) @ 0} is well-formed using that \tcode{operator<=>}; and
-\item
-a synthesized candidate is added to the candidate set
-where the order of the two parameters is reversed
-if \tcode{0 @ (y <=> x)} is well-formed using that \tcode{operator<=>};
-\end{itemize}
-where in each case,
-\begin{itemize}
-\item if \tcode{@} is not \tcode{<=>},
-\tcode{operator<=>} candidates
-are not considered for the recursive lookup of operator \tcode{@}
-and
-\item
-synthesized \tcode{operator<=>} candidates
-are not considered for the recursive lookups.
-\end{itemize}
-\begin{note}
-A candidate synthesized from a member candidate has its implicit
-object parameter as the second parameter, thus implicit conversions
-are considered for the first, but not for the second, parameter.
-\end{note}
+union of
+the member candidates,
+the non-member candidates,
+the built-in candidates,
+and the rewritten candidates
+for that operator \tcode{@}.
 
 \pnum
 The argument list contains all of the
@@ -1112,14 +1116,15 @@
 \end{example}
 
 \pnum
-If an \tcode{operator<=>} candidate
+If a rewritten candidate
 is selected by overload resolution for an operator \tcode{@},
 \tcode{x @ y}
-is interpreted as \tcode{0 @ (y <=> x)}
+is interpreted as the rewritten expression:
+\tcode{0 @ (y <=> x)}
 if the selected candidate is a synthesized candidate
 with reversed order of parameters,
-or \tcode{(x <=> y) @ 0} if \tcode{@} is not \tcode{<=>},
-using the selected \tcode{operator<=>} candidate.
+or \tcode{(x <=> y) @ 0} otherwise,
+using the selected rewritten \tcode{operator<=>} candidate.
 
 \pnum
 If a built-in candidate is selected by overload resolution, the