Skip to content

Commit 7fe6f36

Browse files
borsbors
committed
Auto merge of #103491 - cjgillot:self-rpit, r=oli-obk
Support using `Self` or projections inside an RPIT/async fn I reuse the same idea as #103449 to use variances to encode whether a lifetime parameter is captured by impl-trait. The current implementation of async and RPIT replace all lifetimes from the parent generics by `'static`. This PR changes the scheme ```rust impl<'a> Foo<'a> { fn foo<'b, T>() -> impl Into<Self> + 'b { ... } } opaque Foo::<'_a>::foo::<'_b, T>::opaque<'b>: Into<Foo<'_a>> + 'b; impl<'a> Foo<'a> { // OLD fn foo<'b, T>() -> Foo::<'static>::foo::<'static, T>::opaque::<'b> { ... } ^^^^^^^ the `Self` becomes `Foo<'static>` // NEW fn foo<'b, T>() -> Foo::<'a>::foo::<'b, T>::opaque::<'b> { ... } ^^ the `Self` stays `Foo<'a>` } ``` There is the same issue with projections. In the example, substitute `Self` by `<T as Trait<'b>>::Assoc` in the sugared version, and `Foo<'_a>` by `<T as Trait<'_b>>::Assoc` in the desugared one. This allows to support `Self` in impl-trait, since we do not replace lifetimes by `'static` any more. The same trick allows to use projections like `T::Assoc` where `Self` is allowed. The feature is gated behind a `impl_trait_projections` feature gate. The implementation relies on 2 tweaking rules for opaques in 2 places: - we only relate substs that correspond to captured lifetimes during TypeRelation; - we only list captured lifetimes in choice region computation. For simplicity, I encoded the "capturedness" of lifetimes as a variance, `Bivariant` vs `Invariant` for unused vs captured lifetimes. The `variances_of` query used to ICE for opaques. Impl-trait that do not reference `Self` or projections will have their variances as: - `o` (invariant) for each parent type or const; - `*` (bivariant) for each parent lifetime --> will not participate in borrowck; - `o` (invariant) for each own lifetime. Impl-trait that does reference `Self` and/or projections will have some parent lifetimes marked as `o` (as the example above), and participate in type relation and borrowck. In the example above, `variances_of(opaque) = ['_a: o, '_b: *, T: o, 'b: o]`. r? types cc `@compiler-errors` , as you asked about the issue with `Self` and projections.
2 parents 736c675 + b37feca commit 7fe6f36

File tree

33 files changed

+569
-340
lines changed

33 files changed

+569
-340
lines changed

‎compiler/rustc_ast_lowering/src/lib.rs

+6-12
Original file line numberDiff line numberDiff line change
@@ -60,8 +60,8 @@ use rustc_hir::def_id::{LocalDefId, CRATE_DEF_ID};
6060
use rustc_hir::definitions::DefPathData;
6161
use rustc_hir::{ConstArg, GenericArg, ItemLocalId, ParamName, TraitCandidate};
6262
use rustc_index::vec::{Idx, IndexVec};
63+
use rustc_middle::span_bug;
6364
use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
64-
use rustc_middle::{bug, span_bug};
6565
use rustc_session::parse::feature_err;
6666
use rustc_span::hygiene::MacroKind;
6767
use rustc_span::source_map::DesugaringKind;
@@ -1465,17 +1465,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
14651465
// frequently opened issues show.
14661466
let opaque_ty_span = self.mark_span_with_reason(DesugaringKind::OpaqueTy, span, None);
14671467

1468-
let opaque_ty_def_id = match origin {
1469-
hir::OpaqueTyOrigin::TyAlias => self.create_def(
1470-
self.current_hir_id_owner.def_id,
1471-
opaque_ty_node_id,
1472-
DefPathData::ImplTrait,
1473-
),
1474-
hir::OpaqueTyOrigin::FnReturn(fn_def_id) => {
1475-
self.create_def(fn_def_id, opaque_ty_node_id, DefPathData::ImplTrait)
1476-
}
1477-
hir::OpaqueTyOrigin::AsyncFn(..) => bug!("unreachable"),
1478-
};
1468+
let opaque_ty_def_id = self.create_def(
1469+
self.current_hir_id_owner.def_id,
1470+
opaque_ty_node_id,
1471+
DefPathData::ImplTrait,
1472+
);
14791473
debug!(?opaque_ty_def_id);
14801474

