mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rename needs_subst to has_param

Browse Source
This commit is contained in:
Boxy 2023-04-27 07:52:17 +01:00
parent f04b8fe0af
commit 842419712a
18 changed files with 28 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
View File

@ -515,7 +515,7 @@ fn get_containing_scope<'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 {

6
compiler/rustc_const_eval/src/interpret/util.rs
View File

@ -14,7 +14,7 @@ pub(crate) fn ensure_monomorphic_enough<'tcx, T>(tcx: TyCtxt<'tcx>, ty: T) -> In
T: TypeVisitable<TyCtxt<'tcx>>,
{
debug!("ensure_monomorphic_enough: ty={:?}", ty);
if !ty.needs_subst() {
if !ty.has_param() {
return Ok(());
}
@ -27,7 +27,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for UsedParamsNeedSubstVisitor<'tcx> {
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 @@ fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
// 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);
}
}

2
compiler/rustc_hir_analysis/src/astconv/mod.rs
View File

@ -3039,7 +3039,7 @@ pub fn res_to_ty(
// 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",

8
compiler/rustc_hir_analysis/src/check/wfcheck.rs
View File

@ -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();
}

2
compiler/rustc_hir_analysis/src/coherence/orphan.rs
View File

@ -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![

2
compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
View File

@ -1384,7 +1384,7 @@ pub(crate) fn suggest_associated_const(
}
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) {

2
compiler/rustc_lint/src/enum_intrinsics_non_enums.rs
View File

@ -42,7 +42,7 @@
/// 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(

4
compiler/rustc_middle/src/ty/subst.rs
View File

@ -761,7 +761,7 @@ pub fn subst_identity(self) -> 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 @@ fn region_param_invalid(data: ty::EarlyBoundRegion, other: GenericArgKind<'_>) -
}
fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
if !t.needs_subst() {
if !t.has_param() {
return t;
}

6
compiler/rustc_middle/src/ty/visit.rs
View File

@ -70,7 +70,7 @@ fn error_reported(&self) -> Result<(), ErrorGuaranteed> {
}
}
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 @@ fn has_placeholders(&self) -> bool {
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.

4
compiler/rustc_mir_transform/src/const_prop.rs
View File

@ -428,7 +428,7 @@ fn remove_const(ecx: &mut InterpCx<'mir, 'tcx, ConstPropMachine<'mir, 'tcx>>, lo
/// 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 @@ fn check_rvalue(&mut self, rvalue: &Rvalue<'tcx>) -> Option<()> {
}
// FIXME we need to revisit this for #67176
if rvalue.needs_subst() {
if rvalue.has_param() {
return None;
}
if !rvalue

4
compiler/rustc_mir_transform/src/const_prop_lint.rs
View File

@ -281,7 +281,7 @@ fn use_ecx<F, T>(&mut self, location: Location, f: F) -> Option<T>
/// 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 @@ fn check_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) -> Option<
}
// 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) {

2
compiler/rustc_mir_transform/src/inline/cycle.rs
View File

@ -92,7 +92,7 @@ fn process<'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;
}
}

2
compiler/rustc_monomorphize/src/partitioning/default.rs
View File

@ -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,

2
compiler/rustc_symbol_mangling/src/legacy.rs
View File

@ -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| {

2
compiler/rustc_trait_selection/src/traits/coherence.rs
View File

@ -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

2
compiler/rustc_trait_selection/src/traits/mod.rs
View File

@ -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);

2
compiler/rustc_trait_selection/src/traits/select/mod.rs
View File

@ -1000,7 +1000,7 @@ fn evaluate_trait_predicate_recursively<'o>(
) -> 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

2
compiler/rustc_type_ir/src/lib.rs
View File

@ -179,7 +179,7 @@ pub struct TypeFlags: u32 {
/// 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;