Auto merge of #60796 - cuviper:try-desugar-into, r=<try>

[WIP] Use `Into::into` in operator `?`

#38751 proposes using `into` for `?`, and while commenters suggested problems with inference, I couldn't find any evidence where this was actually attempted -- so here we go!

Author: bors

src/libcore/ops/try.rs

@@ -34,7 +34,7 @@ pub trait Try {
     ///
     /// If an `Err(e)` result is returned, the value `e` will be "wrapped"
     /// in the return type of the enclosing scope (which must itself implement
-    /// `Try`). Specifically, the value `X::from_error(From::from(e))`
+    /// `Try`). Specifically, the value `X::from_error(Into::into(e))`
     /// is returned, where `X` is the return type of the enclosing function.
     #[unstable(feature = "try_trait", issue = "42327")]
     fn into_result(self) -> Result<Self::Ok, Self::Error>;

src/libcore/tests/result.rs

@@ -198,7 +198,7 @@ pub fn test_unwrap_or_default() {
 #[test]
 fn test_try() {
     fn try_result_some() -> Option<u8> {
-        let val = Ok(1)?;
+        let val = Ok::<_, NoneError>(1)?;
         Some(val)
     }
     assert_eq!(try_result_some(), Some(1));

src/librustc/dep_graph/dep_node.rs

@@ -370,7 +370,7 @@ impl fmt::Debug for DepNode {
 
         write!(f, "(")?;
 
-        crate::ty::tls::with_opt(|opt_tcx| {
+        crate::ty::tls::with_opt(|opt_tcx| -> fmt::Result {
             if let Some(tcx) = opt_tcx {
                 if let Some(def_id) = self.extract_def_id(tcx) {
                     write!(f, "{}", tcx.def_path_debug_str(def_id))?;

src/librustc/hir/def_id.rs

@@ -171,7 +171,7 @@ impl fmt::Debug for DefId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "DefId({}:{}", self.krate, self.index.as_array_index())?;
 
-        ty::tls::with_opt(|opt_tcx| {
+        ty::tls::with_opt(|opt_tcx| -> fmt::Result {
             if let Some(tcx) = opt_tcx {
                 write!(f, " ~ {}", tcx.def_path_debug_str(*self))?;
             }

src/librustc/hir/lowering.rs

@@ -4763,9 +4763,9 @@ impl<'a> LoweringContext<'a> {
                 //     Ok(val) => #[allow(unreachable_code)] val,
                 //     Err(err) => #[allow(unreachable_code)]
                 //                 // If there is an enclosing `catch {...}`
-                //                 break 'catch_target Try::from_error(From::from(err)),
+                //                 break 'catch_target Try::from_error(Into::into(err)),
                 //                 // Otherwise
-                //                 return Try::from_error(From::from(err)),
+                //                 return Try::from_error(Into::into(err)),
                 // }
 
                 let unstable_span = self.sess.source_map().mark_span_with_reason(
@@ -4826,17 +4826,17 @@ impl<'a> LoweringContext<'a> {
                 };
 
                 // `Err(err) => #[allow(unreachable_code)]
-                //              return Try::from_error(From::from(err)),`
+                //              return Try::from_error(Into::into(err)),`
                 let err_arm = {
                     let err_ident = self.str_to_ident("err");
                     let (err_local, err_local_nid) = self.pat_ident(try_span, err_ident);
-                    let from_expr = {
-                        let from_path = &[sym::convert, sym::From, sym::from];
+                    let into_expr = {
+                        let into_path = &[sym::convert, sym::Into, sym::into];
                         let err_expr = self.expr_ident(try_span, err_ident, err_local_nid);
-                        self.expr_call_std_path(try_span, from_path, hir_vec![err_expr])
+                        self.expr_call_std_path(try_span, into_path, hir_vec![err_expr])
                     };
                     let from_err_expr =
-                        self.wrap_in_try_constructor(sym::from_error, from_expr, unstable_span);
+                        self.wrap_in_try_constructor(sym::from_error, into_expr, unstable_span);
                     let thin_attrs = ThinVec::from(attrs);
                     let catch_scope = self.catch_scopes.last().map(|x| *x);
                     let ret_expr = if let Some(catch_node) = catch_scope {

src/librustc/infer/unify_key.rs

@@ -139,10 +139,10 @@ impl<'tcx> UnifyValue for ConstVarValue<'tcx> {
 
             // If one side is known, prefer that one.
             (ConstVariableValue::Known { .. }, ConstVariableValue::Unknown { .. }) => {
-                Ok(value1.val)
+                value1.val
             }
             (ConstVariableValue::Unknown { .. }, ConstVariableValue::Known { .. }) => {
-                Ok(value2.val)
+                value2.val
             }
 
             // If both sides are *unknown*, it hardly matters, does it?
@@ -154,9 +154,9 @@ impl<'tcx> UnifyValue for ConstVarValue<'tcx> {
                 // universe is the minimum of the two universes, because that is
                 // the one which contains the fewest names in scope.
                 let universe = cmp::min(universe1, universe2);
-                Ok(ConstVariableValue::Unknown { universe })
+                ConstVariableValue::Unknown { universe }
             }
-        }?;
+        };
 
         Ok(ConstVarValue {
             origin: ConstVariableOrigin::ConstInference(DUMMY_SP),

src/librustc/mir/interpret/mod.rs

@@ -159,7 +159,7 @@ impl<'s> AllocDecodingSession<'s> {
 
         // Decode the AllocDiscriminant now so that we know if we have to reserve an
         // AllocId.
-        let (alloc_kind, pos) = decoder.with_position(pos, |decoder| {
+        let (alloc_kind, pos) = decoder.with_position(pos, |decoder| -> Result<_, D::Error> {
             let alloc_kind = AllocDiscriminant::decode(decoder)?;
             Ok((alloc_kind, decoder.position()))
         })?;
@@ -217,7 +217,7 @@ impl<'s> AllocDecodingSession<'s> {
         };
 
         // Now decode the actual data
-        let alloc_id = decoder.with_position(pos, |decoder| {
+        let alloc_id = decoder.with_position(pos, |decoder| -> Result<_, D::Error> {
             match alloc_kind {
                 AllocDiscriminant::Alloc => {
                     let allocation = <&'tcx Allocation as Decodable>::decode(decoder)?;

src/librustc/mir/mod.rs

@@ -2543,7 +2543,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                         let variant_def = &adt_def.variants[variant];
 
                         let f = &mut *fmt;
-                        ty::tls::with(|tcx| {
+                        ty::tls::with(|tcx| -> fmt::Result {
                             let substs = tcx.lift(&substs).expect("could not lift for printing");
                             FmtPrinter::new(tcx, f, Namespace::ValueNS)
                                 .print_def_path(variant_def.def_id, substs)?;

src/librustc/ty/codec.rs

@@ -201,7 +201,7 @@ pub fn decode_predicates<'a, 'tcx, D>(decoder: &mut D)
             }?;
             Ok((predicate, Decodable::decode(decoder)?))
         })
-        .collect::<Result<Vec<_>, _>>()?,
+        .collect::<Result<Vec<_>, D::Error>>()?,
     })
 }
 

src/librustc/ty/instance.rs

@@ -174,7 +174,7 @@ impl<'tcx> InstanceDef<'tcx> {
 
 impl<'tcx> fmt::Display for Instance<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        ty::tls::with(|tcx| {
+        ty::tls::with(|tcx| -> fmt::Result {
             let substs = tcx.lift(&self.substs).expect("could not lift for printing");
             FmtPrinter::new(tcx, &mut *f, Namespace::ValueNS)
                 .print_def_path(self.def_id(), substs)?;