Merge 2019-07 CWG Motion 18

P1452R2 On the non-uniform semantics of return-type-requirements

Fixes #2998.

Author: zygoloid

source/expressions.tex

@@ -2505,7 +2505,7 @@
 template<typename T>
   concept R = requires (T i) {
     typename T::type;
-    {*i} -> const typename T::type&;
+    {*i} -> ConvertibleTo<const typename T::type&>;
   };
 \end{codeblock}
 A \grammarterm{requires-expression} can also be used in a
@@ -2645,7 +2645,6 @@
 
 \begin{bnf}
 \nontermdef{return-type-requirement}\br
-    trailing-return-type\br
     \terminal{->} type-constraint
 \end{bnf}
 
@@ -2673,19 +2672,8 @@
 into the \grammarterm{return-type-requirement} is performed.
 
 \item
-If the \grammarterm{return-type-requirement} is a
-\grammarterm{trailing-return-type}\iref{dcl.decl},
-%%% FIXME: is -> shall be
-\tcode{E} is implicitly convertible to
-the type named by the \grammarterm{trailing-return-type}.
-If conversion fails, the enclosing \grammarterm{requires-expression}
-is \tcode{false}.
-
-\item
-If the \grammarterm{return-type-requirement}
-is of the form \tcode{->} \grammarterm{type-constraint}, then
-the contextually-determined type being constrained
-is \tcode{decltype((E))}.
+The contextually-determined type being constrained
+by the \grammarterm{type-constraint} is \tcode{decltype((E))}.
 The immediately-declared constraint\iref{temp} of \tcode{decltype((E))}
 shall be satisfied.
 \begin{example}
@@ -2722,15 +2710,14 @@
 
 \begin{codeblock}
 template<typename T> concept C2 = requires(T x) {
-  {*x} -> typename T::inner;
+  {*x} -> Same<typename T::inner>;
 };
 \end{codeblock}
 
 The \grammarterm{compound-requirement} in \tcode{C2}
 requires that \tcode{*x} is a valid expression,
 that \tcode{typename T::inner} is a valid type, and
-that \tcode{*x} is implicitly convertible to
-\tcode{typename T::inner}.
+that \tcode{Same<decltype((*x)), typename T::inner>} is satisfied.
 
 \begin{codeblock}
 template<typename T> concept C3 =

source/iterators.tex

@@ -880,15 +880,15 @@
   is_lvalue_reference_v<iter_reference_t<I>> &&
   Same<remove_cvref_t<iter_reference_t<I>>, typename readable_traits<I>::value_type> &&
   requires(I i) {
-    {  i++ } -> const I&;
+    {  i++ } -> ConvertibleTo<const I&>;
     { *i++ } -> Same<iter_reference_t<I>>;
   };
 
 template<class I>
 concept @\placeholder{cpp17-bidirectional-iterator}@ =
   @\placeholder{cpp17-forward-iterator}@<I> && requires(I i) {
     {  --i } -> Same<I&>;
-    {  i-- } -> const I&;
+    {  i-- } -> ConvertibleTo<const I&>;
     { *i-- } -> Same<iter_reference_t<I>>;
   };
 
@@ -902,7 +902,7 @@
     { n +  i } -> Same<I>;
     { i -  n } -> Same<I>;
     { i -  i } -> Same<decltype(n)>;
-    {  i[n]  } -> iter_reference_t<I>;
+    {  i[n]  } -> ConvertibleTo<iter_reference_t<I>>;
   };
 \end{codeblock}
 

source/ranges.tex

@@ -1125,8 +1125,8 @@
         requires DerivedFrom<tuple_size<T>, integral_constant<size_t, 2>>;
         typename tuple_element_t<0, remove_const_t<T>>;
         typename tuple_element_t<1, remove_const_t<T>>;
-        { get<0>(t) } -> const tuple_element_t<0, T>&;
-        { get<1>(t) } -> const tuple_element_t<1, T>&;
+        { get<0>(t) } -> ConvertibleTo<const tuple_element_t<0, T>&>;
+        { get<1>(t) } -> ConvertibleTo<const tuple_element_t<1, T>&>;
       };
 
   template<class T, class U, class V>

source/templates.tex

@@ -3924,7 +3924,7 @@
 \begin{codeblock}
 template<typename T>
 concept C = requires(T x) {
-  { x == x } -> bool;
+  { x == x } -> ConvertibleTo<bool>;
 };
 
 template<typename T>