Merge 2019-07 CWG Motion 6

 P1186R3 When do you actually use <=>?

Fixes #2985.

Author: zygoloid

source/basic.tex

@@ -651,6 +651,13 @@
                                 // \tcode{D()}'s implicit definition violates the ODR
 \end{codeblock}
 \end{example}
+
+\item if \tcode{D} is a class with
+a defaulted three-way comparison operator function\iref{class.spaceship},
+it is as if the operator was
+implicitly defined in every translation unit where it is odr-used, and the
+implicit definition in every translation unit shall call the same
+comparison operators for each subobject of \tcode{D}.
 \end{itemize}
 If \tcode{D} is a template and is defined in more than one
 translation unit, then the preceding requirements

source/classes.tex

@@ -6831,24 +6831,92 @@
 \rSec2[class.spaceship]{Three-way comparison}
 \indextext{operator!three-way comparison!defaulted}%
 
+\pnum
+The \defnadj{synthesized}{three-way comparison}
+for comparison category type \tcode{R}\iref{cmp.categories}
+of glvalues \tcode{a} and \tcode{b} of the same type
+is defined as follows:
+
+\begin{itemize}
+\item
+If overload resolution for \tcode{a <=> b}
+finds a usable function\iref{over.match},
+\tcode{static_cast<R>(a <=> b)}.
+
+\item
+Otherwise, if overload resolution for \tcode{a <=> b}
+finds at least one viable candidate,
+the synthesized three-way comparison is not defined.
+
+\item
+Otherwise, if \tcode{R} is \tcode{strong_ordering}, then
+\begin{codeblock}
+a == b ? strong_ordering::equal :
+a < b  ? strong_ordering::less :
+         strong_ordering::greater
+\end{codeblock}
+
+\item
+Otherwise, if \tcode{R} is \tcode{weak_ordering}, then
+\begin{codeblock}
+a == b ? weak_ordering::equal :
+a < b  ? weak_ordering::less :
+         weak_ordering::greater
+\end{codeblock}
+
+\item
+Otherwise, if \tcode{R} is \tcode{partial_ordering}, then
+\begin{codeblock}
+a == b ? partial_ordering::equivalent :
+a < b  ? partial_ordering::less :
+b < a  ? partial_ordering::greater :
+         partial_ordering::unordered
+\end{codeblock}
+
+\item
+Otherwise, if \tcode{R} is \tcode{strong_equality}, then
+\begin{codeblock}
+a == b ? strong_equality::equal : strong_equality::nonequal
+\end{codeblock}
+
+\item
+Otherwise, if \tcode{R} is \tcode{weak_equality}, then
+\begin{codeblock}
+a == b ? weak_equality::equivalent : weak_equality::nonequivalent
+\end{codeblock}
+
+\item
+Otherwise, the synthesized three-way comparison is not defined.
+\end{itemize}
+\begin{note}
+A synthesized three-way comparison may be ill-formed
+if overload resolution finds usable functions
+that do not otherwise meet the requirements implied by the defined expression.
+\end{note}
+
 \pnum
 Given an expanded list of subobjects for an object \tcode{x} of type \tcode{C},
 the type of the expression $\tcode{x}_i$ \tcode{<=>} $\tcode{x}_i$
 is denoted by $\tcode{R}_i$.
+If overload resolution as applied to $\tcode{x}_i$ \tcode{<=>} $\tcode{x}_i$
+does not find a usable function,
+then $\tcode{R}_i$ is \tcode{void}.
 If the declared return type
 of a defaulted three-way comparison operator function
 is \tcode{auto},
 then the return type is deduced as
 the common comparison type (see below) of
 $\tcode{R}_0$, $\tcode{R}_1$, $\dotsc$, $\tcode{R}_{n-1}$.
-\begin{note}
-Otherwise,
-the program will be ill-formed
-if the expression $\tcode{x}_i$ \tcode{<=>} $\tcode{x}_i$
-is not implicitly convertible to the declared return type for any $i$.
-\end{note}
 If the return type is deduced as \tcode{void},
 the operator function is defined as deleted.
+If the declared return type of
+a defaulted three-way comparison operator function
+is \tcode{R}
+and the synthesized three-way comparison
+for comparison category type \tcode{R}
+between any objects $\tcode{x}_i$ and $\tcode{x}_i$
+is not defined or would be ill-formed,
+the operator function is defined as deleted.
 
 \pnum
 The return value \tcode{V} of type \tcode{R}
@@ -6858,8 +6926,9 @@
 $\tcode{x}_i$ and $\tcode{y}_i$
 in the expanded lists of subobjects for \tcode{x} and \tcode{y}
 (in increasing index order)
-until the first index $i$
-where $\tcode{x}_i$ \tcode{<=>} $\tcode{y}_i$
+until the first index $i$ where
+the synthesized three-way comparison for comparison category type \tcode{R}
+between $\tcode{x}_i$ and $\tcode{y}_i$
 yields a result value $\tcode{v}_i$ where $\tcode{v}_i \mathrel{\tcode{!=}} 0$,
 contextually converted to \tcode{bool}, yields \tcode{true};
 \tcode{V} is $\tcode{v}_i$ converted to \tcode{R}.

source/overloading.tex

@@ -474,6 +474,12 @@
 in which it is used,
 the program is ill-formed.
 
+\pnum
+Overload resolution results in a \defnadj{usable}{function}
+if overload resolution succeeds and
+the selected function is not deleted and
+is accessible from the context in which overload resolution was performed.
+
 \rSec2[over.match.funcs]{Candidate functions and argument lists}%
 \indextext{overloading!candidate functions|(}%
 \indextext{overloading!argument lists|(}

source/preprocessor.tex

@@ -1697,7 +1697,7 @@
 \defnxname{cpp_hex_float}                         & \tcode{201603L} \\ \rowsep
 \defnxname{cpp_if_constexpr}                      & \tcode{201606L} \\ \rowsep
 \defnxname{cpp_impl_destroying_delete}            & \tcode{201806L} \\ \rowsep
-\defnxname{cpp_impl_three_way_comparison}         & \tcode{201711L} \\ \rowsep
+\defnxname{cpp_impl_three_way_comparison}         & \tcode{201907L} \\ \rowsep
 \defnxname{cpp_inheriting_constructors}           & \tcode{201511L} \\ \rowsep
 \defnxname{cpp_init_captures}                     & \tcode{201304L} \\ \rowsep
 \defnxname{cpp_initializer_lists}                 & \tcode{200806L} \\ \rowsep