14811475
// Contains the new lifetime definitions created for the TAIT (if any).

‎compiler/rustc_borrowck/src/member_constraints.rs

+2
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@ use std::ops::Index;
1111

1212
/// Compactly stores a set of `R0 member of [R1...Rn]` constraints,
1313
/// indexed by the region `R0`.
14+
#[derive(Debug)]
1415
pub(crate) struct MemberConstraintSet<'tcx, R>
1516
where
1617
R: Copy + Eq,
@@ -31,6 +32,7 @@ where
3132
}
3233

3334
/// Represents a `R0 member of [R1..Rn]` constraint
35+
#[derive(Debug)]
3436
pub(crate) struct NllMemberConstraint<'tcx> {
3537
next_constraint: Option<NllMemberConstraintIndex>,
3638

‎compiler/rustc_borrowck/src/region_infer/mod.rs

+1
Original file line numberDiff line numberDiff line change
@@ -128,6 +128,7 @@ pub struct RegionInferenceContext<'tcx> {
128128
/// adds a new lower bound to the SCC it is analyzing: so you wind up
129129
/// with `'R: 'O` where `'R` is the pick-region and `'O` is the
130130
/// minimal viable option.
131+
#[derive(Debug)]
131132
pub(crate) struct AppliedMemberConstraint {
132133
/// The SCC that was affected. (The "member region".)
133134
///

‎compiler/rustc_borrowck/src/region_infer/opaque_types.rs

+37-11
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use rustc_data_structures::fx::FxHashMap;
1+
use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
22
use rustc_data_structures::vec_map::VecMap;
33
use rustc_hir::def_id::LocalDefId;
44
use rustc_hir::OpaqueTyOrigin;
@@ -61,17 +61,21 @@ impl<'tcx> RegionInferenceContext<'tcx> {
6161
opaque_ty_decls: VecMap<OpaqueTypeKey<'tcx>, (OpaqueHiddenType<'tcx>, OpaqueTyOrigin)>,
6262
) -> VecMap<LocalDefId, OpaqueHiddenType<'tcx>> {
6363
let mut result: VecMap<LocalDefId, OpaqueHiddenType<'tcx>> = VecMap::new();
64+
65+
let member_constraints: FxHashMap<_, _> = self
66+
.member_constraints
67+
.all_indices()
68+
.map(|ci| (self.member_constraints[ci].key, ci))
69+
.collect();
70+
debug!(?member_constraints);
71+
6472
for (opaque_type_key, (concrete_type, origin)) in opaque_ty_decls {
6573
let substs = opaque_type_key.substs;
6674
debug!(?concrete_type, ?substs);
6775

6876
let mut subst_regions = vec![self.universal_regions.fr_static];
69-
let universal_substs = infcx.tcx.fold_regions(substs, |region, _| {
70-
if let ty::RePlaceholder(..) = region.kind() {
71-
// Higher kinded regions don't need remapping, they don't refer to anything outside of this the substs.
72-
return region;
73-
}
74-
let vid = self.to_region_vid(region);
77+
78+
let to_universal_region = |vid, subst_regions: &mut Vec<_>| {
7579
trace!(?vid);
7680
let scc = self.constraint_sccs.scc(vid);
7781
trace!(?scc);
@@ -92,10 +96,33 @@ impl<'tcx> RegionInferenceContext<'tcx> {
9296
infcx.tcx.lifetimes.re_static
9397
}
9498
}
99+
};
100+
101+
// Start by inserting universal regions from the member_constraint choice regions.
102+
// This will ensure they get precedence when folding the regions in the concrete type.
103+
if let Some(&ci) = member_constraints.get(&opaque_type_key) {
104+
for &vid in self.member_constraints.choice_regions(ci) {
105+
to_universal_region(vid, &mut subst_regions);
106+
}
107+
}
108+
debug!(?subst_regions);
109+
110+
// Next, insert universal regions from substs, so we can translate regions that appear
111+
// in them but are not subject to member constraints, for instance closure substs.
112+
let universal_substs = infcx.tcx.fold_regions(substs, |region, _| {
113+
if let ty::RePlaceholder(..) = region.kind() {
114+
// Higher kinded regions don't need remapping, they don't refer to anything outside of this the substs.
115+
return region;
116+
}
117+
let vid = self.to_region_vid(region);
118+
to_universal_region(vid, &mut subst_regions)
95119
});
120+
debug!(?universal_substs);
121+
debug!(?subst_regions);
96122

97-
subst_regions.sort();
98-
subst_regions.dedup();
123+
// Deduplicate the set of regions while keeping the chosen order.
124+
let subst_regions = subst_regions.into_iter().collect::<FxIndexSet<_>>();
125+
debug!(?subst_regions);
99126

100127
let universal_concrete_type =
101128
infcx.tcx.fold_regions(concrete_type, |region, _| match *region {
@@ -106,8 +133,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
106133
.unwrap_or(infcx.tcx.lifetimes.re_erased),
107134
_ => region,
108135
});
109-
110-
debug!(?universal_concrete_type, ?universal_substs);
136+
debug!(?universal_concrete_type);
111137

112138
let opaque_type_key =
113139
OpaqueTypeKey { def_id: opaque_type_key.def_id, substs: universal_substs };

‎compiler/rustc_error_codes/src/error_codes/E0760.md

+3-1
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,11 @@
1+
#### Note: this error code is no longer emitted by the compiler.
2+
13
`async fn`/`impl trait` return type cannot contain a projection
24
or `Self` that references lifetimes from a parent scope.
35

46
Erroneous code example:
57

6-
```compile_fail,E0760,edition2018
8+
```compile_fail,edition2018
79
struct S<'a>(&'a i32);
810
911
impl<'a> S<'a> {

‎compiler/rustc_feature/src/active.rs

+2
Original file line numberDiff line numberDiff line change
@@ -419,6 +419,8 @@ declare_features! (
419419
(active, if_let_guard, "1.47.0", Some(51114), None),
420420
/// Allows `impl Trait` as output type in `Fn` traits in return position of functions.
421421
(active, impl_trait_in_fn_trait_return, "1.64.0", Some(99697), None),
422+
/// Allows referencing `Self` and projections in impl-trait.
423+
(active, impl_trait_projections, "CURRENT_RUSTC_VERSION", Some(103532), None),
422424
/// Allows using imported `main` function
423425
(active, imported_main, "1.53.0", Some(28937), None),
424426
/// Allows associated types in inherent impls.

‎compiler/rustc_hir_analysis/src/astconv/mod.rs

+5-28
Original file line numberDiff line numberDiff line change
@@ -2777,35 +2777,11 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
27772777
let substs = InternalSubsts::for_item(tcx, def_id, |param, _| {
27782778
if let Some(i) = (param.index as usize).checked_sub(generics.parent_count) {
27792779
// Our own parameters are the resolved lifetimes.
2780-
if let GenericParamDefKind::Lifetime = param.kind {
2781-
if let hir::GenericArg::Lifetime(lifetime) = &lifetimes[i] {
2782-
self.ast_region_to_region(lifetime, None).into()
2783-
} else {
2784-
bug!()
2785-
}
2786-
} else {
2787-
bug!()
2788-
}
2780+
let GenericParamDefKind::Lifetime { .. } = param.kind else { bug!() };
2781+
let hir::GenericArg::Lifetime(lifetime) = &lifetimes[i] else { bug!() };
2782+
self.ast_region_to_region(lifetime, None).into()
27892783
} else {
2790-
match param.kind {
2791-
// For RPIT (return position impl trait), only lifetimes
2792-
// mentioned in the impl Trait predicate are captured by
2793-
// the opaque type, so the lifetime parameters from the
2794-
// parent item need to be replaced with `'static`.
2795-
//
2796-
// For `impl Trait` in the types of statics, constants,
2797-
// locals and type aliases. These capture all parent
2798-
// lifetimes, so they can use their identity subst.
2799-
GenericParamDefKind::Lifetime
2800-
if matches!(
2801-
origin,
2802-
hir::OpaqueTyOrigin::FnReturn(..) | hir::OpaqueTyOrigin::AsyncFn(..)
2803-
) =>
2804-
{
2805-
tcx.lifetimes.re_static.into()
2806-
}
2807-
_ => tcx.mk_param_from_def(param),
2808-
}
2784+
tcx.mk_param_from_def(param)
28092785
}
28102786
});
28112787
debug!("impl_trait_ty_to_ty: substs={:?}", substs);
@@ -2982,6 +2958,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
29822958
Some(tcx.liberate_late_bound_regions(fn_hir_id.expect_owner().to_def_id(), ty))
29832959
}
29842960

2961+
#[instrument(level = "trace", skip(self, generate_err))]
29852962
fn validate_late_bound_regions(
29862963
&self,
29872964
constrained_regions: FxHashSet<ty::BoundRegionKind>,

‎compiler/rustc_hir_analysis/src/check/check.rs

+41-50
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@ use rustc_hir::def::{CtorKind, DefKind, Res};
1010
use rustc_hir::def_id::{DefId, LocalDefId};
1111
use rustc_hir::intravisit::Visitor;
1212
use rustc_hir::{ItemKind, Node, PathSegment};
13+
use rustc_infer::infer::opaque_types::ConstrainOpaqueTypeRegionVisitor;
1314
use rustc_infer::infer::outlives::env::OutlivesEnvironment;
1415
use rustc_infer::infer::{DefiningAnchor, RegionVariableOrigin, TyCtxtInferExt};
1516
use rustc_infer::traits::Obligation;
@@ -229,7 +230,9 @@ fn check_opaque<'tcx>(tcx: TyCtxt<'tcx>, id: hir::ItemId) {
229230
let substs = InternalSubsts::identity_for_item(tcx, item.owner_id.to_def_id());
230231
let span = tcx.def_span(item.owner_id.def_id);
231232

232-
check_opaque_for_inheriting_lifetimes(tcx, item.owner_id.def_id, span);
233+
if !tcx.features().impl_trait_projections {
234+
check_opaque_for_inheriting_lifetimes(tcx, item.owner_id.def_id, span);
235+
}
233236
if tcx.type_of(item.owner_id.def_id).references_error() {
234237
return;
235238
}
@@ -238,6 +241,7 @@ fn check_opaque<'tcx>(tcx: TyCtxt<'tcx>, id: hir::ItemId) {
238241
}
239242
check_opaque_meets_bounds(tcx, item.owner_id.def_id, substs, span, &origin);
240243
}
244+
241245
/// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result
242246
/// in "inheriting lifetimes".
243247
#[instrument(level = "debug", skip(tcx, span))]
@@ -249,52 +253,37 @@ pub(super) fn check_opaque_for_inheriting_lifetimes<'tcx>(
249253
let item = tcx.hir().expect_item(def_id);
250254
debug!(?item, ?span);
251255

252-
struct FoundParentLifetime;
253-
struct FindParentLifetimeVisitor<'tcx>(&'tcx ty::Generics);
254-
impl<'tcx> ty::visit::TypeVisitor<'tcx> for FindParentLifetimeVisitor<'tcx> {
255-
type BreakTy = FoundParentLifetime;
256-
257-
fn visit_region(&mut self, r: ty::Region<'tcx>) -> ControlFlow<Self::BreakTy> {
258-
debug!("FindParentLifetimeVisitor: r={:?}", r);
259-
if let ty::ReEarlyBound(ty::EarlyBoundRegion { index, .. }) = *r {
260-
if index < self.0.parent_count as u32 {
261-
return ControlFlow::Break(FoundParentLifetime);
262-
} else {
263-
return ControlFlow::CONTINUE;
264-
}
265-
}
266-
267-
r.super_visit_with(self)
268-
}
269-
270-
fn visit_const(&mut self, c: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
271-
if let ty::ConstKind::Unevaluated(..) = c.kind() {
272-
// FIXME(#72219) We currently don't detect lifetimes within substs
273-
// which would violate this check. Even though the particular substitution is not used
274-
// within the const, this should still be fixed.
275-
return ControlFlow::CONTINUE;
276-
}
277-
c.super_visit_with(self)
278-
}
279-
}
280-
281256
struct ProhibitOpaqueVisitor<'tcx> {
282257
tcx: TyCtxt<'tcx>,
283258
opaque_identity_ty: Ty<'tcx>,
284-
generics: &'tcx ty::Generics,
259+
parent_count: u32,
260+
references_parent_regions: bool,
285261
selftys: Vec<(Span, Option<String>)>,
286262
}
287263

