Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

some further small cleanups #85033

Merged
merged 2 commits into from
May 7, 2021
Merged

some further small cleanups #85033

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
3c3cf08
wfcheck fcx <-> tcx cleanup
lcnr May 7, 2021
e00146f
fulfillment typo
lcnr May 7, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -720,11 +720,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
pub(in super::super) fn select_obligations_where_possible(
&self,
fallback_has_occurred: bool,
mutate_fullfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
mutate_fulfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
) {
let result = self.fulfillment_cx.borrow_mut().select_where_possible(self);
if let Err(mut errors) = result {
mutate_fullfillment_errors(&mut errors);
mutate_fulfillment_errors(&mut errors);
self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
}
}
Expand Down
2 changes: 1 addition & 1 deletion compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -986,7 +986,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
error.obligation.predicate.kind().skip_binder()
{
// If any of the type arguments in this path segment caused the
// `FullfillmentError`, point at its span (#61860).
// `FulfillmentError`, point at its span (#61860).
for arg in path
.segments
.iter()
Expand Down
98 changes: 44 additions & 54 deletions compiler/rustc_typeck/src/check/wfcheck.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -43,7 +43,7 @@ struct CheckWfFcxBuilder<'tcx> {
impl<'tcx> CheckWfFcxBuilder<'tcx> {
fn with_fcx<F>(&mut self, f: F)
where
F: for<'b> FnOnce(&FnCtxt<'b, 'tcx>, TyCtxt<'tcx>) -> Vec<Ty<'tcx>>,
F: for<'b> FnOnce(&FnCtxt<'b, 'tcx>) -> Vec<Ty<'tcx>>,
{
let id = self.id;
let span = self.span;
Expand All @@ -56,7 +56,7 @@ impl<'tcx> CheckWfFcxBuilder<'tcx> {
// empty `param_env`.
check_false_global_bounds(&fcx, span, id);
}
let wf_tys = f(&fcx, fcx.tcx);
let wf_tys = f(&fcx);
fcx.select_all_obligations_or_error();
fcx.regionck_item(id, span, &wf_tys);
});
Expand Down Expand Up @@ -388,7 +388,7 @@ fn check_associated_item(
debug!("check_associated_item: {:?}", item_id);

let code = ObligationCauseCode::MiscObligation;
for_id(tcx, item_id, span).with_fcx(|fcx, tcx| {
for_id(tcx, item_id, span).with_fcx(|fcx| {
let item = fcx.tcx.associated_item(fcx.tcx.hir().local_def_id(item_id));

let (mut implied_bounds, self_ty) = match item.container {
Expand All @@ -409,7 +409,6 @@ fn check_associated_item(
let sig = fcx.normalize_associated_types_in(span, sig);
let hir_sig = sig_if_method.expect("bad signature for method");
check_fn_or_method(
tcx,
fcx,
item.ident.span,
sig,
Expand Down Expand Up @@ -467,25 +466,24 @@ fn check_type_defn<'tcx, F>(
) where
F: for<'fcx> FnMut(&FnCtxt<'fcx, 'tcx>) -> Vec<AdtVariant<'tcx>>,
{
for_item(tcx, item).with_fcx(|fcx, fcx_tcx| {
for_item(tcx, item).with_fcx(|fcx| {
let variants = lookup_fields(fcx);
let packed = fcx.tcx.adt_def(item.def_id).repr.packed();
let packed = tcx.adt_def(item.def_id).repr.packed();

for variant in &variants {
// For DST, or when drop needs to copy things around, all
// intermediate types must be sized.
let needs_drop_copy = || {
packed && {
let ty = variant.fields.last().unwrap().ty;
let ty = fcx.tcx.erase_regions(ty);
let ty = tcx.erase_regions(ty);
if ty.needs_infer() {
fcx_tcx
.sess
tcx.sess
.delay_span_bug(item.span, &format!("inference variables in {:?}", ty));
// Just treat unresolved type expression as if it needs drop.
true
} else {
ty.needs_drop(fcx_tcx, fcx_tcx.param_env(item.def_id))
ty.needs_drop(tcx, tcx.param_env(item.def_id))
}
}
};
Expand All @@ -497,7 +495,7 @@ fn check_type_defn<'tcx, F>(
let last = idx == variant.fields.len() - 1;
fcx.register_bound(
field.ty,
fcx.tcx.require_lang_item(LangItem::Sized, None),
tcx.require_lang_item(LangItem::Sized, None),
traits::ObligationCause::new(
field.span,
fcx.body_id,
Expand All @@ -524,11 +522,10 @@ fn check_type_defn<'tcx, F>(

// Explicit `enum` discriminant values must const-evaluate successfully.
if let Some(discr_def_id) = variant.explicit_discr {
let discr_substs =
InternalSubsts::identity_for_item(fcx.tcx, discr_def_id.to_def_id());
let discr_substs = InternalSubsts::identity_for_item(tcx, discr_def_id.to_def_id());

let cause = traits::ObligationCause::new(
fcx.tcx.def_span(discr_def_id),
tcx.def_span(discr_def_id),
fcx.body_id,
traits::MiscObligation,
);
Expand All @@ -539,12 +536,12 @@ fn check_type_defn<'tcx, F>(
ty::WithOptConstParam::unknown(discr_def_id.to_def_id()),
discr_substs,
)
.to_predicate(fcx.tcx),
.to_predicate(tcx),
));
}
}

check_where_clauses(tcx, fcx, item.span, item.def_id.to_def_id(), None);
check_where_clauses(fcx, item.span, item.def_id.to_def_id(), None);

// No implied bounds in a struct definition.
vec![]
Expand All @@ -569,8 +566,9 @@ fn check_trait(tcx: TyCtxt<'_>, item: &hir::Item<'_>) {
}
}

for_item(tcx, item).with_fcx(|fcx, _| {
check_where_clauses(tcx, fcx, item.span, item.def_id.to_def_id(), None);
// FIXME: this shouldn't use an `FnCtxt` at all.
for_item(tcx, item).with_fcx(|fcx| {
check_where_clauses(fcx, item.span, item.def_id.to_def_id(), None);

vec![]
});
Expand Down Expand Up @@ -610,28 +608,20 @@ fn check_item_fn(
span: Span,
decl: &hir::FnDecl<'_>,
) {
for_id(tcx, item_id, span).with_fcx(|fcx, tcx| {
let def_id = fcx.tcx.hir().local_def_id(item_id);
let sig = fcx.tcx.fn_sig(def_id);
for_id(tcx, item_id, span).with_fcx(|fcx| {
let def_id = tcx.hir().local_def_id(item_id);
let sig = tcx.fn_sig(def_id);
let sig = fcx.normalize_associated_types_in(span, sig);
let mut implied_bounds = vec![];
check_fn_or_method(
tcx,
fcx,
ident.span,
sig,
decl,
def_id.to_def_id(),
&mut implied_bounds,
);
check_fn_or_method(fcx, ident.span, sig, decl, def_id.to_def_id(), &mut implied_bounds);
implied_bounds
})
}

fn check_item_type(tcx: TyCtxt<'_>, item_id: hir::HirId, ty_span: Span, allow_foreign_ty: bool) {
debug!("check_item_type: {:?}", item_id);

for_id(tcx, item_id, ty_span).with_fcx(|fcx, tcx| {
for_id(tcx, item_id, ty_span).with_fcx(|fcx| {
let ty = tcx.type_of(tcx.hir().local_def_id(item_id));
let item_ty = fcx.normalize_associated_types_in(ty_span, ty);

Expand All @@ -647,7 +637,7 @@ fn check_item_type(tcx: TyCtxt<'_>, item_id: hir::HirId, ty_span: Span, allow_fo
if forbid_unsized {
fcx.register_bound(
item_ty,
fcx.tcx.require_lang_item(LangItem::Sized, None),
tcx.require_lang_item(LangItem::Sized, None),
traits::ObligationCause::new(ty_span, fcx.body_id, traits::MiscObligation),
);
}
Expand All @@ -665,13 +655,13 @@ fn check_impl<'tcx>(
) {
debug!("check_impl: {:?}", item);

for_item(tcx, item).with_fcx(|fcx, tcx| {
for_item(tcx, item).with_fcx(|fcx| {
match *ast_trait_ref {
Some(ref ast_trait_ref) => {
// `#[rustc_reservation_impl]` impls are not real impls and
// therefore don't need to be WF (the trait's `Self: Trait` predicate
// won't hold).
let trait_ref = fcx.tcx.impl_trait_ref(item.def_id).unwrap();
let trait_ref = tcx.impl_trait_ref(item.def_id).unwrap();
let trait_ref =
fcx.normalize_associated_types_in(ast_trait_ref.path.span, trait_ref);
let obligations = traits::wf::trait_obligations(
Expand All @@ -687,7 +677,7 @@ fn check_impl<'tcx>(
}
}
None => {
let self_ty = fcx.tcx.type_of(item.def_id);
let self_ty = tcx.type_of(item.def_id);
let self_ty = fcx.normalize_associated_types_in(item.span, self_ty);
fcx.register_wf_obligation(
self_ty.into(),
Expand All @@ -697,23 +687,23 @@ fn check_impl<'tcx>(
}
}

check_where_clauses(tcx, fcx, item.span, item.def_id.to_def_id(), None);
check_where_clauses(fcx, item.span, item.def_id.to_def_id(), None);

fcx.impl_implied_bounds(item.def_id.to_def_id(), item.span)
});
}

/// Checks where-clauses and inline bounds that are declared on `def_id`.
fn check_where_clauses<'tcx, 'fcx>(
tcx: TyCtxt<'tcx>,
fcx: &FnCtxt<'fcx, 'tcx>,
span: Span,
def_id: DefId,
return_ty: Option<(Ty<'tcx>, Span)>,
) {
debug!("check_where_clauses(def_id={:?}, return_ty={:?})", def_id, return_ty);
let tcx = fcx.tcx;

let predicates = fcx.tcx.predicates_of(def_id);
let predicates = tcx.predicates_of(def_id);
let generics = tcx.generics_of(def_id);

let is_our_default = |def: &ty::GenericParamDef| match def.kind {
Expand All @@ -734,14 +724,14 @@ fn check_where_clauses<'tcx, 'fcx>(
match param.kind {
GenericParamDefKind::Type { .. } => {
if is_our_default(&param) {
let ty = fcx.tcx.type_of(param.def_id);
let ty = tcx.type_of(param.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() {
fcx.register_wf_obligation(
ty.into(),
fcx.tcx.def_span(param.def_id),
tcx.def_span(param.def_id),
ObligationCauseCode::MiscObligation,
);
}
Expand All @@ -754,7 +744,7 @@ fn check_where_clauses<'tcx, 'fcx>(
let default_ct = tcx.const_param_default(param.def_id);
fcx.register_wf_obligation(
default_ct.into(),
fcx.tcx.def_span(param.def_id),
tcx.def_span(param.def_id),
ObligationCauseCode::MiscObligation,
);
}
Expand All @@ -772,25 +762,25 @@ fn check_where_clauses<'tcx, 'fcx>(
// For more examples see tests `defaults-well-formedness.rs` and `type-check-defaults.rs`.
//
// First we build the defaulted substitution.
let substs = InternalSubsts::for_item(fcx.tcx, def_id, |param, _| {
let substs = InternalSubsts::for_item(tcx, def_id, |param, _| {
match param.kind {
GenericParamDefKind::Lifetime => {
// All regions are identity.
fcx.tcx.mk_param_from_def(param)
tcx.mk_param_from_def(param)
}

GenericParamDefKind::Type { .. } => {
// If the param has a default, ...
if is_our_default(param) {
let default_ty = fcx.tcx.type_of(param.def_id);
let default_ty = tcx.type_of(param.def_id);
// ... and it's not a dependent default, ...
if !default_ty.needs_subst() {
// ... then substitute it with the default.
return default_ty.into();
}
}

fcx.tcx.mk_param_from_def(param)
tcx.mk_param_from_def(param)
}
GenericParamDefKind::Const { .. } => {
// FIXME(const_generics_defaults): I(@lcnr) feel like always
Expand All @@ -811,7 +801,7 @@ fn check_where_clauses<'tcx, 'fcx>(
}
}

fcx.tcx.mk_param_from_def(param)
tcx.mk_param_from_def(param)
}
}
});
Expand Down Expand Up @@ -848,7 +838,7 @@ fn check_where_clauses<'tcx, 'fcx>(
}
let mut param_count = CountParams::default();
let has_region = pred.visit_with(&mut param_count).is_break();
let substituted_pred = pred.subst(fcx.tcx, substs);
let substituted_pred = pred.subst(tcx, substs);
// Don't check non-defaulted params, dependent defaults (including lifetimes)
// or preds with multiple params.
if substituted_pred.has_param_types_or_consts()
Expand Down Expand Up @@ -879,14 +869,14 @@ fn check_where_clauses<'tcx, 'fcx>(
traits::Obligation::new(cause, fcx.param_env, pred)
});

let predicates = predicates.instantiate_identity(fcx.tcx);
let predicates = predicates.instantiate_identity(tcx);

if let Some((mut return_ty, span)) = return_ty {
if return_ty.has_infer_types_or_consts() {
fcx.select_obligations_where_possible(false, |_| {});
return_ty = fcx.resolve_vars_if_possible(return_ty);
}
check_opaque_types(tcx, fcx, def_id.expect_local(), span, return_ty);
check_opaque_types(fcx, def_id.expect_local(), span, return_ty);
}

let predicates = fcx.normalize_associated_types_in(span, predicates);
Expand All @@ -905,7 +895,6 @@ fn check_where_clauses<'tcx, 'fcx>(
}

fn check_fn_or_method<'fcx, 'tcx>(
tcx: TyCtxt<'tcx>,
fcx: &FnCtxt<'fcx, 'tcx>,
span: Span,
sig: ty::PolyFnSig<'tcx>,
Expand All @@ -930,7 +919,7 @@ fn check_fn_or_method<'fcx, 'tcx>(
// FIXME(#25759) return types should not be implied bounds
implied_bounds.push(sig.output());

check_where_clauses(tcx, fcx, span, def_id, Some((sig.output(), hir_decl.output.span())));
check_where_clauses(fcx, span, def_id, Some((sig.output(), hir_decl.output.span())));
}

/// Checks "defining uses" of opaque `impl Trait` types to ensure that they meet the restrictions
Expand All @@ -953,15 +942,16 @@ fn check_fn_or_method<'fcx, 'tcx>(
/// ```
///
fn check_opaque_types<'fcx, 'tcx>(
tcx: TyCtxt<'tcx>,
fcx: &FnCtxt<'fcx, 'tcx>,
fn_def_id: LocalDefId,
span: Span,
ty: Ty<'tcx>,
) {
trace!("check_opaque_types(ty={:?})", ty);
trace!("check_opaque_types(fn_def_id={:?}, ty={:?})", fn_def_id, ty);
let tcx = fcx.tcx;

ty.fold_with(&mut ty::fold::BottomUpFolder {
tcx: fcx.tcx,
tcx,
ty_op: |ty| {
if let ty::Opaque(def_id, substs) = *ty.kind() {
trace!("check_opaque_types: opaque_ty, {:?}, {:?}", def_id, substs);
Expand Down