Skip to content

Commit 8694b09

Browse files
committed
Do not erase late bound regions, replace them with placeholders
1 parent fe3038f commit 8694b09

File tree

3 files changed

+98
-115
lines changed

3 files changed

+98
-115
lines changed

compiler/rustc_hir_analysis/src/astconv/mod.rs

+88-114
Original file line numberDiff line numberDiff line change
@@ -40,7 +40,6 @@ use rustc_span::{sym, BytePos, Span, DUMMY_SP};
4040
use rustc_target::spec::abi;
4141
use rustc_trait_selection::traits::wf::object_region_bounds;
4242
use rustc_trait_selection::traits::{self, NormalizeExt, ObligationCtxt};
43-
use rustc_type_ir::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
4443

4544
use std::fmt::Display;
4645
use std::slice;
@@ -1609,130 +1608,105 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
16091608
let cause = ObligationCause::misc(span, block.owner.def_id);
16101609

16111610
let mut fulfillment_errors = Vec::new();
1612-
let mut applicable_candidates: Vec<_> = infcx.probe(|_| {
1613-
// Regions are not considered during selection.
1614-
let self_ty = self_ty
1615-
.fold_with(&mut BoundVarEraser { tcx, universe: infcx.create_next_universe() });
1616-
1617-
struct BoundVarEraser<'tcx> {
1618-
tcx: TyCtxt<'tcx>,
1619-
universe: ty::UniverseIndex,
1620-
}
1621-
1622-
// FIXME(non_lifetime_binders): Don't assign the same universe to each placeholder.
1623-
impl<'tcx> TypeFolder<TyCtxt<'tcx>> for BoundVarEraser<'tcx> {
1624-
fn interner(&self) -> TyCtxt<'tcx> {
1625-
self.tcx
1626-
}
1627-
1628-
fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
1629-
// FIXME(@lcnr): This is broken, erasing bound regions
1630-
// impacts selection as it results in different types.
1631-
if r.is_bound() { self.tcx.lifetimes.re_erased } else { r }
1632-
}
1633-
1634-
fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
1635-
match *ty.kind() {
1636-
ty::Bound(_, bv) => Ty::new_placeholder(
1637-
self.tcx,
1638-
ty::PlaceholderType { universe: self.universe, bound: bv },
1639-
),
1640-
_ => ty.super_fold_with(self),
1641-
}
1642-
}
1643-
1644-
fn fold_const(
1645-
&mut self,
1646-
ct: ty::Const<'tcx>,
1647-
) -> <TyCtxt<'tcx> as rustc_type_ir::Interner>::Const {
1648-
assert!(!ct.ty().has_escaping_bound_vars());
1649-
1650-
match ct.kind() {
1651-
ty::ConstKind::Bound(_, bv) => ty::Const::new_placeholder(
1652-
self.tcx,
1653-
ty::PlaceholderConst { universe: self.universe, bound: bv },
1654-
ct.ty(),
1655-
),
1656-
_ => ct.super_fold_with(self),
1657-
}
1658-
}
1659-
}
1611+
let mut universes = if self_ty.has_escaping_bound_vars() {
1612+
vec![None; self_ty.outer_exclusive_binder().as_usize()]
1613+
} else {
1614+
vec![]
1615+
};
16601616

