EarlyBinder::new -> EarlyBinder::bind
This commit is contained in:
parent
70e04bd88d
commit
08d149ca85
@ -361,7 +361,7 @@ pub(crate) fn monomorphize<T>(&self, value: T) -> T
|
||||
self.instance.subst_mir_and_normalize_erasing_regions(
|
||||
self.tcx,
|
||||
ty::ParamEnv::reveal_all(),
|
||||
ty::EarlyBinder::new(value),
|
||||
ty::EarlyBinder::bind(value),
|
||||
)
|
||||
}
|
||||
|
||||
|
@ -93,7 +93,7 @@ fn make_mir_scope<'ll, 'tcx>(
|
||||
let callee = cx.tcx.subst_and_normalize_erasing_regions(
|
||||
instance.substs,
|
||||
ty::ParamEnv::reveal_all(),
|
||||
ty::EarlyBinder::new(callee),
|
||||
ty::EarlyBinder::bind(callee),
|
||||
);
|
||||
let callee_fn_abi = cx.fn_abi_of_instance(callee, ty::List::empty());
|
||||
cx.dbg_scope_fn(callee, callee_fn_abi, None)
|
||||
|
@ -111,7 +111,7 @@ pub fn monomorphize<T>(&self, value: T) -> T
|
||||
self.instance.subst_mir_and_normalize_erasing_regions(
|
||||
self.cx.tcx(),
|
||||
ty::ParamEnv::reveal_all(),
|
||||
ty::EarlyBinder::new(value),
|
||||
ty::EarlyBinder::bind(value),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
@ -497,7 +497,7 @@ pub(super) fn subst_from_frame_and_normalize_erasing_regions<T: TypeFoldable<TyC
|
||||
.try_subst_mir_and_normalize_erasing_regions(
|
||||
*self.tcx,
|
||||
self.param_env,
|
||||
ty::EarlyBinder::new(value),
|
||||
ty::EarlyBinder::bind(value),
|
||||
)
|
||||
.map_err(|_| err_inval!(TooGeneric))
|
||||
}
|
||||
|
@ -1278,7 +1278,7 @@ fn add_predicates_for_ast_type_binding(
|
||||
// params (and trait ref's late bound params). This logic is very similar to
|
||||
// `Predicate::subst_supertrait`, and it's no coincidence why.
|
||||
let shifted_output = tcx.shift_bound_var_indices(num_bound_vars, output);
|
||||
let subst_output = ty::EarlyBinder::new(shifted_output).subst(tcx, substs);
|
||||
let subst_output = ty::EarlyBinder::bind(shifted_output).subst(tcx, substs);
|
||||
|
||||
let bound_vars = tcx.late_bound_vars(binding.hir_id);
|
||||
ty::Binder::bind_with_vars(subst_output, bound_vars)
|
||||
|
@ -795,14 +795,14 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
|
||||
})
|
||||
});
|
||||
debug!(%ty);
|
||||
collected_tys.insert(def_id, ty::EarlyBinder::new(ty));
|
||||
collected_tys.insert(def_id, ty::EarlyBinder::bind(ty));
|
||||
}
|
||||
Err(err) => {
|
||||
let reported = tcx.sess.delay_span_bug(
|
||||
return_span,
|
||||
format!("could not fully resolve: {ty} => {err:?}"),
|
||||
);
|
||||
collected_tys.insert(def_id, ty::EarlyBinder::new(tcx.ty_error(reported)));
|
||||
collected_tys.insert(def_id, ty::EarlyBinder::bind(tcx.ty_error(reported)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -128,7 +128,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>(
|
||||
// We don't need to normalize this param-env or anything, since we're only
|
||||
// substituting it with free params, so no additional param-env normalization
|
||||
// can occur on top of what has been done in the param_env query itself.
|
||||
let param_env = ty::EarlyBinder::new(tcx.param_env(adt_def_id))
|
||||
let param_env = ty::EarlyBinder::bind(tcx.param_env(adt_def_id))
|
||||
.subst(tcx, adt_to_impl_substs)
|
||||
.with_constness(tcx.constness(drop_impl_def_id));
|
||||
|
||||
|
@ -1398,7 +1398,7 @@ fn visit_const(&mut self, c: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
|
||||
}
|
||||
let mut param_count = CountParams::default();
|
||||
let has_region = pred.visit_with(&mut param_count).is_break();
|
||||
let substituted_pred = ty::EarlyBinder::new(pred).subst(tcx, substs);
|
||||
let substituted_pred = ty::EarlyBinder::bind(pred).subst(tcx, substs);
|
||||
// Don't check non-defaulted params, dependent defaults (including lifetimes)
|
||||
// or preds with multiple params.
|
||||
if substituted_pred.has_non_region_param() || param_count.params.len() > 1 || has_region
|
||||
|
@ -1124,7 +1124,7 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<ty::PolyFnSig<
|
||||
bug!("unexpected sort of node in fn_sig(): {:?}", x);
|
||||
}
|
||||
};
|
||||
ty::EarlyBinder::new(output)
|
||||
ty::EarlyBinder::bind(output)
|
||||
}
|
||||
|
||||
fn infer_return_ty_for_fn_sig<'tcx>(
|
||||
@ -1312,7 +1312,7 @@ fn impl_trait_ref(
|
||||
check_impl_constness(tcx, impl_.constness, ast_trait_ref),
|
||||
)
|
||||
})
|
||||
.map(ty::EarlyBinder::new)
|
||||
.map(ty::EarlyBinder::bind)
|
||||
}
|
||||
|
||||
fn check_impl_constness(
|
||||
|
@ -86,7 +86,7 @@ pub(super) fn explicit_item_bounds(
|
||||
Some(ty::ImplTraitInTraitData::Trait { opaque_def_id, .. }) => {
|
||||
let item = tcx.hir().get_by_def_id(opaque_def_id.expect_local()).expect_item();
|
||||
let opaque_ty = item.expect_opaque_ty();
|
||||
return ty::EarlyBinder::new(opaque_type_bounds(
|
||||
return ty::EarlyBinder::bind(opaque_type_bounds(
|
||||
tcx,
|
||||
opaque_def_id.expect_local(),
|
||||
opaque_ty.bounds,
|
||||
@ -124,7 +124,7 @@ pub(super) fn explicit_item_bounds(
|
||||
}
|
||||
_ => bug!("item_bounds called on {:?}", def_id),
|
||||
};
|
||||
ty::EarlyBinder::new(bounds)
|
||||
ty::EarlyBinder::bind(bounds)
|
||||
}
|
||||
|
||||
pub(super) fn item_bounds(
|
||||
|
@ -323,7 +323,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<Ty
|
||||
return map[&assoc_item.trait_item_def_id.unwrap()];
|
||||
}
|
||||
Err(_) => {
|
||||
return ty::EarlyBinder::new(tcx.ty_error_with_message(
|
||||
return ty::EarlyBinder::bind(tcx.ty_error_with_message(
|
||||
DUMMY_SP,
|
||||
"Could not collect return position impl trait in trait tys",
|
||||
));
|
||||
@ -497,7 +497,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<Ty
|
||||
bug!("unexpected sort of node in type_of(): {:?}", x);
|
||||
}
|
||||
};
|
||||
ty::EarlyBinder::new(output)
|
||||
ty::EarlyBinder::bind(output)
|
||||
}
|
||||
|
||||
fn infer_placeholder_type<'a>(
|
||||
|
@ -68,7 +68,7 @@ pub(crate) fn explicit_predicates_of(
|
||||
}
|
||||
}
|
||||
|
||||
ty::EarlyBinder::new(required_predicates)
|
||||
ty::EarlyBinder::bind(required_predicates)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
@ -74,7 +74,7 @@ pub(super) fn infer_predicates(
|
||||
if item_required_predicates.len() > item_predicates_len {
|
||||
predicates_added = true;
|
||||
global_inferred_outlives
|
||||
.insert(item_did.to_def_id(), ty::EarlyBinder::new(item_required_predicates));
|
||||
.insert(item_did.to_def_id(), ty::EarlyBinder::bind(item_required_predicates));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -851,7 +851,7 @@ fn get_explicit_item_bounds(
|
||||
} else {
|
||||
tcx.arena.alloc_from_iter(lazy.decode((self, tcx)))
|
||||
};
|
||||
ty::EarlyBinder::new(&*output)
|
||||
ty::EarlyBinder::bind(&*output)
|
||||
}
|
||||
|
||||
fn get_variant(
|
||||
|
@ -1727,7 +1727,7 @@ fn encode_info_for_closure(&mut self, def_id: LocalDefId) {
|
||||
ty::Closure(_, substs) => {
|
||||
let constness = self.tcx.constness(def_id.to_def_id());
|
||||
self.tables.constness.set_some(def_id.to_def_id().index, constness);
|
||||
record!(self.tables.fn_sig[def_id.to_def_id()] <- ty::EarlyBinder::new(substs.as_closure().sig()));
|
||||
record!(self.tables.fn_sig[def_id.to_def_id()] <- ty::EarlyBinder::bind(substs.as_closure().sig()));
|
||||
}
|
||||
|
||||
_ => bug!("closure that is neither generator nor closure"),
|
||||
|
@ -476,7 +476,7 @@ pub fn return_ty(&self) -> Ty<'tcx> {
|
||||
/// Returns the return type; it always return first element from `local_decls` array.
|
||||
#[inline]
|
||||
pub fn bound_return_ty(&self) -> ty::EarlyBinder<Ty<'tcx>> {
|
||||
ty::EarlyBinder::new(self.local_decls[RETURN_PLACE].ty)
|
||||
ty::EarlyBinder::bind(self.local_decls[RETURN_PLACE].ty)
|
||||
}
|
||||
|
||||
/// Gets the location of the terminator for the given block.
|
||||
|
@ -573,7 +573,7 @@ pub fn destructor(self, tcx: TyCtxt<'tcx>) -> Option<Destructor> {
|
||||
/// Due to normalization being eager, this applies even if
|
||||
/// the associated type is behind a pointer (e.g., issue #31299).
|
||||
pub fn sized_constraint(self, tcx: TyCtxt<'tcx>) -> ty::EarlyBinder<&'tcx [Ty<'tcx>]> {
|
||||
ty::EarlyBinder::new(tcx.adt_sized_constraint(self.did()))
|
||||
ty::EarlyBinder::bind(tcx.adt_sized_constraint(self.did()))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -254,5 +254,5 @@ pub fn const_param_default(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBind
|
||||
"`const_param_default` expected a generic parameter with a constant"
|
||||
),
|
||||
};
|
||||
ty::EarlyBinder::new(Const::from_anon_const(tcx, default_def_id))
|
||||
ty::EarlyBinder::bind(Const::from_anon_const(tcx, default_def_id))
|
||||
}
|
||||
|
@ -343,7 +343,7 @@ pub fn instantiate_own(
|
||||
substs: SubstsRef<'tcx>,
|
||||
) -> impl Iterator<Item = (Predicate<'tcx>, Span)> + DoubleEndedIterator + ExactSizeIterator
|
||||
{
|
||||
EarlyBinder::new(self.predicates).subst_iter_copied(tcx, substs)
|
||||
EarlyBinder::bind(self.predicates).subst_iter_copied(tcx, substs)
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip(self, tcx))]
|
||||
@ -358,7 +358,7 @@ fn instantiate_into(
|
||||
}
|
||||
instantiated
|
||||
.predicates
|
||||
.extend(self.predicates.iter().map(|(p, _)| EarlyBinder::new(*p).subst(tcx, substs)));
|
||||
.extend(self.predicates.iter().map(|(p, _)| EarlyBinder::bind(*p).subst(tcx, substs)));
|
||||
instantiated.spans.extend(self.predicates.iter().map(|(_, sp)| *sp));
|
||||
}
|
||||
|
||||
|
@ -158,7 +158,7 @@ pub fn subst(self, tcx: TyCtxt<'tcx>, substs: ty::SubstsRef<'tcx>) -> Self {
|
||||
fn subst_opt(self, tcx: TyCtxt<'tcx>, substs: ty::SubstsRef<'tcx>) -> Option<Self> {
|
||||
match self {
|
||||
Self::ConstIsZero(c) => {
|
||||
let c = ty::EarlyBinder::new(c).subst(tcx, substs);
|
||||
let c = ty::EarlyBinder::bind(c).subst(tcx, substs);
|
||||
let pred = match c.kind().try_to_target_usize(tcx) {
|
||||
Some(0) => Self::True,
|
||||
Some(1..) => Self::False,
|
||||
@ -167,7 +167,7 @@ fn subst_opt(self, tcx: TyCtxt<'tcx>, substs: ty::SubstsRef<'tcx>) -> Option<Sel
|
||||
Some(pred)
|
||||
}
|
||||
Self::GenericType(t) => {
|
||||
Some(ty::EarlyBinder::new(t).subst(tcx, substs).inhabited_predicate(tcx))
|
||||
Some(ty::EarlyBinder::bind(t).subst(tcx, substs).inhabited_predicate(tcx))
|
||||
}
|
||||
Self::And(&[a, b]) => match a.subst_opt(tcx, substs) {
|
||||
None => b.subst_opt(tcx, substs).map(|b| a.and(tcx, b)),
|
||||
|
@ -764,7 +764,7 @@ pub fn subst_supertrait(
|
||||
let shifted_pred =
|
||||
tcx.shift_bound_var_indices(trait_bound_vars.len(), bound_pred.skip_binder());
|
||||
// 2) Self: Bar1<'a, '^0.1> -> T: Bar1<'^0.0, '^0.1>
|
||||
let new = EarlyBinder::new(shifted_pred).subst(tcx, trait_ref.skip_binder().substs);
|
||||
let new = EarlyBinder::bind(shifted_pred).subst(tcx, trait_ref.skip_binder().substs);
|
||||
// 3) ['x] + ['b] -> ['x, 'b]
|
||||
let bound_vars =
|
||||
tcx.mk_bound_variable_kinds_from_iter(trait_bound_vars.iter().chain(pred_bound_vars));
|
||||
|
@ -568,7 +568,7 @@ pub fn state_tys(
|
||||
let layout = tcx.generator_layout(def_id).unwrap();
|
||||
layout.variant_fields.iter().map(move |variant| {
|
||||
variant.iter().map(move |field| {
|
||||
ty::EarlyBinder::new(layout.field_tys[*field].ty).subst(tcx, self.substs)
|
||||
ty::EarlyBinder::bind(layout.field_tys[*field].ty).subst(tcx, self.substs)
|
||||
})
|
||||
})
|
||||
}
|
||||
|
@ -545,7 +545,7 @@ impl<'tcx, T> !TypeFoldable<TyCtxt<'tcx>> for ty::EarlyBinder<T> {}
|
||||
impl<'tcx, T> !TypeVisitable<TyCtxt<'tcx>> for ty::EarlyBinder<T> {}
|
||||
|
||||
impl<T> EarlyBinder<T> {
|
||||
pub fn new(inner: T) -> EarlyBinder<T> {
|
||||
pub fn bind(inner: T) -> EarlyBinder<T> {
|
||||
EarlyBinder(inner)
|
||||
}
|
||||
|
||||
|
@ -709,7 +709,7 @@ pub fn generator_hidden_types(
|
||||
.as_ref()
|
||||
.map_or_else(|| [].iter(), |l| l.field_tys.iter())
|
||||
.filter(|decl| !decl.ignore_for_traits)
|
||||
.map(|decl| ty::EarlyBinder::new(decl.ty))
|
||||
.map(|decl| ty::EarlyBinder::bind(decl.ty))
|
||||
}
|
||||
|
||||
/// Normalizes all opaque types in the given value, replacing them
|
||||
|
@ -96,13 +96,13 @@ fn from_cycle_error(tcx: TyCtxt<'tcx>, cycle: &[QueryInfo<DepKind>]) -> Self {
|
||||
|
||||
impl<'tcx> Value<TyCtxt<'tcx>, DepKind> for ty::EarlyBinder<Ty<'_>> {
|
||||
fn from_cycle_error(tcx: TyCtxt<'tcx>, cycle: &[QueryInfo<DepKind>]) -> Self {
|
||||
ty::EarlyBinder::new(Ty::from_cycle_error(tcx, cycle))
|
||||
ty::EarlyBinder::bind(Ty::from_cycle_error(tcx, cycle))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'tcx> Value<TyCtxt<'tcx>, DepKind> for ty::EarlyBinder<ty::Binder<'_, ty::FnSig<'_>>> {
|
||||
fn from_cycle_error(tcx: TyCtxt<'tcx>, cycle: &[QueryInfo<DepKind>]) -> Self {
|
||||
ty::EarlyBinder::new(ty::Binder::from_cycle_error(tcx, cycle))
|
||||
ty::EarlyBinder::bind(ty::Binder::from_cycle_error(tcx, cycle))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -83,7 +83,7 @@ fn check_bound_args(
|
||||
// If the inner type matches the type bound by `Pointer`
|
||||
if inner_ty == bound_ty {
|
||||
// Do a substitution using the parameters from the callsite
|
||||
let subst_ty = EarlyBinder::new(inner_ty).subst(self.tcx, substs_ref);
|
||||
let subst_ty = EarlyBinder::bind(inner_ty).subst(self.tcx, substs_ref);
|
||||
if let Some((fn_id, fn_substs)) =
|
||||
FunctionItemRefChecker::is_fn_ref(subst_ty)
|
||||
{
|
||||
|
@ -192,7 +192,7 @@ fn try_inlining(
|
||||
let Ok(callee_body) = callsite.callee.try_subst_mir_and_normalize_erasing_regions(
|
||||
self.tcx,
|
||||
self.param_env,
|
||||
ty::EarlyBinder::new(callee_body.clone()),
|
||||
ty::EarlyBinder::bind(callee_body.clone()),
|
||||
) else {
|
||||
return Err("failed to normalize callee body");
|
||||
};
|
||||
@ -455,7 +455,7 @@ fn check_mir_body(
|
||||
// If the place doesn't actually need dropping, treat it like a regular goto.
|
||||
let ty = callsite
|
||||
.callee
|
||||
.subst_mir(self.tcx, ty::EarlyBinder::new(&place.ty(callee_body, tcx).ty));
|
||||
.subst_mir(self.tcx, ty::EarlyBinder::bind(&place.ty(callee_body, tcx).ty));
|
||||
if ty.needs_drop(tcx, self.param_env) && let UnwindAction::Cleanup(unwind) = unwind {
|
||||
work_list.push(unwind);
|
||||
}
|
||||
@ -790,7 +790,7 @@ fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, location: Location
|
||||
// If the place doesn't actually need dropping, treat it like a regular goto.
|
||||
let ty = self
|
||||
.instance
|
||||
.subst_mir(tcx, ty::EarlyBinder::new(&place.ty(self.callee_body, tcx).ty));
|
||||
.subst_mir(tcx, ty::EarlyBinder::bind(&place.ty(self.callee_body, tcx).ty));
|
||||
if ty.needs_drop(tcx, self.param_env) {
|
||||
self.cost += CALL_PENALTY;
|
||||
if let UnwindAction::Cleanup(_) = unwind {
|
||||
@ -801,7 +801,7 @@ fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, location: Location
|
||||
}
|
||||
}
|
||||
TerminatorKind::Call { func: Operand::Constant(ref f), unwind, .. } => {
|
||||
let fn_ty = self.instance.subst_mir(tcx, ty::EarlyBinder::new(&f.literal.ty()));
|
||||
let fn_ty = self.instance.subst_mir(tcx, ty::EarlyBinder::bind(&f.literal.ty()));
|
||||
self.cost += if let ty::FnDef(def_id, _) = *fn_ty.kind() && tcx.is_intrinsic(def_id) {
|
||||
// Don't give intrinsics the extra penalty for calls
|
||||
INSTR_COST
|
||||
|
@ -47,7 +47,7 @@ fn process<'tcx>(
|
||||
let Ok(substs) = caller.try_subst_mir_and_normalize_erasing_regions(
|
||||
tcx,
|
||||
param_env,
|
||||
ty::EarlyBinder::new(substs),
|
||||
ty::EarlyBinder::bind(substs),
|
||||
) else {
|
||||
trace!(?caller, ?param_env, ?substs, "cannot normalize, skipping");
|
||||
continue;
|
||||
|
@ -69,7 +69,7 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceDef<'tcx>) -> Body<'
|
||||
// of this function. Is this intentional?
|
||||
if let Some(ty::Generator(gen_def_id, substs, _)) = ty.map(Ty::kind) {
|
||||
let body = tcx.optimized_mir(*gen_def_id).generator_drop().unwrap();
|
||||
let body = EarlyBinder::new(body.clone()).subst(tcx, substs);
|
||||
let body = EarlyBinder::bind(body.clone()).subst(tcx, substs);
|
||||
debug!("make_shim({:?}) = {:?}", instance, body);
|
||||
return body;
|
||||
}
|
||||
|
@ -677,7 +677,7 @@ pub fn monomorphize<T>(&self, value: T) -> T
|
||||
self.instance.subst_mir_and_normalize_erasing_regions(
|
||||
self.tcx,
|
||||
ty::ParamEnv::reveal_all(),
|
||||
ty::EarlyBinder::new(value),
|
||||
ty::EarlyBinder::bind(value),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
@ -29,12 +29,12 @@ pub(crate) fn dump_closure_profile<'tcx>(tcx: TyCtxt<'tcx>, closure_instance: In
|
||||
let before_feature_tys = tcx.subst_and_normalize_erasing_regions(
|
||||
closure_instance.substs,
|
||||
param_env,
|
||||
ty::EarlyBinder::new(before_feature_tys),
|
||||
ty::EarlyBinder::bind(before_feature_tys),
|
||||
);
|
||||
let after_feature_tys = tcx.subst_and_normalize_erasing_regions(
|
||||
closure_instance.substs,
|
||||
param_env,
|
||||
ty::EarlyBinder::new(after_feature_tys),
|
||||
ty::EarlyBinder::bind(after_feature_tys),
|
||||
);
|
||||
|
||||
let new_size = tcx
|
||||
|
@ -274,7 +274,7 @@ fn print_impl_path(
|
||||
|
||||
let mut param_env = self.tcx.param_env_reveal_all_normalized(impl_def_id);
|
||||
if !substs.is_empty() {
|
||||
param_env = EarlyBinder::new(param_env).subst(self.tcx, substs);
|
||||
param_env = EarlyBinder::bind(param_env).subst(self.tcx, substs);
|
||||
}
|
||||
|
||||
match &mut impl_trait_ref {
|
||||
|
@ -487,7 +487,7 @@ fn visit_const(&mut self, ct: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
|
||||
tcx,
|
||||
ObligationCause::dummy_with_span(*span),
|
||||
param_env,
|
||||
ty::EarlyBinder::new(*pred).subst(tcx, impl_trait_ref.substs),
|
||||
ty::EarlyBinder::bind(*pred).subst(tcx, impl_trait_ref.substs),
|
||||
)
|
||||
})
|
||||
});
|
||||
|
@ -642,7 +642,7 @@ fn receiver_for_self_ty<'tcx>(
|
||||
if param.index == 0 { self_ty.into() } else { tcx.mk_param_from_def(param) }
|
||||
});
|
||||
|
||||
let result = EarlyBinder::new(receiver_ty).subst(tcx, substs);
|
||||
let result = EarlyBinder::bind(receiver_ty).subst(tcx, substs);
|
||||
debug!(
|
||||
"receiver_for_self_ty({:?}, {:?}, {:?}) = {:?}",
|
||||
receiver_ty, self_ty, method_def_id, result
|
||||
|
@ -307,13 +307,13 @@ pub fn dtorck_constraint_for_ty_inner<'tcx>(
|
||||
// there, but that needs some way to handle cycles.
|
||||
constraints
|
||||
.dtorck_types
|
||||
.extend(dtorck_types.iter().map(|t| EarlyBinder::new(*t).subst(tcx, substs)));
|
||||
.extend(dtorck_types.iter().map(|t| EarlyBinder::bind(*t).subst(tcx, substs)));
|
||||
constraints
|
||||
.outlives
|
||||
.extend(outlives.iter().map(|t| EarlyBinder::new(*t).subst(tcx, substs)));
|
||||
.extend(outlives.iter().map(|t| EarlyBinder::bind(*t).subst(tcx, substs)));
|
||||
constraints
|
||||
.overflows
|
||||
.extend(overflows.iter().map(|t| EarlyBinder::new(*t).subst(tcx, substs)));
|
||||
.extend(overflows.iter().map(|t| EarlyBinder::bind(*t).subst(tcx, substs)));
|
||||
}
|
||||
|
||||
// Objects must be alive in order for their destructor
|
||||
|
@ -301,7 +301,7 @@ fn associated_type_for_impl_trait_in_trait(
|
||||
trait_assoc_ty.impl_defaultness(tcx.impl_defaultness(fn_def_id));
|
||||
|
||||
// Copy type_of of the opaque.
|
||||
trait_assoc_ty.type_of(ty::EarlyBinder::new(tcx.mk_opaque(
|
||||
trait_assoc_ty.type_of(ty::EarlyBinder::bind(tcx.mk_opaque(
|
||||
opaque_ty_def_id.to_def_id(),
|
||||
InternalSubsts::identity_for_item(tcx, opaque_ty_def_id),
|
||||
)));
|
||||
|
@ -419,7 +419,7 @@ pub fn thir_abstract_const(
|
||||
|
||||
let root_span = body.exprs[body_id].span;
|
||||
|
||||
Ok(Some(ty::EarlyBinder::new(recurse_build(tcx, body, body_id, root_span)?)))
|
||||
Ok(Some(ty::EarlyBinder::bind(recurse_build(tcx, body, body_id, root_span)?)))
|
||||
}
|
||||
|
||||
pub fn provide(providers: &mut Providers) {
|
||||
|
@ -610,7 +610,7 @@ fn generator_layout<'tcx>(
|
||||
) -> Result<Layout<'tcx>, LayoutError<'tcx>> {
|
||||
use SavedLocalEligibility::*;
|
||||
let tcx = cx.tcx;
|
||||
let subst_field = |ty: Ty<'tcx>| EarlyBinder::new(ty).subst(tcx, substs);
|
||||
let subst_field = |ty: Ty<'tcx>| EarlyBinder::bind(ty).subst(tcx, substs);
|
||||
|
||||
let Some(info) = tcx.generator_layout(def_id) else {
|
||||
return Err(LayoutError::Unknown(ty));
|
||||
|
@ -210,7 +210,7 @@ fn with_query_cache<'tcx>(
|
||||
match subty.kind() {
|
||||
ty::Adt(adt_id, subst) => {
|
||||
for subty in tcx.adt_drop_tys(adt_id.did())? {
|
||||
vec.push(EarlyBinder::new(subty).subst(tcx, subst));
|
||||
vec.push(EarlyBinder::bind(subty).subst(tcx, subst));
|
||||
}
|
||||
}
|
||||
_ => vec.push(subty),
|
||||
|
@ -506,7 +506,7 @@ fn issue33140_self_ty(tcx: TyCtxt<'_>, def_id: DefId) -> Option<EarlyBinder<Ty<'
|
||||
|
||||
if self_ty_matches {
|
||||
debug!("issue33140_self_ty - MATCHES!");
|
||||
Some(EarlyBinder::new(self_ty))
|
||||
Some(EarlyBinder::bind(self_ty))
|
||||
} else {
|
||||
debug!("issue33140_self_ty - non-matching self type");
|
||||
None
|
||||
|
@ -40,7 +40,7 @@ pub(crate) fn get_blanket_impls(&mut self, item_def_id: DefId) -> Vec<Item> {
|
||||
let infcx = cx.tcx.infer_ctxt().build();
|
||||
let substs = infcx.fresh_substs_for_item(DUMMY_SP, item_def_id);
|
||||
let impl_ty = ty.subst(infcx.tcx, substs);
|
||||
let param_env = EarlyBinder::new(param_env).subst(infcx.tcx, substs);
|
||||
let param_env = EarlyBinder::bind(param_env).subst(infcx.tcx, substs);
|
||||
|
||||
let impl_substs = infcx.fresh_substs_for_item(DUMMY_SP, impl_def_id);
|
||||
let impl_trait_ref = trait_ref.subst(infcx.tcx, impl_substs);
|
||||
|
@ -1219,7 +1219,7 @@ fn needless_borrow_impl_arg_position<'tcx>(
|
||||
return false;
|
||||
}
|
||||
|
||||
let predicate = EarlyBinder::new(predicate).subst(cx.tcx, &substs_with_referent_ty);
|
||||
let predicate = EarlyBinder::bind(predicate).subst(cx.tcx, &substs_with_referent_ty);
|
||||
let obligation = Obligation::new(cx.tcx, ObligationCause::dummy(), cx.param_env, predicate);
|
||||
let infcx = cx.tcx.infer_ctxt().build();
|
||||
infcx.predicate_must_hold_modulo_regions(&obligation)
|
||||
|
@ -243,7 +243,7 @@ fn get_ufcs_type_name<'tcx>(cx: &LateContext<'tcx>, method_def_id: DefId, substs
|
||||
| ty::Ref(..)
|
||||
| ty::Slice(_)
|
||||
| ty::Tuple(_) => {
|
||||
format!("<{}>", EarlyBinder::new(ty).subst(cx.tcx, substs))
|
||||
format!("<{}>", EarlyBinder::bind(ty).subst(cx.tcx, substs))
|
||||
},
|
||||
_ => ty.to_string(),
|
||||
}
|
||||
|
@ -241,7 +241,7 @@ fn is_contains_sig(cx: &LateContext<'_>, call_id: HirId, iter_expr: &Expr<'_>) -
|
||||
&& let proj_ty = cx.tcx.mk_projection(iter_item.def_id, substs)
|
||||
&& let Ok(item_ty) = cx.tcx.try_normalize_erasing_regions(cx.param_env, proj_ty)
|
||||
{
|
||||
item_ty == EarlyBinder::new(search_ty).subst(cx.tcx, cx.typeck_results().node_substs(call_id))
|
||||
item_ty == EarlyBinder::bind(search_ty).subst(cx.tcx, cx.typeck_results().node_substs(call_id))
|
||||
} else {
|
||||
false
|
||||
}
|
||||
|
@ -428,7 +428,7 @@ fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<
|
||||
}));
|
||||
|
||||
if trait_predicates.any(|predicate| {
|
||||
let predicate = EarlyBinder::new(predicate).subst(cx.tcx, new_subst);
|
||||
let predicate = EarlyBinder::bind(predicate).subst(cx.tcx, new_subst);
|
||||
let obligation = Obligation::new(cx.tcx, ObligationCause::dummy(), cx.param_env, predicate);
|
||||
!cx.tcx.infer_ctxt().build().predicate_must_hold_modulo_regions(&obligation)
|
||||
}) {
|
||||
@ -438,7 +438,7 @@ fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<
|
||||
let output_ty = fn_sig.output();
|
||||
if output_ty.contains(*param_ty) {
|
||||
if let Ok(new_ty) = cx.tcx.try_subst_and_normalize_erasing_regions(
|
||||
new_subst, cx.param_env, EarlyBinder::new(output_ty)) {
|
||||
new_subst, cx.param_env, EarlyBinder::bind(output_ty)) {
|
||||
expr = parent_expr;
|
||||
ty = new_ty;
|
||||
continue;
|
||||
|
@ -462,7 +462,7 @@ fn fetch_path(&mut self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>) -> Option<C
|
||||
let substs = if self.substs.is_empty() {
|
||||
substs
|
||||
} else {
|
||||
EarlyBinder::new(substs).subst(self.lcx.tcx, self.substs)
|
||||
EarlyBinder::bind(substs).subst(self.lcx.tcx, self.substs)
|
||||
};
|
||||
|
||||
let result = self
|
||||
|
Loading…
Reference in New Issue
Block a user