288264
impl<'tcx> ty::visit::TypeVisitor<'tcx> for ProhibitOpaqueVisitor<'tcx> {
289265
type BreakTy = Ty<'tcx>;
290266

291267
fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
292-
debug!("check_opaque_for_inheriting_lifetimes: (visit_ty) t={:?}", t);
268+
debug!(?t, "root_visit_ty");
293269
if t == self.opaque_identity_ty {
294270
ControlFlow::CONTINUE
295271
} else {
296-
t.super_visit_with(&mut FindParentLifetimeVisitor(self.generics))
297-
.map_break(|FoundParentLifetime| t)
272+
t.visit_with(&mut ConstrainOpaqueTypeRegionVisitor {
273+
tcx: self.tcx,
274+
op: |region| {
275+
if let ty::ReEarlyBound(ty::EarlyBoundRegion { index, .. }) = *region
276+
&& index < self.parent_count
277+
{
278+
self.references_parent_regions= true;
279+
}
280+
},
281+
});
282+
if self.references_parent_regions {
283+
ControlFlow::Break(t)
284+
} else {
285+
ControlFlow::CONTINUE
286+
}
298287
}
299288
}
300289
}
@@ -327,26 +316,27 @@ pub(super) fn check_opaque_for_inheriting_lifetimes<'tcx>(
327316

