Skip to content

Commit 29ac429

Browse files
compiler-errorscompiler-errors
authored
Rollup merge of #109410 - fmease:iat-alias-kind-inherent, r=compiler-errors
Introduce `AliasKind::Inherent` for inherent associated types Allows us to check (possibly generic) inherent associated types for well-formedness. Type inference now also works properly. Follow-up to #105961. Supersedes #108430. Fixes #106722. Fixes #108957. Fixes #109768. Fixes #109789. Fixes #109790. ~Not to be merged before #108860 (`AliasKind::Weak`).~ CC `@jackh726` r? `@compiler-errors` `@rustbot` label T-types F-inherent_associated_types
2 parents fcb275f + cd6dec3 commit 29ac429

File tree

96 files changed

+1365
-229
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

96 files changed

+1365
-229
lines changed

Diff for: ‎compiler/rustc_hir_analysis/src/astconv/mod.rs

+35-26
Original file line numberDiff line numberDiff line change
@@ -2419,6 +2419,10 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
24192419
return Ok(None);
24202420
}
24212421

2422+
//
2423+
// Select applicable inherent associated type candidates modulo regions.
2424+
//
2425+
24222426
// In contexts that have no inference context, just make a new one.
24232427
// We do need a local variable to store it, though.
24242428
let infcx_;
@@ -2431,14 +2435,18 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
24312435
}
24322436
};
24332437

2434-
let param_env = tcx.param_env(block.owner.to_def_id());
2438+
// FIXME(inherent_associated_types): Acquiring the ParamEnv this early leads to cycle errors
2439+
// when inside of an ADT (#108491) or where clause.
2440+
let param_env = tcx.param_env(block.owner);
24352441
let cause = ObligationCause::misc(span, block.owner.def_id);
24362442

