Require that a <_ as Try>::Residual implement Residual

The `Residual` trait was even more experimental than `Try`, but now that RFC3721 is merged, I think it would make sense to require this.

Author: scottmcm

library/core/src/ops/try_trait.rs

@@ -157,7 +157,7 @@ pub const trait Try: [const] FromResidual {
     /// type: that type will have a "hole" in the correct place, and will maintain the
     /// "foo-ness" of the residual so other types need to opt-in to interconversion.
     #[unstable(feature = "try_trait_v2", issue = "84277", old_name = "try_trait")]
-    type Residual;
+    type Residual: Residual<Self::Output>;
 
     /// Constructs the type from its `Output` type.
     ///

tests/ui/consts/const-try.rs

@@ -6,10 +6,11 @@
 
 #![crate_type = "lib"]
 #![feature(try_trait_v2)]
+#![feature(try_trait_v2_residual)]
 #![feature(const_trait_impl)]
 #![feature(const_try)]
 
-use std::ops::{ControlFlow, FromResidual, Try};
+use std::ops::{ControlFlow, FromResidual, Residual, Try};
 
 struct TryMe;
 struct Error;
@@ -31,6 +32,10 @@ impl const Try for TryMe {
     }
 }
 
+impl Residual<()> for Error {
+    type TryType = TryMe;
+}
+
 const fn t() -> TryMe {
     TryMe?;
     TryMe

tests/ui/traits/const-traits/ice-126148-failed-to-normalize.rs

@@ -1,6 +1,6 @@
 #![allow(incomplete_features)]
-#![feature(const_trait_impl, try_trait_v2, const_try)]
-use std::ops::{FromResidual, Try};
+#![feature(const_trait_impl, try_trait_v2, try_trait_v2_residual, const_try, const_try_residual)]
+use std::ops::{FromResidual, Residual, Try};
 
 struct TryMe;
 struct Error;
@@ -14,6 +14,10 @@ impl const Try for TryMe {
     type Residual = Error;
 }
 
+impl const Residual<()> for Error {
+    type TryType = TryMe;
+}
+
 const fn t() -> TryMe {
     TryMe?;
     TryMe

tests/ui/traits/const-traits/trait-default-body-stability.rs

@@ -5,11 +5,12 @@
 #![feature(const_trait_impl)]
 #![feature(const_t_try)]
 #![feature(const_try)]
+#![feature(const_try_residual)]
 #![feature(try_trait_v2)]
-
+#![feature(try_trait_v2_residual)]
 #![stable(feature = "foo", since = "1.0")]
 
-use std::ops::{ControlFlow, FromResidual, Try};
+use std::ops::{ControlFlow, FromResidual, Residual, Try};
 
 #[stable(feature = "foo", since = "1.0")]
 pub struct T;
@@ -29,6 +30,12 @@ impl const Try for T {
     }
 }
 
+#[stable(feature = "foo", since = "1.0")]
+#[rustc_const_unstable(feature = "const_t_try", issue = "none")]
+impl const Residual<T> for T {
+    type TryType = T;
+}
+
 #[stable(feature = "foo", since = "1.0")]
 #[rustc_const_unstable(feature = "const_t_try", issue = "none")]
 impl const FromResidual for T {

tests/ui/try-trait/try-operator-custom.rs

@@ -1,12 +1,13 @@
 //@ run-pass
 
 #![feature(try_trait_v2)]
+#![feature(try_trait_v2_residual)]
 
-use std::ops::{ControlFlow, FromResidual, Try};
+use std::ops::{ControlFlow, FromResidual, Residual, Try};
 
 enum MyResult<T, U> {
     Awesome(T),
-    Terrible(U)
+    Terrible(U),
 }
 
 enum Never {}
@@ -27,25 +28,38 @@ impl<U, V> Try for MyResult<U, V> {
     }
 }
 
-impl<U, V, W> FromResidual<MyResult<Never, V>> for MyResult<U, W> where V: Into<W> {
+impl<U, V, W> FromResidual<MyResult<Never, V>> for MyResult<U, W>
+where
+    V: Into<W>,
+{
     fn from_residual(x: MyResult<Never, V>) -> Self {
         match x {
             MyResult::Terrible(e) => MyResult::Terrible(e.into()),
         }
     }
 }
 
+impl<U, V> Residual<U> for MyResult<Never, V> {
+    type TryType = MyResult<U, V>;
+}
+
 type ResultResidual<E> = Result<std::convert::Infallible, E>;
 
-impl<U, V, W> FromResidual<ResultResidual<V>> for MyResult<U, W> where V: Into<W> {
+impl<U, V, W> FromResidual<ResultResidual<V>> for MyResult<U, W>
+where
+    V: Into<W>,
+{
     fn from_residual(x: ResultResidual<V>) -> Self {
         match x {
             Err(e) => MyResult::Terrible(e.into()),
         }
     }
 }
 
-impl<U, V, W> FromResidual<MyResult<Never, V>> for Result<U, W> where V: Into<W> {
+impl<U, V, W> FromResidual<MyResult<Never, V>> for Result<U, W>
+where
+    V: Into<W>,
+{
     fn from_residual(x: MyResult<Never, V>) -> Self {
         match x {
             MyResult::Terrible(e) => Err(e.into()),