328317
if let ItemKind::OpaqueTy(hir::OpaqueTy {
329318
origin: hir::OpaqueTyOrigin::AsyncFn(..) | hir::OpaqueTyOrigin::FnReturn(..),
319+
in_trait,
330320
..
331321
}) = item.kind
332322
{
323+
let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id());
324+
let opaque_identity_ty = if in_trait {
325+
tcx.mk_projection(def_id.to_def_id(), substs)
326+
} else {
327+
tcx.mk_opaque(def_id.to_def_id(), substs)
328+
};
333329
let mut visitor = ProhibitOpaqueVisitor {
334-
opaque_identity_ty: tcx.mk_opaque(
335-
def_id.to_def_id(),
336-
InternalSubsts::identity_for_item(tcx, def_id.to_def_id()),
337-
),
338-
generics: tcx.generics_of(def_id),
330+
opaque_identity_ty,
331+
parent_count: tcx.generics_of(def_id).parent_count as u32,
332+
references_parent_regions: false,
339333
tcx,
340334
selftys: vec![],
341335
};
342336
let prohibit_opaque = tcx
343337
.explicit_item_bounds(def_id)
344338
.iter()
345339
.try_for_each(|(predicate, _)| predicate.visit_with(&mut visitor));
346-
debug!(
347-
"check_opaque_for_inheriting_lifetimes: prohibit_opaque={:?}, visitor.opaque_identity_ty={:?}, visitor.generics={:?}",
348-
prohibit_opaque, visitor.opaque_identity_ty, visitor.generics
349-
);
350340

351341
if let Some(ty) = prohibit_opaque.break_value() {
352342
visitor.visit_item(&item);
@@ -357,15 +347,16 @@ pub(super) fn check_opaque_for_inheriting_lifetimes<'tcx>(
357347
_ => unreachable!(),
358348
};
359349

360-
let mut err = struct_span_err!(
361-
tcx.sess,
350+
let mut err = feature_err(
351+
&tcx.sess.parse_sess,
352+
sym::impl_trait_projections,
362353
span,
363-
E0760,
364-
"`{}` return type cannot contain a projection or `Self` that references lifetimes from \
365-
a parent scope",
366-
if is_async { "async fn" } else { "impl Trait" },
354+
&format!(
355+
"`{}` return type cannot contain a projection or `Self` that references \
356+
lifetimes from a parent scope",
357+
if is_async { "async fn" } else { "impl Trait" },
358+
),
367359
);
368-
369360
for (span, name) in visitor.selftys {
370361
err.span_suggestion(
371362
span,

0 commit comments

Comments
 (0)