Rustup to rust-lang/rust#91230

Author: jdisanti

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-15` toolchain.
-You can install it by using `rustup install nightly-2021-11-15` if you already have rustup.
+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.
 Then you can do:
 
 ```sh
-$ rustup component add rustc-dev llvm-tools-preview --toolchain nightly-2021-11-15
-$ cargo +nightly-2021-11-15 install --git https://github.com/rust-lang/rust-semverver
+$ 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
 ```
 
 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-15"
+channel = "nightly-2021-11-30"
 components = ["llvm-tools-preview", "rustc-dev"]

src/lib.rs

@@ -1,4 +1,5 @@
 #![feature(rustc_private)]
+#![feature(exhaustive_patterns)]
 #![allow(clippy::similar_names)]
 #![allow(clippy::single_match_else)]
 #![allow(clippy::too_many_lines)]

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};
 
-        orig.fold_with(&mut BottomUpFolder {
+        let Ok(result) = orig.fold_with(&mut BottomUpFolder {
             tcx: self.tcx,
             ty_op: |ty| {
                 match *ty.kind() {
@@ -327,7 +327,8 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
             },
             lt_op: |region| self.translate_region(region),
             ct_op: |konst| konst, // TODO: translate consts
-        })
+        });
+        result
     }
 
     /// Translate a region.
@@ -558,12 +559,12 @@ impl<'a, 'tcx> TypeFolder<'tcx> for InferenceCleanupFolder<'a, 'tcx> {
         self.infcx.tcx
     }
 
-    fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
+    fn fold_ty(&mut self, ty: Ty<'tcx>) -> Result<Ty<'tcx>, Self::Error> {
         use rustc_middle::ty::TyKind;
         use rustc_middle::ty::TypeAndMut;
 
-        let t1 = ty.super_fold_with(self);
-        match *t1.kind() {
+        let t1 = ty.super_fold_with(self)?;
+        Ok(match *t1.kind() {
             TyKind::Ref(region, ty, mutbl) if region.needs_infer() => {
                 let ty_and_mut = TypeAndMut { ty, mutbl };
                 self.infcx
@@ -572,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>) -> Region<'tcx> {
-        let r1 = r.super_fold_with(self);
-        if r1.needs_infer() {
+    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() {
             self.infcx.tcx.lifetimes.re_erased
         } else {
             r1
-        }
+        })
     }
 }

src/typeck.rs

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