Fix new ? inference errors in librustc

Author: cuviper

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/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)?;

src/librustc/ty/layout.rs

@@ -249,7 +249,10 @@ impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> {
             Prefixed(Size, Align),
         }
 
-        let univariant_uninterned = |fields: &[TyLayout<'_>], repr: &ReprOptions, kind| {
+        let univariant_uninterned = |fields: &[TyLayout<'_>],
+                                     repr: &ReprOptions,
+                                     kind|
+         -> Result<_, LayoutError<'tcx>> {
             let packed = repr.packed();
             if packed && repr.align > 0 {
                 bug!("struct cannot be packed and aligned");
@@ -458,9 +461,10 @@ impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> {
                 size
             })
         };
-        let univariant = |fields: &[TyLayout<'_>], repr: &ReprOptions, kind| {
-            Ok(tcx.intern_layout(univariant_uninterned(fields, repr, kind)?))
-        };
+        let univariant =
+            |fields: &[TyLayout<'_>], repr: &ReprOptions, kind| -> Result<_, LayoutError<'tcx>> {
+                Ok(tcx.intern_layout(univariant_uninterned(fields, repr, kind)?))
+            };
         debug_assert!(!ty.has_infer_types());
 
         Ok(match ty.sty {
@@ -635,7 +639,7 @@ impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> {
                     align = align.max(variant.align);
 
                     Ok(variant)
-                }).collect::<Result<IndexVec<VariantIdx, _>, _>>()?;
+                }).collect::<Result<IndexVec<VariantIdx, _>, LayoutError<'tcx>>>()?;
 
                 let abi = if prefix.abi.is_uninhabited() ||
                              variants.iter().all(|v| v.abi.is_uninhabited()) {
@@ -933,7 +937,7 @@ impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> {
                                 align = align.max(st.align);
 
                                 Ok(st)
-                            }).collect::<Result<IndexVec<VariantIdx, _>, _>>()?;
+                            }).collect::<Result<IndexVec<VariantIdx, _>, LayoutError<'tcx>>>()?;
 
                             let offset = st[i].fields.offset(field_index) + niche.offset;
                             let size = st[i].size;
@@ -1048,7 +1052,7 @@ impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> {
                     size = cmp::max(size, st.size);
                     align = align.max(st.align);
                     Ok(st)
-                }).collect::<Result<IndexVec<VariantIdx, _>, _>>()?;
+                }).collect::<Result<IndexVec<VariantIdx, _>, LayoutError<'tcx>>>()?;
 
                 // Align the maximum variant size to the largest alignment.
                 size = size.align_to(align.abi);

src/librustc/ty/query/on_disk_cache.rs

@@ -202,7 +202,7 @@ impl<'sess> OnDiskCache<'sess> {
             // Encode query results
             let mut query_result_index = EncodedQueryResultIndex::new();
 
-            time(tcx.sess, "encode query results", || {
+            time(tcx.sess, "encode query results", || -> Result<_, E::Error> {
                 use crate::ty::query::queries::*;
                 let enc = &mut encoder;
                 let qri = &mut query_result_index;
@@ -260,7 +260,7 @@ impl<'sess> OnDiskCache<'sess> {
 
                 Ok((dep_node_index, pos))
             })
-            .collect::<Result<_, _>>()?;
+            .collect::<Result<_, E::Error>>()?;
 
             let interpret_alloc_index = {
                 let mut interpret_alloc_index = Vec::new();