Skip to content

Commit e8139df

Browse files
fmeasefmease
committed
IAT: Introduce AliasKind::Inherent
1 parent 6f8c055 commit e8139df

File tree

82 files changed

+1008
-167
lines changed

Some content is hidden

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

82 files changed

+1008
-167
lines changed

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

+35-26
Original file line numberDiff line numberDiff line change
@@ -2378,6 +2378,10 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
23782378
return Ok(None);
23792379
}
23802380

2381+
//
2382+
// Select applicable inherent associated type candidates modulo regions.
2383+
//
2384+
23812385
// In contexts that have no inference context, just make a new one.
23822386
// We do need a local variable to store it, though.
23832387
let infcx_;
@@ -2390,14 +2394,18 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
23902394
}
23912395
};
23922396

2393-
let param_env = tcx.param_env(block.owner.to_def_id());
2397+
// FIXME(inherent_associated_types): Acquiring the ParamEnv this early leads to cycle errors
2398+
// when inside of an ADT (#108491) or where clause.
2399+
let param_env = tcx.param_env(block.owner);
23942400
let cause = ObligationCause::misc(span, block.owner.def_id);
23952401

23962402
let mut fulfillment_errors = Vec::new();
23972403
let mut applicable_candidates: Vec<_> = infcx.probe(|_| {
23982404
let universe = infcx.create_next_universe();
23992405

24002406
// Regions are not considered during selection.
2407+
// FIXME(non_lifetime_binders): Here we are "truncating" or "flattening" the universes
2408+
// of type and const binders. Is that correct in the selection phase? See also #109505.
24012409
let self_ty = tcx.replace_escaping_bound_vars_uncached(
24022410
self_ty,
24032411
FnMutDelegate {
@@ -2413,41 +2421,40 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
24132421

24142422
candidates
24152423
.iter()
2416-
.filter_map(|&(impl_, (assoc_item, def_scope))| {
2424+
.copied()
2425+
.filter(|&(impl_, _)| {
24172426
infcx.probe(|_| {
24182427
let ocx = ObligationCtxt::new_in_snapshot(&infcx);
24192428

2420-
let impl_ty = tcx.type_of(impl_);
24212429
let impl_substs = infcx.fresh_item_substs(impl_);
2422-
let impl_ty = impl_ty.subst(tcx, impl_substs);
2430+
let impl_ty = tcx.type_of(impl_).subst(tcx, impl_substs);
24232431
let impl_ty = ocx.normalize(&cause, param_env, impl_ty);
24242432

2425-
// Check that the Self-types can be related.
2426-
// FIXME(fmease): Should we use `eq` here?
2427-
ocx.sup(&ObligationCause::dummy(), param_env, impl_ty, self_ty).ok()?;
2433+
// Check that the self types can be related.
2434+
// FIXME(inherent_associated_types): Should we use `eq` here? Method probing uses
2435+
// `sup` for this situtation, too. What for? To constrain inference variables?
2436+
if ocx.sup(&ObligationCause::dummy(), param_env, impl_ty, self_ty).is_err()
2437+
{
2438+
return false;
2439+
}
24282440

24292441
// Check whether the impl imposes obligations we have to worry about.
2430-
let impl_bounds = tcx.predicates_of(impl_);
2431-
let impl_bounds = impl_bounds.instantiate(tcx, impl_substs);
2432-
2442+
let impl_bounds = tcx.predicates_of(impl_).instantiate(tcx, impl_substs);
24332443
let impl_bounds = ocx.normalize(&cause, param_env, impl_bounds);
2434-
24352444
let impl_obligations = traits::predicates_for_generics(
24362445
|_, _| cause.clone(),
24372446
param_env,
24382447
impl_bounds,
24392448
);
2440-
24412449
ocx.register_obligations(impl_obligations);
24422450

24432451
let mut errors = ocx.select_where_possible();
24442452
if !errors.is_empty() {
24452453
fulfillment_errors.append(&mut errors);
2446-
return None;
2454+
return false;
24472455
}
24482456

2449-
// FIXME(fmease): Unsolved vars can escape this InferCtxt snapshot.
2450-
Some((assoc_item, def_scope, infcx.resolve_vars_if_possible(impl_substs)))
2457+
true
24512458
})
24522459
})
24532460
.collect()
@@ -2456,24 +2463,26 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
24562463
if applicable_candidates.len() > 1 {
24572464
return Err(self.complain_about_ambiguous_inherent_assoc_type(
24582465
name,
2459-
applicable_candidates.into_iter().map(|(candidate, ..)| candidate).collect(),
2466+
applicable_candidates.into_iter().map(|(_, (candidate, _))| candidate).collect(),
24602467
span,
24612468
));
24622469
}
24632470

2464-
if let Some((assoc_item, def_scope, impl_substs)) = applicable_candidates.pop() {
2471+
if let Some((impl_, (assoc_item, def_scope))) = applicable_candidates.pop() {
24652472
self.check_assoc_ty(assoc_item, name, def_scope, block, span);
24662473

2467-
// FIXME(inherent_associated_types): To fully *confirm* the *probed* candidate, we still
2468-
// need to relate the Self-type with fresh item substs & register region obligations for
2469-
// regionck to prove/disprove.
2470-
2471-
let item_substs =
2472-
self.create_substs_for_associated_item(span, assoc_item, segment, impl_substs);
2474+
// FIXME(fmease): Currently creating throwaway `parent_substs` to please
2475+
// `create_substs_for_associated_item`. Modify the latter instead (or sth. similar) to
2476+
// not require the parent substs logic.
2477+
let parent_substs = InternalSubsts::identity_for_item(tcx, impl_);
2478+
let substs =
2479+
self.create_substs_for_associated_item(span, assoc_item, segment, parent_substs);
2480+
let substs = tcx.mk_substs_from_iter(
2481+
std::iter::once(ty::GenericArg::from(self_ty))
2482+
.chain(substs.into_iter().skip(parent_substs.len())),
2483+
);
24732484

2474-
// FIXME(fmease, #106722): Check if the bounds on the parameters of the
2475-
// associated type hold, if any.
2476-
let ty = tcx.type_of(assoc_item).subst(tcx, item_substs);
2485+
let ty = tcx.mk_alias(ty::Inherent, tcx.mk_alias_ty(assoc_item, substs));
24772486

24782487
return Ok(Some((ty, assoc_item)));
24792488
}

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
@@ -1938,7 +1938,7 @@ fn is_late_bound_map(
19381938
ty::Param(param_ty) => {
19391939
self.arg_is_constrained[param_ty.index as usize] = true;
19401940
}
1941-
ty::Alias(ty::Projection, _) => return ControlFlow::Continue(()),
1941+
ty::Alias(ty::Projection | ty::Inherent, _) => return ControlFlow::Continue(()),
19421942
_ => (),
19431943
}
19441944
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
@@ -125,7 +125,8 @@ impl<'tcx> InferCtxt<'tcx> {
125125
bug!()
126126
}
127127

128-
(_, ty::Alias(AliasKind::Projection, _)) | (ty::Alias(AliasKind::Projection, _), _)
128+
(_, ty::Alias(AliasKind::Projection | AliasKind::Inherent, _))
129+
| (ty::Alias(AliasKind::Projection | AliasKind::Inherent, _), _)
129130
if self.tcx.trait_solver_next() =>
130131
{
131132
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::lint::{BuiltinLintDiagnostics, FutureIncompatibilityReason};
6768
use rustc_span::edition::Edition;
@@ -1461,6 +1462,10 @@ impl<'tcx> LateLintPass<'tcx> for TypeAliasBounds {
14611462
// Bounds are respected for `type X = impl Trait`
14621463
return;
14631464
}
1465+
if cx.tcx.type_of(item.owner_id).skip_binder().has_inherent_projections() {
1466+
// Bounds are respected for `type X = … Type::Inherent …`
1467+
return;
1468+
}
14641469
// There must not be a where clause
14651470
if type_alias_generics.predicates.is_empty() {
14661471
return;
@@ -1580,7 +1585,6 @@ declare_lint_pass!(
15801585

15811586
impl<'tcx> LateLintPass<'tcx> for TrivialConstraints {
15821587
fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
1583-
use rustc_middle::ty::visit::TypeVisitableExt;
15841588
use rustc_middle::ty::Clause;
15851589
use rustc_middle::ty::PredicateKind::*;
15861590

@@ -2917,6 +2921,7 @@ impl ClashingExternDeclarations {
29172921
| (Generator(..), Generator(..))
29182922
| (GeneratorWitness(..), GeneratorWitness(..))
29192923
| (Alias(ty::Projection, ..), Alias(ty::Projection, ..))
2924+
| (Alias(ty::Inherent, ..), Alias(ty::Inherent, ..))
29202925
| (Alias(ty::Opaque, ..), Alias(ty::Opaque, ..)) => false,
29212926

29222927
// 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
@@ -1846,7 +1846,17 @@ impl<'tcx> TyCtxt<'tcx> {
18461846
let substs = substs.into_iter().map(Into::into);
18471847
#[cfg(debug_assertions)]
18481848
{
1849-
let n = self.generics_of(_def_id).count();
1849+
let generics = self.generics_of(_def_id);
1850+
1851+
let n = if let DefKind::AssocTy = self.def_kind(_def_id)
1852+
&& let DefKind::Impl { of_trait: false } = self.def_kind(self.parent(_def_id))
1853+
{
1854+
// If this is an inherent projection.
1855+
1856+
generics.params.len() + 1
1857+
} else {
1858+
generics.count()
1859+
};
18501860
assert_eq!(
18511861
(n, Some(n)),
18521862
substs.size_hint(),
@@ -2007,7 +2017,7 @@ impl<'tcx> TyCtxt<'tcx> {
20072017
debug_assert_matches!(
20082018
(kind, self.def_kind(alias_ty.def_id)),
20092019
(ty::Opaque, DefKind::OpaqueTy)
2010-
| (ty::Projection, DefKind::AssocTy)
2020+
| (ty::Projection | ty::Inherent, DefKind::AssocTy)
20112021
| (ty::Opaque | ty::Projection, DefKind::ImplTraitPlaceholder)
20122022
);
20132023
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)