rename needs_subst to has_param

BoxyUwU · BoxyUwU · commit 842419712a9e · 2023-04-27T08:35:19.000+01:00
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -515,7 +515,7 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                         ty::Adt(def, ..) if !def.is_box() => {
                             // Again, only create type information if full debuginfo is enabled
                             if cx.sess().opts.debuginfo == DebugInfo::Full
-                                && !impl_self_ty.needs_subst()
+                                && !impl_self_ty.has_param()
                             {
                                 Some(type_di_node(cx, impl_self_ty))
                             } else {
diff --git a/compiler/rustc_const_eval/src/interpret/util.rs b/compiler/rustc_const_eval/src/interpret/util.rs
@@ -14,7 +14,7 @@ where
     T: TypeVisitable<TyCtxt<'tcx>>,
 {
     debug!("ensure_monomorphic_enough: ty={:?}", ty);
-    if !ty.needs_subst() {
+    if !ty.has_param() {
         return Ok(());
     }
 
@@ -27,7 +27,7 @@ where
         type BreakTy = FoundParam;
 
         fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
-            if !ty.needs_subst() {
+            if !ty.has_param() {
                 return ControlFlow::Continue(());
             }
 
@@ -46,7 +46,7 @@ where
                         // are used and require substitution.
                         // Just in case there are closures or generators within this subst,
                         // recurse.
-                        if unused_params.is_used(index) && subst.needs_subst() {
+                        if unused_params.is_used(index) && subst.has_param() {
                             return subst.visit_with(self);
                         }
                     }
diff --git a/compiler/rustc_hir_analysis/src/astconv/mod.rs b/compiler/rustc_hir_analysis/src/astconv/mod.rs
@@ -3039,7 +3039,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 // the anon const, which is empty. This is why the
                 // `AlwaysApplicable` impl needs a `T: ?Sized` bound for
                 // this to compile if we were to normalize here.
-                if forbid_generic && ty.needs_subst() {
+                if forbid_generic && ty.has_param() {
                     let mut err = tcx.sess.struct_span_err(
                         path.span,
                         "generic `Self` types are currently not permitted in anonymous constants",
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -1292,7 +1292,7 @@ fn check_where_clauses<'tcx>(wfcx: &WfCheckingCtxt<'_, 'tcx>, span: Span, def_id
                     // Ignore dependent defaults -- that is, where the default of one type
                     // parameter includes another (e.g., `<T, U = T>`). In those cases, we can't
                     // be sure if it will error or not as user might always specify the other.
-                    if !ty.needs_subst() {
+                    if !ty.has_param() {
                         wfcx.register_wf_obligation(
                             tcx.def_span(param.def_id),
                             Some(WellFormedLoc::Ty(param.def_id.expect_local())),
@@ -1308,7 +1308,7 @@ fn check_where_clauses<'tcx>(wfcx: &WfCheckingCtxt<'_, 'tcx>, span: Span, def_id
                     // for `struct Foo<const N: usize, const M: usize = { 1 - 2 }>`
                     // we should eagerly error.
                     let default_ct = tcx.const_param_default(param.def_id).subst_identity();
-                    if !default_ct.needs_subst() {
+                    if !default_ct.has_param() {
                         wfcx.register_wf_obligation(
                             tcx.def_span(param.def_id),
                             None,
@@ -1342,7 +1342,7 @@ fn check_where_clauses<'tcx>(wfcx: &WfCheckingCtxt<'_, 'tcx>, span: Span, def_id
                 if is_our_default(param) {
                     let default_ty = tcx.type_of(param.def_id).subst_identity();
                     // ... and it's not a dependent default, ...
-                    if !default_ty.needs_subst() {
+                    if !default_ty.has_param() {
                         // ... then substitute it with the default.
                         return default_ty.into();
                     }
@@ -1355,7 +1355,7 @@ fn check_where_clauses<'tcx>(wfcx: &WfCheckingCtxt<'_, 'tcx>, span: Span, def_id
                 if is_our_default(param) {
                     let default_ct = tcx.const_param_default(param.def_id).subst_identity();
                     // ... and it's not a dependent default, ...
-                    if !default_ct.needs_subst() {
+                    if !default_ct.has_param() {
                         // ... then substitute it with the default.
                         return default_ct.into();
                     }
diff --git a/compiler/rustc_hir_analysis/src/coherence/orphan.rs b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
@@ -457,7 +457,7 @@ fn emit_newtype_suggestion_for_raw_ptr(
     ptr_ty: &ty::TypeAndMut<'_>,
     diag: &mut Diagnostic,
 ) {
-    if !self_ty.needs_subst() {
+    if !self_ty.has_param() {
         let mut_key = ptr_ty.mutbl.prefix_str();
         let msg_sugg = "consider introducing a new wrapper type".to_owned();
         let sugg = vec![
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -1384,7 +1384,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
         let item_ty = self.tcx.type_of(item.def_id).subst_identity();
         // FIXME(compiler-errors): This check is *so* rudimentary
-        if item_ty.needs_subst() {
+        if item_ty.has_param() {
             return false;
         }
         if self.can_coerce(item_ty, expected_ty) {
diff --git a/compiler/rustc_lint/src/enum_intrinsics_non_enums.rs b/compiler/rustc_lint/src/enum_intrinsics_non_enums.rs
@@ -42,7 +42,7 @@ declare_lint_pass!(EnumIntrinsicsNonEnums => [ENUM_INTRINSICS_NON_ENUMS]);
 /// Returns `true` if we know for sure that the given type is not an enum. Note that for cases where
 /// the type is generic, we can't be certain if it will be an enum so we have to assume that it is.
 fn is_non_enum(t: Ty<'_>) -> bool {
-    !t.is_enum() && !t.needs_subst()
+    !t.is_enum() && !t.has_param()
 }
 
 fn enforce_mem_discriminant(
diff --git a/compiler/rustc_middle/src/ty/subst.rs b/compiler/rustc_middle/src/ty/subst.rs
@@ -761,7 +761,7 @@ impl<'tcx, T: TypeFoldable<TyCtxt<'tcx>>> ty::EarlyBinder<T> {
 
     /// Returns the inner value, but only if it contains no bound vars.
     pub fn no_bound_vars(self) -> Option<T> {
-        if !self.0.needs_subst() { Some(self.0) } else { None }
+        if !self.0.has_param() { Some(self.0) } else { None }
     }
 }
 
@@ -840,7 +840,7 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for SubstFolder<'a, 'tcx> {
     }
 
     fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
-        if !t.needs_subst() {
+        if !t.has_param() {
             return t;
         }
 
diff --git a/compiler/rustc_middle/src/ty/visit.rs b/compiler/rustc_middle/src/ty/visit.rs
@@ -70,7 +70,7 @@ pub trait TypeVisitableExt<'tcx>: TypeVisitable<TyCtxt<'tcx>> {
         }
     }
     fn has_non_region_param(&self) -> bool {
-        self.has_type_flags(TypeFlags::NEEDS_SUBST - TypeFlags::HAS_RE_PARAM)
+        self.has_type_flags(TypeFlags::HAS_PARAM - TypeFlags::HAS_RE_PARAM)
     }
     fn has_infer_regions(&self) -> bool {
         self.has_type_flags(TypeFlags::HAS_RE_INFER)
@@ -94,8 +94,8 @@ pub trait TypeVisitableExt<'tcx>: TypeVisitable<TyCtxt<'tcx>> {
     fn has_non_region_placeholders(&self) -> bool {
         self.has_type_flags(TypeFlags::HAS_TY_PLACEHOLDER | TypeFlags::HAS_CT_PLACEHOLDER)
     }
-    fn needs_subst(&self) -> bool {
-        self.has_type_flags(TypeFlags::NEEDS_SUBST)
+    fn has_param(&self) -> bool {
+        self.has_type_flags(TypeFlags::HAS_PARAM)
     }
     /// "Free" regions in this context means that it has any region
     /// that is not (a) erased or (b) late-bound.
diff --git a/compiler/rustc_mir_transform/src/const_prop.rs b/compiler/rustc_mir_transform/src/const_prop.rs
@@ -428,7 +428,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
     /// Returns the value, if any, of evaluating `c`.
     fn eval_constant(&mut self, c: &Constant<'tcx>) -> Option<OpTy<'tcx>> {
         // FIXME we need to revisit this for #67176
-        if c.needs_subst() {
+        if c.has_param() {
             return None;
         }
 
@@ -527,7 +527,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
         }
 
         // FIXME we need to revisit this for #67176
-        if rvalue.needs_subst() {
+        if rvalue.has_param() {
             return None;
         }
         if !rvalue
diff --git a/compiler/rustc_mir_transform/src/const_prop_lint.rs b/compiler/rustc_mir_transform/src/const_prop_lint.rs
@@ -281,7 +281,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
     /// Returns the value, if any, of evaluating `c`.
     fn eval_constant(&mut self, c: &Constant<'tcx>, location: Location) -> Option<OpTy<'tcx>> {
         // FIXME we need to revisit this for #67176
-        if c.needs_subst() {
+        if c.has_param() {
             return None;
         }
 
@@ -474,7 +474,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
         }
 
         // FIXME we need to revisit this for #67176
-        if rvalue.needs_subst() {
+        if rvalue.has_param() {
             return None;
         }
         if !rvalue.ty(self.local_decls(), self.tcx).is_sized(self.tcx, self.param_env) {
diff --git a/compiler/rustc_mir_transform/src/inline/cycle.rs b/compiler/rustc_mir_transform/src/inline/cycle.rs
@@ -92,7 +92,7 @@ pub(crate) fn mir_callgraph_reachable<'tcx>(
                     // FIXME: A not fully substituted drop shim can cause ICEs if one attempts to
                     // have its MIR built. Likely oli-obk just screwed up the `ParamEnv`s, so this
                     // needs some more analysis.
-                    if callee.needs_subst() {
+                    if callee.has_param() {
                         continue;
                     }
                 }
diff --git a/compiler/rustc_monomorphize/src/partitioning/default.rs b/compiler/rustc_monomorphize/src/partitioning/default.rs
@@ -305,7 +305,7 @@ fn characteristic_def_id_of_mono_item<'tcx>(
 
                 // When polymorphization is enabled, methods which do not depend on their generic
                 // parameters, but the self-type of their impl block do will fail to normalize.
-                if !tcx.sess.opts.unstable_opts.polymorphize || !instance.needs_subst() {
+                if !tcx.sess.opts.unstable_opts.polymorphize || !instance.has_param() {
                     // This is a method within an impl, find out what the self-type is:
                     let impl_self_ty = tcx.subst_and_normalize_erasing_regions(
                         instance.substs,
diff --git a/compiler/rustc_symbol_mangling/src/legacy.rs b/compiler/rustc_symbol_mangling/src/legacy.rs
@@ -108,7 +108,7 @@ fn get_symbol_hash<'tcx>(
             tcx.def_path_hash(def_id).hash_stable(&mut hcx, &mut hasher);
 
             // Include the main item-type. Note that, in this case, the
-            // assertions about `needs_subst` may not hold, but this item-type
+            // assertions about `has_param` may not hold, but this item-type
             // ought to be the same for every reference anyway.
             assert!(!item_type.has_erasable_regions());
             hcx.while_hashing_spans(false, |hcx| {
diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs
@@ -582,7 +582,7 @@ fn orphan_check_trait_ref<'tcx>(
     trait_ref: ty::TraitRef<'tcx>,
     in_crate: InCrate,
 ) -> Result<(), OrphanCheckErr<'tcx>> {
-    if trait_ref.has_infer() && trait_ref.needs_subst() {
+    if trait_ref.has_infer() && trait_ref.has_param() {
         bug!(
             "can't orphan check a trait ref with both params and inference variables {:?}",
             trait_ref
diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs
@@ -414,7 +414,7 @@ fn subst_and_check_impossible_predicates<'tcx>(
         predicates.push(ty::Binder::dummy(trait_ref).to_predicate(tcx));
     }
 
-    predicates.retain(|predicate| !predicate.needs_subst());
+    predicates.retain(|predicate| !predicate.has_param());
     let result = impossible_predicates(tcx, predicates);
 
     debug!("subst_and_check_impossible_predicates(key={:?}) = {:?}", key, result);
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -1000,7 +1000,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     ) -> Result<EvaluationResult, OverflowError> {
         if !self.is_intercrate()
             && obligation.is_global()
-            && obligation.param_env.caller_bounds().iter().all(|bound| bound.needs_subst())
+            && obligation.param_env.caller_bounds().iter().all(|bound| bound.has_param())
         {
             // If a param env has no global bounds, global obligations do not
             // depend on its particular value in order to work, so we can clear
diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs
@@ -179,7 +179,7 @@ bitflags! {
         /// Does this have `ConstKind::Param`?
         const HAS_CT_PARAM                = 1 << 2;
 
-        const NEEDS_SUBST                 = TypeFlags::HAS_TY_PARAM.bits
+        const HAS_PARAM                 = TypeFlags::HAS_TY_PARAM.bits
                                           | TypeFlags::HAS_RE_PARAM.bits
                                           | TypeFlags::HAS_CT_PARAM.bits;
 

Original file line number	Diff line number	Diff line change
`@@ -515,7 +515,7 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {`
`515`	`515`	`ty::Adt(def, ..) if !def.is_box() => {`
`516`	`516`	`// Again, only create type information if full debuginfo is enabled`
`517`	`517`	`if cx.sess().opts.debuginfo == DebugInfo::Full`
`518`		`- && !impl_self_ty.needs_subst()`
	`518`	`+ && !impl_self_ty.has_param()`
`519`	`519`	`{`
`520`	`520`	`Some(type_di_node(cx, impl_self_ty))`
`521`	`521`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ where`
`14`	`14`	`T: TypeVisitable<TyCtxt<'tcx>>,`
`15`	`15`	`{`
`16`	`16`	`debug!("ensure_monomorphic_enough: ty={:?}", ty);`
`17`		`- if !ty.needs_subst() {`
	`17`	`+ if !ty.has_param() {`
`18`	`18`	`return Ok(());`
`19`	`19`	`}`
`20`	`20`
`@@ -27,7 +27,7 @@ where`
`27`	`27`	`type BreakTy = FoundParam;`
`28`	`28`
`29`	`29`	`fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {`
`30`		`- if !ty.needs_subst() {`
	`30`	`+ if !ty.has_param() {`
`31`	`31`	`return ControlFlow::Continue(());`
`32`	`32`	`}`
`33`	`33`
`@@ -46,7 +46,7 @@ where`
`46`	`46`	`// are used and require substitution.`
`47`	`47`	`// Just in case there are closures or generators within this subst,`
`48`	`48`	`// recurse.`
`49`		`- if unused_params.is_used(index) && subst.needs_subst() {`
	`49`	`+ if unused_params.is_used(index) && subst.has_param() {`
`50`	`50`	`return subst.visit_with(self);`
`51`	`51`	`}`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1384,7 +1384,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1384`	`1384`	`}`
`1385`	`1385`	`let item_ty = self.tcx.type_of(item.def_id).subst_identity();`
`1386`	`1386`	`// FIXME(compiler-errors): This check is so rudimentary`
`1387`		`- if item_ty.needs_subst() {`
	`1387`	`+ if item_ty.has_param() {`
`1388`	`1388`	`return false;`
`1389`	`1389`	`}`
`1390`	`1390`	`if self.can_coerce(item_ty, expected_ty) {`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ declare_lint_pass!(EnumIntrinsicsNonEnums => [ENUM_INTRINSICS_NON_ENUMS]);`
`42`	`42`	/// Returns `true` if we know for sure that the given type is not an enum. Note that for cases where
`43`	`43`	`/// the type is generic, we can't be certain if it will be an enum so we have to assume that it is.`
`44`	`44`	`fn is_non_enum(t: Ty<'_>) -> bool {`
`45`		`- !t.is_enum() && !t.needs_subst()`
	`45`	`+ !t.is_enum() && !t.has_param()`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`fn enforce_mem_discriminant(`
Original file line number	Diff line number	Diff line change
`@@ -761,7 +761,7 @@ impl<'tcx, T: TypeFoldable<TyCtxt<'tcx>>> ty::EarlyBinder<T> {`
`761`	`761`
`762`	`762`	`/// Returns the inner value, but only if it contains no bound vars.`
`763`	`763`	`pub fn no_bound_vars(self) -> Option<T> {`
`764`		`- if !self.0.needs_subst() { Some(self.0) } else { None }`
	`764`	`+ if !self.0.has_param() { Some(self.0) } else { None }`
`765`	`765`	`}`
`766`	`766`	`}`
`767`	`767`
`@@ -840,7 +840,7 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for SubstFolder<'a, 'tcx> {`
`840`	`840`	`}`
`841`	`841`
`842`	`842`	`fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {`
`843`		`- if !t.needs_subst() {`
	`843`	`+ if !t.has_param() {`
`844`	`844`	`return t;`
`845`	`845`	`}`
`846`	`846`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ pub trait TypeVisitableExt<'tcx>: TypeVisitable<TyCtxt<'tcx>> {`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`	`fn has_non_region_param(&self) -> bool {`
`73`		`- self.has_type_flags(TypeFlags::NEEDS_SUBST - TypeFlags::HAS_RE_PARAM)`
	`73`	`+ self.has_type_flags(TypeFlags::HAS_PARAM - TypeFlags::HAS_RE_PARAM)`
`74`	`74`	`}`
`75`	`75`	`fn has_infer_regions(&self) -> bool {`
`76`	`76`	`self.has_type_flags(TypeFlags::HAS_RE_INFER)`
`@@ -94,8 +94,8 @@ pub trait TypeVisitableExt<'tcx>: TypeVisitable<TyCtxt<'tcx>> {`
`94`	`94`	`fn has_non_region_placeholders(&self) -> bool {`
`95`	`95`	`self.has_type_flags(TypeFlags::HAS_TY_PLACEHOLDER \| TypeFlags::HAS_CT_PLACEHOLDER)`
`96`	`96`	`}`
`97`		`- fn needs_subst(&self) -> bool {`
`98`		`- self.has_type_flags(TypeFlags::NEEDS_SUBST)`
	`97`	`+ fn has_param(&self) -> bool {`
	`98`	`+ self.has_type_flags(TypeFlags::HAS_PARAM)`
`99`	`99`	`}`
`100`	`100`	`/// "Free" regions in this context means that it has any region`
`101`	`101`	`/// that is not (a) erased or (b) late-bound.`
Original file line number	Diff line number	Diff line change
`@@ -428,7 +428,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {`
`428`	`428`	/// Returns the value, if any, of evaluating `c`.
`429`	`429`	`fn eval_constant(&mut self, c: &Constant<'tcx>) -> Option<OpTy<'tcx>> {`
`430`	`430`	`// FIXME we need to revisit this for #67176`
`431`		`- if c.needs_subst() {`
	`431`	`+ if c.has_param() {`
`432`	`432`	`return None;`
`433`	`433`	`}`
`434`	`434`
`@@ -527,7 +527,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {`
`527`	`527`	`}`
`528`	`528`
`529`	`529`	`// FIXME we need to revisit this for #67176`
`530`		`- if rvalue.needs_subst() {`
	`530`	`+ if rvalue.has_param() {`
`531`	`531`	`return None;`
`532`	`532`	`}`
`533`	`533`	`if !rvalue`
Original file line number	Diff line number	Diff line change
`@@ -281,7 +281,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {`
`281`	`281`	/// Returns the value, if any, of evaluating `c`.
`282`	`282`	`fn eval_constant(&mut self, c: &Constant<'tcx>, location: Location) -> Option<OpTy<'tcx>> {`
`283`	`283`	`// FIXME we need to revisit this for #67176`
`284`		`- if c.needs_subst() {`
	`284`	`+ if c.has_param() {`
`285`	`285`	`return None;`
`286`	`286`	`}`
`287`	`287`
`@@ -474,7 +474,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {`
`474`	`474`	`}`
`475`	`475`
`476`	`476`	`// FIXME we need to revisit this for #67176`
`477`		`- if rvalue.needs_subst() {`
	`477`	`+ if rvalue.has_param() {`
`478`	`478`	`return None;`
`479`	`479`	`}`
`480`	`480`	`if !rvalue.ty(self.local_decls(), self.tcx).is_sized(self.tcx, self.param_env) {`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ pub(crate) fn mir_callgraph_reachable<'tcx>(`
`92`	`92`	`// FIXME: A not fully substituted drop shim can cause ICEs if one attempts to`
`93`	`93`	// have its MIR built. Likely oli-obk just screwed up the `ParamEnv`s, so this
`94`	`94`	`// needs some more analysis.`
`95`		`- if callee.needs_subst() {`
	`95`	`+ if callee.has_param() {`
`96`	`96`	`continue;`
`97`	`97`	`}`
`98`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -414,7 +414,7 @@ fn subst_and_check_impossible_predicates<'tcx>(`
`414`	`414`	`predicates.push(ty::Binder::dummy(trait_ref).to_predicate(tcx));`
`415`	`415`	`}`
`416`	`416`
`417`		`- predicates.retain(\|predicate\| !predicate.needs_subst());`
	`417`	`+ predicates.retain(\|predicate\| !predicate.has_param());`
`418`	`418`	`let result = impossible_predicates(tcx, predicates);`
`419`	`419`
`420`	`420`	`debug!("subst_and_check_impossible_predicates(key={:?}) = {:?}", key, result);`