24372443
let mut fulfillment_errors = Vec::new();
24382444
let mut applicable_candidates: Vec<_> = infcx.probe(|_| {
24392445
let universe = infcx.create_next_universe();
24402446

24412447
// Regions are not considered during selection.
2448+
// FIXME(non_lifetime_binders): Here we are "truncating" or "flattening" the universes
2449+
// of type and const binders. Is that correct in the selection phase? See also #109505.
24422450
let self_ty = tcx.replace_escaping_bound_vars_uncached(
24432451
self_ty,
24442452
FnMutDelegate {
@@ -2454,41 +2462,40 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
24542462

24552463
candidates
24562464
.iter()
2457-
.filter_map(|&(impl_, (assoc_item, def_scope))| {
2465+
.copied()
2466+
.filter(|&(impl_, _)| {
24582467
infcx.probe(|_| {
24592468
let ocx = ObligationCtxt::new_in_snapshot(&infcx);
24602469

2461-
let impl_ty = tcx.type_of(impl_);
24622470
let impl_substs = infcx.fresh_item_substs(impl_);
2463-
let impl_ty = impl_ty.subst(tcx, impl_substs);
2471+
let impl_ty = tcx.type_of(impl_).subst(tcx, impl_substs);
24642472
let impl_ty = ocx.normalize(&cause, param_env, impl_ty);
24652473

2466-
// Check that the Self-types can be related.
2467-
// FIXME(fmease): Should we use `eq` here?
2468-
ocx.sup(&ObligationCause::dummy(), param_env, impl_ty, self_ty).ok()?;
2474+
// Check that the self types can be related.
2475+
// FIXME(inherent_associated_types): Should we use `eq` here? Method probing uses
2476+
// `sup` for this situtation, too. What for? To constrain inference variables?
2477+
if ocx.sup(&ObligationCause::dummy(), param_env, impl_ty, self_ty).is_err()
2478+
{
2479+
return false;
2480+
}
24692481

24702482
// Check whether the impl imposes obligations we have to worry about.
2471-
let impl_bounds = tcx.predicates_of(impl_);
2472-
let impl_bounds = impl_bounds.instantiate(tcx, impl_substs);
2473-
2483+
let impl_bounds = tcx.predicates_of(impl_).instantiate(tcx, impl_substs);
24742484
let impl_bounds = ocx.normalize(&cause, param_env, impl_bounds);
2475-
24762485
let impl_obligations = traits::predicates_for_generics(
24772486
|_, _| cause.clone(),
24782487
param_env,
24792488
impl_bounds,
24802489
);
2481-
24822490
ocx.register_obligations(impl_obligations);
24832491

24842492
let mut errors = ocx.select_where_possible();
24852493
if !errors.is_empty() {
24862494
fulfillment_errors.append(&mut errors);
2487-
return None;
2495+
return false;
24882496
}
24892497

2490-
// FIXME(fmease): Unsolved vars can escape this InferCtxt snapshot.
2491-
Some((assoc_item, def_scope, infcx.resolve_vars_if_possible(impl_substs)))
2498+
true
24922499
})
24932500
})
24942501
.collect()
@@ -2497,24 +2504,26 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
24972504
if applicable_candidates.len() > 1 {
24982505
return Err(self.complain_about_ambiguous_inherent_assoc_type(
24992506
name,
2500-
applicable_candidates.into_iter().map(|(candidate, ..)| candidate).collect(),
2507+
applicable_candidates.into_iter().map(|(_, (candidate, _))| candidate).collect(),
25012508
span,
25022509
));
25032510
}
25042511

2505-
if let Some((assoc_item, def_scope, impl_substs)) = applicable_candidates.pop() {
2512+
if let Some((impl_, (assoc_item, def_scope))) = applicable_candidates.pop() {
25062513
self.check_assoc_ty(assoc_item, name, def_scope, block, span);
25072514

2508-
// FIXME(inherent_associated_types): To fully *confirm* the *probed* candidate, we still
2509-
// need to relate the Self-type with fresh item substs & register region obligations for
2510-
// regionck to prove/disprove.
2511-
2512-
let item_substs =
2513-
self.create_substs_for_associated_item(span, assoc_item, segment, impl_substs);
2515+
// FIXME(fmease): Currently creating throwaway `parent_substs` to please
2516+
// `create_substs_for_associated_item`. Modify the latter instead (or sth. similar) to
2517+
// not require the parent substs logic.
2518+
let parent_substs = InternalSubsts::identity_for_item(tcx, impl_);
2519+
let substs =
2520+
self.create_substs_for_associated_item(span, assoc_item, segment, parent_substs);
2521+
let substs = tcx.mk_substs_from_iter(
2522+
std::iter::once(ty::GenericArg::from(self_ty))
2523+
.chain(substs.into_iter().skip(parent_substs.len())),
2524+
);
25142525

2515-
// FIXME(fmease, #106722): Check if the bounds on the parameters of the
2516-
// associated type hold, if any.
2517-
let ty = tcx.type_of(assoc_item).subst(tcx, item_substs);
2526+
let ty = tcx.mk_alias(ty::Inherent, tcx.mk_alias_ty(assoc_item, substs));
25182527

25192528
return Ok(Some((ty, assoc_item)));
25202529
}

Diff for: ‎compiler/rustc_hir_analysis/src/coherence/orphan.rs

+13
Original file line numberDiff line numberDiff line change
@@ -210,6 +210,19 @@ fn do_orphan_check_impl<'tcx>(
210210
NonlocalImpl::DisallowOther,
211211
),
212212

213+
// ```
214+
// struct S<T>(T);
215+
// impl<T: ?Sized> S<T> {
216+
// type This = T;
217+
// }
218+
// impl<T: ?Sized> AutoTrait for S<T>::This {}
219+
// ```
220+
// FIXME(inherent_associated_types): The example code above currently leads to a cycle
221+
ty::Alias(AliasKind::Inherent, _) => (
222+
LocalImpl::Disallow { problematic_kind: "associated type" },
223+
NonlocalImpl::DisallowOther,
224+
),
225+
213226
// type Opaque = impl Trait;
214227
// impl AutoTrait for Opaque {}
215228
ty::Alias(AliasKind::Opaque, _) => (

Diff for: ‎compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1948,7 +1948,7 @@ fn is_late_bound_map(
19481948
ty::Param(param_ty) => {
19491949
self.arg_is_constrained[param_ty.index as usize] = true;
19501950
}
1951-
ty::Alias(ty::Projection, _) => return ControlFlow::Continue(()),
1951+
ty::Alias(ty::Projection | ty::Inherent, _) => return ControlFlow::Continue(()),
19521952
_ => (),
19531953
}
19541954
t.super_visit_with(self)

Diff for: ‎compiler/rustc_hir_analysis/src/collect/type_of.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -127,7 +127,7 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
127127
// the def_id that this query was called with. We filter to only type and const args here
128128
// as a precaution for if it's ever allowed to elide lifetimes in GAT's. It currently isn't
129129
// but it can't hurt to be safe ^^
130-
if let ty::Alias(ty::Projection, projection) = ty.kind() {
130+
if let ty::Alias(ty::Projection | ty::Inherent, projection) = ty.kind() {
131131
let generics = tcx.generics_of(projection.def_id);
132132

133133
let arg_index = segment

Diff for: ‎compiler/rustc_hir_analysis/src/constrained_generic_params.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -59,7 +59,7 @@ struct ParameterCollector {
5959
impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ParameterCollector {
6060
fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
6161
match *t.kind() {
62-
ty::Alias(ty::Projection, ..) if !self.include_nonconstraining => {
62+
ty::Alias(ty::Projection | ty::Inherent, ..) if !self.include_nonconstraining => {
6363
// projections are not injective
6464
return ControlFlow::Continue(());
6565
}

Diff for: ‎compiler/rustc_hir_analysis/src/outlives/implicit_infer.rs

+3
Original file line numberDiff line numberDiff line change
@@ -210,6 +210,9 @@ fn insert_required_predicates_to_be_wf<'tcx>(
210210
);
211211
}
212212

213+
// FIXME(inherent_associated_types): Handle this case properly.
214+
ty::Alias(ty::Inherent, _) => {}
215+
213216
_ => {}
214217
}
215218
}

Diff for: ‎compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -843,7 +843,7 @@ fn find_param_in_ty<'tcx>(
843843
return true;
844844
}
845845
if let ty::GenericArgKind::Type(ty) = arg.unpack()
846-
&& let ty::Alias(ty::Projection, ..) = ty.kind()
846+
&& let ty::Alias(ty::Projection | ty::Inherent, ..) = ty.kind()
847847
{
848848
// This logic may seem a bit strange, but typically when
849849
// we have a projection type in a function signature, the

Diff for: ‎compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -300,7 +300,7 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
300300
match ty.kind() {
301301
ty::Adt(adt_def, _) => Some(*adt_def),
302302
// FIXME(#104767): Should we handle bound regions here?
303-
ty::Alias(ty::Projection, _) if !ty.has_escaping_bound_vars() => {
303+
ty::Alias(ty::Projection | ty::Inherent, _) if !ty.has_escaping_bound_vars() => {
304304
self.normalize(span, ty).ty_adt_def()
305305
}
306306
_ => None,

Diff for: ‎compiler/rustc_hir_typeck/src/method/suggest.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -2211,7 +2211,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
22112211
| ty::Float(_)
22122212
| ty::Adt(_, _)
22132213
| ty::Str
2214-
| ty::Alias(ty::Projection, _)
2214+
| ty::Alias(ty::Projection | ty::Inherent, _)
22152215
| ty::Param(_) => format!("{deref_ty}"),
22162216
// we need to test something like <&[_]>::len or <(&[u32])>::len
22172217
// and Vec::function();

Diff for: ‎compiler/rustc_infer/src/infer/combine.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -127,7 +127,8 @@ impl<'tcx> InferCtxt<'tcx> {
127127
bug!()
128128
}
129129

130-
(_, ty::Alias(AliasKind::Projection, _)) | (ty::Alias(AliasKind::Projection, _), _)
130+
(_, ty::Alias(AliasKind::Projection | AliasKind::Inherent, _))
131+
| (ty::Alias(AliasKind::Projection | AliasKind::Inherent, _), _)
131132
if self.tcx.trait_solver_next() =>
132133
{
133134
relation.register_type_relate_obligation(a, b);

Diff for: ‎compiler/rustc_infer/src/infer/error_reporting/mod.rs

+3-1
Original file line numberDiff line numberDiff line change
@@ -2354,7 +2354,9 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
23542354
let labeled_user_string = match bound_kind {
23552355
GenericKind::Param(ref p) => format!("the parameter type `{}`", p),
23562356
GenericKind::Alias(ref p) => match p.kind(self.tcx) {
2357-
ty::AliasKind::Projection => format!("the associated type `{}`", p),
2357+
ty::AliasKind::Projection | ty::AliasKind::Inherent => {
2358+
format!("the associated type `{}`", p)
2359+
}
23582360
ty::AliasKind::Opaque => format!("the opaque type `{}`", p),
23592361
},
23602362
};

Diff for: ‎compiler/rustc_infer/src/infer/error_reporting/note_and_explain.rs

+4-3
Original file line numberDiff line numberDiff line change
@@ -71,9 +71,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
7171
#traits-as-parameters",
7272
);
7373
}
74-
(ty::Alias(ty::Projection, _), ty::Alias(ty::Projection, _)) => {
74+
(ty::Alias(ty::Projection | ty::Inherent, _), ty::Alias(ty::Projection | ty::Inherent, _)) => {
7575
diag.note("an associated type was expected, but a different one was found");
7676
}
77+
// FIXME(inherent_associated_types): Extend this to support `ty::Inherent`, too.
7778
(ty::Param(p), ty::Alias(ty::Projection, proj)) | (ty::Alias(ty::Projection, proj), ty::Param(p))
7879
if !tcx.is_impl_trait_in_trait(proj.def_id) =>
7980
{
@@ -222,7 +223,7 @@ impl<T> Trait<T> for X {
222223
diag.span_label(p_span, "this type parameter");
223224
}
224225
}
225-
(ty::Alias(ty::Projection, proj_ty), _) if !tcx.is_impl_trait_in_trait(proj_ty.def_id) => {
226+
(ty::Alias(ty::Projection | ty::Inherent, proj_ty), _) if !tcx.is_impl_trait_in_trait(proj_ty.def_id) => {
226227
self.expected_projection(
227228
diag,
228229
proj_ty,
@@ -231,7 +232,7 @@ impl<T> Trait<T> for X {
231232
cause.code(),
232233
);
233234
}
234-
(_, ty::Alias(ty::Projection, proj_ty)) if !tcx.is_impl_trait_in_trait(proj_ty.def_id) => {
235+
(_, ty::Alias(ty::Projection | ty::Inherent, proj_ty)) if !tcx.is_impl_trait_in_trait(proj_ty.def_id) => {
235236
let msg = format!(
236237
"consider constraining the associated type `{}` to `{}`",
237238
values.found, values.expected,

Diff for: ‎compiler/rustc_infer/src/infer/opaque_types.rs

+2
Original file line numberDiff line numberDiff line change
@@ -549,6 +549,7 @@ impl<'tcx> InferCtxt<'tcx> {
549549
// We can't normalize associated types from `rustc_infer`,
550550
// but we can eagerly register inference variables for them.
551551
// FIXME(RPITIT): Don't replace RPITITs with inference vars.
552+
// FIXME(inherent_associated_types): Extend this to support `ty::Inherent`, too.
552553
ty::Alias(ty::Projection, projection_ty)
553554
if !projection_ty.has_escaping_bound_vars()
554555
&& !tcx.is_impl_trait_in_trait(projection_ty.def_id) =>
@@ -569,6 +570,7 @@ impl<'tcx> InferCtxt<'tcx> {
569570
hidden_ty
570571
}
571572
// FIXME(RPITIT): This can go away when we move to associated types
573+
// FIXME(inherent_associated_types): Extend this to support `ty::Inherent`, too.
572574
ty::Alias(
573575
ty::Projection,
574576
ty::AliasTy { def_id: def_id2, substs: substs2, .. },

Diff for: ‎compiler/rustc_lint/src/builtin.rs

+6-1
Original file line numberDiff line numberDiff line change
@@ -62,6 +62,7 @@ use rustc_middle::lint::in_external_macro;
6262
use rustc_middle::ty::layout::{LayoutError, LayoutOf};
6363
use rustc_middle::ty::print::with_no_trimmed_paths;
6464
use rustc_middle::ty::subst::GenericArgKind;
65+
use rustc_middle::ty::TypeVisitableExt;
6566
use rustc_middle::ty::{self, Instance, Ty, TyCtxt, VariantDef};
6667
use rustc_session::config::ExpectedValues;
6768
use rustc_session::lint::{BuiltinLintDiagnostics, FutureIncompatibilityReason};
@@ -1442,6 +1443,10 @@ impl<'tcx> LateLintPass<'tcx> for TypeAliasBounds {
14421443
// Bounds are respected for `type X = impl Trait`
14431444
return;
14441445
}
1446+
if cx.tcx.type_of(item.owner_id).skip_binder().has_inherent_projections() {
1447+
// Bounds are respected for `type X = … Type::Inherent …`
1448+
return;
1449+
}
14451450
// There must not be a where clause
14461451
if type_alias_generics.predicates.is_empty() {
14471452
return;
@@ -1561,7 +1566,6 @@ declare_lint_pass!(
15611566

15621567
impl<'tcx> LateLintPass<'tcx> for TrivialConstraints {
15631568
fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
1564-
use rustc_middle::ty::visit::TypeVisitableExt;
15651569
use rustc_middle::ty::Clause;
15661570
use rustc_middle::ty::PredicateKind::*;
15671571

@@ -2898,6 +2902,7 @@ impl ClashingExternDeclarations {
28982902
| (Generator(..), Generator(..))
28992903
| (GeneratorWitness(..), GeneratorWitness(..))
29002904
| (Alias(ty::Projection, ..), Alias(ty::Projection, ..))
2905+
| (Alias(ty::Inherent, ..), Alias(ty::Inherent, ..))
29012906
| (Alias(ty::Opaque, ..), Alias(ty::Opaque, ..)) => false,
29022907

29032908
// These definitely should have been caught above.

Diff for: ‎compiler/rustc_lint/src/types.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -1119,14 +1119,14 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
11191119

11201120
// `extern "C" fn` functions can have type parameters, which may or may not be FFI-safe,
11211121
// so they are currently ignored for the purposes of this lint.
1122-
ty::Param(..) | ty::Alias(ty::Projection, ..)
1122+
ty::Param(..) | ty::Alias(ty::Projection | ty::Inherent, ..)
11231123
if matches!(self.mode, CItemKind::Definition) =>
11241124
{
11251125
FfiSafe
11261126
}
11271127

11281128
ty::Param(..)
1129-
| ty::Alias(ty::Projection, ..)
1129+
| ty::Alias(ty::Projection | ty::Inherent, ..)
11301130
| ty::Infer(..)
11311131
| ty::Bound(..)
11321132
| ty::Error(_)

Diff for: ‎compiler/rustc_middle/src/query/mod.rs

+10
Original file line numberDiff line numberDiff line change
@@ -1821,6 +1821,16 @@ rustc_queries! {
18211821
desc { "normalizing `{}`", goal.value.value }
18221822
}
18231823

1824+
/// Do not call this query directly: invoke `normalize` instead.
1825+
query normalize_inherent_projection_ty(
1826+
goal: CanonicalProjectionGoal<'tcx>
1827+
) -> Result<
1828+
&'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, NormalizationResult<'tcx>>>,
1829+
NoSolution,
1830+
> {
1831+
desc { "normalizing `{}`", goal.value.value }
1832+
}
1833+
18241834
/// Do not call this query directly: invoke `try_normalize_erasing_regions` instead.
18251835
query try_normalize_generic_arg_after_erasing_regions(
18261836
goal: ParamEnvAnd<'tcx, GenericArg<'tcx>>

Diff for: ‎compiler/rustc_middle/src/ty/context.rs

+12-2
Original file line numberDiff line numberDiff line change
@@ -1848,7 +1848,17 @@ impl<'tcx> TyCtxt<'tcx> {
18481848
let substs = substs.into_iter().map(Into::into);
18491849
#[cfg(debug_assertions)]
18501850
{
1851-
let n = self.generics_of(_def_id).count();
1851+
let generics = self.generics_of(_def_id);
1852+
1853+
let n = if let DefKind::AssocTy = self.def_kind(_def_id)
1854+
&& let DefKind::Impl { of_trait: false } = self.def_kind(self.parent(_def_id))
1855+
{
1856+
// If this is an inherent projection.
1857+
1858+
generics.params.len() + 1
1859+
} else {
1860+
generics.count()
1861+
};
18521862
assert_eq!(
18531863
(n, Some(n)),
18541864
substs.size_hint(),
@@ -2009,7 +2019,7 @@ impl<'tcx> TyCtxt<'tcx> {
20092019
debug_assert_matches!(
20102020
(kind, self.def_kind(alias_ty.def_id)),
20112021
(ty::Opaque, DefKind::OpaqueTy)
2012-
| (ty::Projection, DefKind::AssocTy)
2022+
| (ty::Projection | ty::Inherent, DefKind::AssocTy)
20132023
| (ty::Opaque | ty::Projection, DefKind::ImplTraitPlaceholder)
20142024
);
20152025
self.mk_ty_from_kind(Alias(kind, alias_ty))

Diff for: ‎compiler/rustc_middle/src/ty/error.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -265,7 +265,7 @@ impl<'tcx> Ty<'tcx> {
265265
ty::Infer(ty::FreshTy(_)) => "fresh type".into(),
266266
ty::Infer(ty::FreshIntTy(_)) => "fresh integral type".into(),
267267
ty::Infer(ty::FreshFloatTy(_)) => "fresh floating-point type".into(),
268-
ty::Alias(ty::Projection, _) => "associated type".into(),
268+
ty::Alias(ty::Projection | ty::Inherent, _) => "associated type".into(),
269269
ty::Param(p) => format!("type parameter `{p}`").into(),
270270
ty::Alias(ty::Opaque, ..) => if tcx.ty_is_opaque_future(self) { "future".into() } else { "opaque type".into() },
271271
ty::Error(_) => "type error".into(),
@@ -312,7 +312,7 @@ impl<'tcx> Ty<'tcx> {
312312
ty::Tuple(..) => "tuple".into(),
313313
ty::Placeholder(..) => "higher-ranked type".into(),
314314
ty::Bound(..) => "bound type variable".into(),
315-
ty::Alias(ty::Projection, _) => "associated type".into(),
315+
ty::Alias(ty::Projection | ty::Inherent, _) => "associated type".into(),
316316
ty::Param(_) => "type parameter".into(),
317317
ty::Alias(ty::Opaque, ..) => "opaque type".into(),
318318
}

0 commit comments

Comments
 (0)