Remove Option from fold_infer_ty return type.

nnethercote · nnethercote · commit ec5e96e58b55 · 2025-12-23T07:46:12.000+11:00
It's no longer needed.
diff --git a/compiler/rustc_infer/src/infer/freshen.rs b/compiler/rustc_infer/src/infer/freshen.rs
@@ -120,7 +120,7 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for TypeFreshener<'a, 'tcx> {
             t
         } else {
             match *t.kind() {
-                ty::Infer(v) => self.fold_infer_ty(v).unwrap_or(t),
+                ty::Infer(v) => self.fold_infer_ty(v),
 
                 // This code is hot enough that a non-debug assertion here makes a noticeable
                 // difference on benchmarks like `wg-grammar`.
@@ -168,18 +168,18 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for TypeFreshener<'a, 'tcx> {
 impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
     // This is separate from `fold_ty` to keep that method small and inlinable.
     #[inline(never)]
-    fn fold_infer_ty(&mut self, ty: ty::InferTy) -> Option<Ty<'tcx>> {
+    fn fold_infer_ty(&mut self, ty: ty::InferTy) -> Ty<'tcx> {
         match ty {
             ty::TyVar(v) => {
                 let mut inner = self.infcx.inner.borrow_mut();
                 match inner.type_variables().probe(v).known() {
                     Some(ty) => {
                         drop(inner);
-                        Some(ty.fold_with(self))
+                        ty.fold_with(self)
                     }
                     None => {
                         let input = ty::TyVar(inner.type_variables().root_var(v));
-                        Some(self.freshen_ty(input, |n| Ty::new_fresh(self.infcx.tcx, n)))
+                        self.freshen_ty(input, |n| Ty::new_fresh(self.infcx.tcx, n))
                     }
                 }
             }
@@ -188,11 +188,11 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
                 let mut inner = self.infcx.inner.borrow_mut();
                 let value = inner.int_unification_table().probe_value(v);
                 match value {
-                    ty::IntVarValue::IntType(ty) => Some(Ty::new_int(self.infcx.tcx, ty)),
-                    ty::IntVarValue::UintType(ty) => Some(Ty::new_uint(self.infcx.tcx, ty)),
+                    ty::IntVarValue::IntType(ty) => Ty::new_int(self.infcx.tcx, ty),
+                    ty::IntVarValue::UintType(ty) => Ty::new_uint(self.infcx.tcx, ty),
                     ty::IntVarValue::Unknown => {
                         let input = ty::IntVar(inner.int_unification_table().find(v));
-                        Some(self.freshen_ty(input, |n| Ty::new_fresh_int(self.infcx.tcx, n)))
+                        self.freshen_ty(input, |n| Ty::new_fresh_int(self.infcx.tcx, n))
                     }
                 }
             }
@@ -201,10 +201,10 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
                 let mut inner = self.infcx.inner.borrow_mut();
                 let value = inner.float_unification_table().probe_value(v);
                 match value {
-                    ty::FloatVarValue::Known(ty) => Some(Ty::new_float(self.infcx.tcx, ty)),
+                    ty::FloatVarValue::Known(ty) => Ty::new_float(self.infcx.tcx, ty),
                     ty::FloatVarValue::Unknown => {
                         let input = ty::FloatVar(inner.float_unification_table().find(v));
-                        Some(self.freshen_ty(input, |n| Ty::new_fresh_float(self.infcx.tcx, n)))
+                        self.freshen_ty(input, |n| Ty::new_fresh_float(self.infcx.tcx, n))
                     }
                 }
             }

Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for TypeFreshener<'a, 'tcx> {`
`120`	`120`	`t`
`121`	`121`	`} else {`
`122`	`122`	`match *t.kind() {`
`123`		`- ty::Infer(v) => self.fold_infer_ty(v).unwrap_or(t),`
	`123`	`+ ty::Infer(v) => self.fold_infer_ty(v),`
`124`	`124`
`125`	`125`	`// This code is hot enough that a non-debug assertion here makes a noticeable`
`126`	`126`	// difference on benchmarks like `wg-grammar`.
`@@ -168,18 +168,18 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for TypeFreshener<'a, 'tcx> {`
`168`	`168`	`impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {`
`169`	`169`	// This is separate from `fold_ty` to keep that method small and inlinable.
`170`	`170`	`#[inline(never)]`
`171`		`- fn fold_infer_ty(&mut self, ty: ty::InferTy) -> Option<Ty<'tcx>> {`
	`171`	`+ fn fold_infer_ty(&mut self, ty: ty::InferTy) -> Ty<'tcx> {`
`172`	`172`	`match ty {`
`173`	`173`	`ty::TyVar(v) => {`
`174`	`174`	`let mut inner = self.infcx.inner.borrow_mut();`
`175`	`175`	`match inner.type_variables().probe(v).known() {`
`176`	`176`	`Some(ty) => {`
`177`	`177`	`drop(inner);`
`178`		`- Some(ty.fold_with(self))`
	`178`	`+ ty.fold_with(self)`
`179`	`179`	`}`
`180`	`180`	`None => {`
`181`	`181`	`let input = ty::TyVar(inner.type_variables().root_var(v));`
`182`		`- Some(self.freshen_ty(input, \|n\| Ty::new_fresh(self.infcx.tcx, n)))`
	`182`	`+ self.freshen_ty(input, \|n\| Ty::new_fresh(self.infcx.tcx, n))`
`183`	`183`	`}`
`184`	`184`	`}`
`185`	`185`	`}`
`@@ -188,11 +188,11 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {`
`188`	`188`	`let mut inner = self.infcx.inner.borrow_mut();`
`189`	`189`	`let value = inner.int_unification_table().probe_value(v);`
`190`	`190`	`match value {`
`191`		`- ty::IntVarValue::IntType(ty) => Some(Ty::new_int(self.infcx.tcx, ty)),`
`192`		`- ty::IntVarValue::UintType(ty) => Some(Ty::new_uint(self.infcx.tcx, ty)),`
	`191`	`+ ty::IntVarValue::IntType(ty) => Ty::new_int(self.infcx.tcx, ty),`
	`192`	`+ ty::IntVarValue::UintType(ty) => Ty::new_uint(self.infcx.tcx, ty),`
`193`	`193`	`ty::IntVarValue::Unknown => {`
`194`	`194`	`let input = ty::IntVar(inner.int_unification_table().find(v));`
`195`		`- Some(self.freshen_ty(input, \|n\| Ty::new_fresh_int(self.infcx.tcx, n)))`
	`195`	`+ self.freshen_ty(input, \|n\| Ty::new_fresh_int(self.infcx.tcx, n))`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`	`}`
`@@ -201,10 +201,10 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {`
`201`	`201`	`let mut inner = self.infcx.inner.borrow_mut();`
`202`	`202`	`let value = inner.float_unification_table().probe_value(v);`
`203`	`203`	`match value {`
`204`		`- ty::FloatVarValue::Known(ty) => Some(Ty::new_float(self.infcx.tcx, ty)),`
	`204`	`+ ty::FloatVarValue::Known(ty) => Ty::new_float(self.infcx.tcx, ty),`
`205`	`205`	`ty::FloatVarValue::Unknown => {`
`206`	`206`	`let input = ty::FloatVar(inner.float_unification_table().find(v));`
`207`		`- Some(self.freshen_ty(input, \|n\| Ty::new_fresh_float(self.infcx.tcx, n)))`
	`207`	`+ self.freshen_ty(input, \|n\| Ty::new_fresh_float(self.infcx.tcx, n))`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`	`}`