Auto merge of #281 - JohnTitor:rustup-2022-04-11, r=JohnTitor

Rustup to nightly-2021-12-31

Author: bors

README.md

@@ -27,13 +27,13 @@ repository and compiled from source or installed from
 of the nightly toolchain is supported at any given time.
 
 <!-- NOTE: Keep in sync with nightly date on rust-toolchain. -->
-It's recommended to use `nightly-2021-11-30` toolchain.
-You can install it by using `rustup install nightly-2021-11-30` if you already have rustup.
+It's recommended to use `nightly-2021-12-31` toolchain.
+You can install it by using `rustup install nightly-2021-12-31` if you already have rustup.
 Then you can do:
 
 ```sh
-$ rustup component add rustc-dev llvm-tools-preview --toolchain nightly-2021-11-30
-$ cargo +nightly-2021-11-30 install --git https://github.com/rust-lang/rust-semverver
+$ rustup component add rustc-dev llvm-tools-preview --toolchain nightly-2021-12-31
+$ cargo +nightly-2021-12-31 install --git https://github.com/rust-lang/rust-semverver
 ```
 
 You'd also need `cmake` for some dependencies, and a few common libraries (if you hit

rust-toolchain

@@ -1,4 +1,4 @@
 # NOTE: Keep in sync with nightly date on README
 [toolchain]
-channel = "nightly-2021-11-30"
+channel = "nightly-2021-12-31"
 components = ["llvm-tools-preview", "rustc-dev"]

src/mismatch.rs

@@ -198,12 +198,7 @@ impl<'a, 'tcx> TypeRelation<'tcx> for MismatchRelation<'a, 'tcx> {
                 None
             }
             (&TyKind::RawPtr(a_mt), &TyKind::RawPtr(b_mt)) => {
-                let _ = ty::relate::relate_type_and_mut(
-                    self,
-                    a_mt,
-                    b_mt,
-                    ty::VarianceDiagMutKind::RawPtr,
-                )?;
+                let _ = ty::relate::relate_type_and_mut(self, a_mt, b_mt, a)?;
                 None
             }
             (&TyKind::Ref(a_r, a_ty, _), &TyKind::Ref(b_r, b_ty, _)) => {

src/translate.rs

@@ -166,7 +166,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
         use rustc_middle::ty::TypeAndMut;
         use rustc_middle::ty::{AdtDef, Binder, ExistentialProjection, ExistentialTraitRef};
 
-        let Ok(result) = orig.fold_with(&mut BottomUpFolder {
+        orig.fold_with(&mut BottomUpFolder {
             tcx: self.tcx,
             ty_op: |ty| {
                 match *ty.kind() {
@@ -327,8 +327,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
             },
             lt_op: |region| self.translate_region(region),
             ct_op: |konst| konst, // TODO: translate consts
-        });
-        result
+        })
     }
 
     /// Translate a region.
@@ -504,6 +503,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
                 ParamEnv::new(
                     self.tcx.intern_predicates(&target_preds),
                     param_env.reveal(),
+                    param_env.constness(),
                 )
             })
     }
@@ -559,12 +559,12 @@ impl<'a, 'tcx> TypeFolder<'tcx> for InferenceCleanupFolder<'a, 'tcx> {
         self.infcx.tcx
     }
 
-    fn fold_ty(&mut self, ty: Ty<'tcx>) -> Result<Ty<'tcx>, Self::Error> {
+    fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
         use rustc_middle::ty::TyKind;
         use rustc_middle::ty::TypeAndMut;
 
-        let t1 = ty.super_fold_with(self)?;
-        Ok(match *t1.kind() {
+        let t1 = ty.super_fold_with(self);
+        match *t1.kind() {
             TyKind::Ref(region, ty, mutbl) if region.needs_infer() => {
                 let ty_and_mut = TypeAndMut { ty, mutbl };
                 self.infcx
@@ -573,15 +573,15 @@ impl<'a, 'tcx> TypeFolder<'tcx> for InferenceCleanupFolder<'a, 'tcx> {
             }
             TyKind::Infer(_) => self.infcx.tcx.ty_error(),
             _ => t1,
-        })
+        }
     }
 
-    fn fold_region(&mut self, r: Region<'tcx>) -> Result<Region<'tcx>, Self::Error> {
-        let r1 = r.super_fold_with(self)?;
-        Ok(if r1.needs_infer() {
+    fn fold_region(&mut self, r: Region<'tcx>) -> Region<'tcx> {
+        let r1 = r.super_fold_with(self);
+        if r1.needs_infer() {
             self.infcx.tcx.lifetimes.re_erased
         } else {
             r1
-        })
+        }
     }
 }

src/traverse.rs

@@ -85,7 +85,7 @@ pub fn run_traversal(tcx: TyCtxt, new: DefId) {
 
     // Pull a module from the queue, with its global visibility.
     while let Some((new_def_id, idents, new_vis)) = mod_queue.pop_front() {
-        for item in tcx.item_children(new_def_id).to_vec() {
+        for item in tcx.item_children(new_def_id).iter().copied() {
             let n_vis = get_vis(new_vis, item);
             match item.res {
                 Def(Mod, n_def_id) => {

src/typeck.rs

@@ -254,11 +254,12 @@ impl<'a, 'tcx> TypeComparisonContext<'a, 'tcx> {
                 RegionckMode::default(),
             );
 
-            let Ok(folded) = self
+            let err = self
                 .infcx
                 .resolve_vars_if_possible(err)
-                .fold_with(&mut self.folder.clone());
-            let err = folded.lift_to_tcx(lift_tcx).unwrap();
+                .fold_with(&mut self.folder.clone())
+                .lift_to_tcx(lift_tcx)
+                .unwrap();
 
             Some(err)
         } else {
@@ -287,11 +288,11 @@ impl<'a, 'tcx> TypeComparisonContext<'a, 'tcx> {
             errors
                 .iter()
                 .map(|err| {
-                    let Ok(folded) = self
-                        .infcx
+                    self.infcx
                         .resolve_vars_if_possible(err.obligation.predicate)
-                        .fold_with(&mut self.folder.clone());
-                    folded.lift_to_tcx(lift_tcx).unwrap()
+                        .fold_with(&mut self.folder.clone())
+                        .lift_to_tcx(lift_tcx)
+                        .unwrap()
                 })
                 .collect()
         })