1661-
let InferOk { value: self_ty, obligations } =
1662-
infcx.at(&cause, param_env).normalize(self_ty);
1617+
crate::traits::project::with_replaced_escaping_bound_vars(
1618+
infcx,
1619+
&mut universes,
1620+
self_ty,
1621+
|self_ty| {
1622+
let InferOk { value: self_ty, obligations } =
1623+
infcx.at(&cause, param_env).normalize(self_ty);
16631624

1664-
candidates
1665-
.iter()
1666-
.copied()
1667-
.filter(|&(impl_, _)| {
1668-
infcx.probe(|_| {
1669-
let ocx = ObligationCtxt::new(infcx);
1670-
ocx.register_obligations(obligations.clone());
1671-
1672-
let impl_args = infcx.fresh_args_for_item(span, impl_);
1673-
let impl_ty = tcx.type_of(impl_).instantiate(tcx, impl_args);
1674-
let impl_ty = ocx.normalize(&cause, param_env, impl_ty);
1675-
1676-
// Check that the self types can be related.
1677-
if ocx.eq(&ObligationCause::dummy(), param_env, impl_ty, self_ty).is_err() {
1678-
return false;
1679-
}
1625+
let mut applicable_candidates: Vec<_> = candidates
1626+
.iter()
1627+
.copied()
1628+
.filter(|&(impl_, _)| {
1629+
infcx.probe(|_| {
1630+
let ocx = ObligationCtxt::new(infcx);
1631+
ocx.register_obligations(obligations.clone());
1632+
1633+
let impl_args = infcx.fresh_args_for_item(span, impl_);
1634+
let impl_ty = tcx.type_of(impl_).instantiate(tcx, impl_args);
1635+
let impl_ty = ocx.normalize(&cause, param_env, impl_ty);
1636+
1637+
// Check that the self types can be related.
1638+
if ocx
1639+
.eq(&ObligationCause::dummy(), param_env, impl_ty, self_ty)
1640+
.is_err()
1641+
{
1642+
return false;
1643+
}
16801644

1681-
// Check whether the impl imposes obligations we have to worry about.
1682-
let impl_bounds = tcx.predicates_of(impl_).instantiate(tcx, impl_args);
1683-
let impl_bounds = ocx.normalize(&cause, param_env, impl_bounds);
1684-
let impl_obligations = traits::predicates_for_generics(
1685-
|_, _| cause.clone(),
1686-
param_env,
1687-
impl_bounds,
1688-
);
1689-
ocx.register_obligations(impl_obligations);
1645+
// Check whether the impl imposes obligations we have to worry about.
1646+
let impl_bounds = tcx.predicates_of(impl_).instantiate(tcx, impl_args);
1647+
let impl_bounds = ocx.normalize(&cause, param_env, impl_bounds);
1648+
let impl_obligations = traits::predicates_for_generics(
1649+
|_, _| cause.clone(),
1650+
param_env,
1651+
impl_bounds,
1652+
);
1653+
ocx.register_obligations(impl_obligations);
16901654

1691-
let mut errors = ocx.select_where_possible();
1692-
if !errors.is_empty() {
1693-
fulfillment_errors.append(&mut errors);
1694-
return false;
1695-
}
1655+
let mut errors = ocx.select_where_possible();
1656+
if !errors.is_empty() {
1657+
fulfillment_errors.append(&mut errors);
1658+
return false;
1659+
}
16961660

1697-
true
1661+
true
1662+
})
16981663
})
1699-
})
1700-
.collect()
1701-
});
1664+
.collect();
17021665

1703-
if applicable_candidates.len() > 1 {
1704-
return Err(self.complain_about_ambiguous_inherent_assoc_type(
1705-
name,
1706-
applicable_candidates.into_iter().map(|(_, (candidate, _))| candidate).collect(),
1707-
span,
1708-
));
1709-
}
1666+
if applicable_candidates.len() > 1 {
1667+
return Err(self.complain_about_ambiguous_inherent_assoc_type(
1668+
name,
1669+
applicable_candidates
1670+
.into_iter()
1671+
.map(|(_, (candidate, _))| candidate)
1672+
.collect(),
1673+
span,
1674+
));
1675+
}
17101676

1711-
if let Some((impl_, (assoc_item, def_scope))) = applicable_candidates.pop() {
1712-
self.check_assoc_ty(assoc_item, name, def_scope, block, span);
1713-
1714-
// FIXME(fmease): Currently creating throwaway `parent_args` to please
1715-
// `create_args_for_associated_item`. Modify the latter instead (or sth. similar) to
1716-
// not require the parent args logic.
1717-
let parent_args = ty::GenericArgs::identity_for_item(tcx, impl_);
1718-
let args = self.create_args_for_associated_item(span, assoc_item, segment, parent_args);
1719-
let args = tcx.mk_args_from_iter(
1720-
std::iter::once(ty::GenericArg::from(self_ty))
1721-
.chain(args.into_iter().skip(parent_args.len())),
1722-
);
1677+
if let Some((impl_, (assoc_item, def_scope))) = applicable_candidates.pop() {
1678+
self.check_assoc_ty(assoc_item, name, def_scope, block, span);
17231679

1724-
let ty = Ty::new_alias(tcx, ty::Inherent, ty::AliasTy::new(tcx, assoc_item, args));
1680+
// FIXME(fmease): Currently creating throwaway `parent_args` to please
1681+
// `create_args_for_associated_item`. Modify the latter instead (or sth. similar) to
1682+
// not require the parent args logic.
1683+
let parent_args = ty::GenericArgs::identity_for_item(tcx, impl_);
1684+
let args = self.create_args_for_associated_item(
1685+
span,
1686+
assoc_item,
1687+
segment,
1688+
parent_args,
1689+
);
1690+
let args = tcx.mk_args_from_iter(
1691+
std::iter::once(ty::GenericArg::from(self_ty))
1692+
.chain(args.into_iter().skip(parent_args.len())),
1693+
);
17251694

1726-
return Ok(Some((ty, assoc_item)));
1727-
}
1695+
let ty =
1696+
Ty::new_alias(tcx, ty::Inherent, ty::AliasTy::new(tcx, assoc_item, args));
17281697

1729-
Err(self.complain_about_inherent_assoc_type_not_found(
1730-
name,
1731-
self_ty,
1732-
candidates,
1733-
fulfillment_errors,
1734-
span,
1735-
))
1698+
return Ok(Some((ty, assoc_item)));
1699+
}
1700+
1701+
Err(self.complain_about_inherent_assoc_type_not_found(
1702+
name,
1703+
self_ty,
1704+
candidates,
1705+
fulfillment_errors,
1706+
span,
1707+
))
1708+
},
1709+
)
17361710
}
17371711

17381712
fn lookup_assoc_ty(

tests/ui/associated-inherent-types/issue-111404-1.rs

+1
Original file line numberDiff line numberDiff line change
@@ -9,5 +9,6 @@ impl<'a> Foo<fn(&'a ())> {
99

1010
fn bar(_: fn(Foo<for<'b> fn(Foo<fn(&'b ())>::Assoc)>::Assoc)) {}
1111
//~^ ERROR higher-ranked subtype error
12+
//~| ERROR higher-ranked subtype error
1213

1314
fn main() {}

tests/ui/associated-inherent-types/issue-111404-1.stderr

+9-1
Original file line numberDiff line numberDiff line change
@@ -4,5 +4,13 @@ error: higher-ranked subtype error
44
LL | fn bar(_: fn(Foo<for<'b> fn(Foo<fn(&'b ())>::Assoc)>::Assoc)) {}
55
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
66

7-
error: aborting due to 1 previous error
7+
error: higher-ranked subtype error
8+
--> $DIR/issue-111404-1.rs:10:1
9+
|
10+
LL | fn bar(_: fn(Foo<for<'b> fn(Foo<fn(&'b ())>::Assoc)>::Assoc)) {}
11+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
12+
|
13+
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
14+
15+
error: aborting due to 2 previous errors
816

0 commit comments

Comments
 (0)