squash OpaqueTy and ProjectionTy into AliasTy
This commit is contained in:
parent
5c6afb850c
commit
c13bd83528
66 changed files with 182 additions and 197 deletions
|
@ -369,7 +369,7 @@ fn suggest_restriction<'tcx>(
|
|||
msg: &str,
|
||||
err: &mut Diagnostic,
|
||||
fn_sig: Option<&hir::FnSig<'_>>,
|
||||
projection: Option<&ty::ProjectionTy<'_>>,
|
||||
projection: Option<&ty::AliasTy<'_>>,
|
||||
trait_pred: ty::PolyTraitPredicate<'tcx>,
|
||||
// When we are dealing with a trait, `super_traits` will be `Some`:
|
||||
// Given `trait T: A + B + C {}`
|
||||
|
@ -855,7 +855,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
|
|||
fn_sig.inputs().map_bound(|inputs| &inputs[1..]),
|
||||
))
|
||||
}
|
||||
ty::Opaque(ty::OpaqueTy { def_id, substs }) => {
|
||||
ty::Opaque(ty::AliasTy { def_id, substs }) => {
|
||||
self.tcx.bound_item_bounds(def_id).subst(self.tcx, substs).iter().find_map(|pred| {
|
||||
if let ty::PredicateKind::Clause(ty::Clause::Projection(proj)) = pred.kind().skip_binder()
|
||||
&& Some(proj.projection_ty.def_id) == self.tcx.lang_items().fn_once_output()
|
||||
|
@ -2644,7 +2644,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
|
|||
Some(ident) => err.span_note(ident.span, &msg),
|
||||
None => err.note(&msg),
|
||||
},
|
||||
ty::Opaque(ty::OpaqueTy { def_id, substs: _ }) => {
|
||||
ty::Opaque(ty::AliasTy { def_id, substs: _ }) => {
|
||||
// Avoid printing the future from `core::future::identity_future`, it's not helpful
|
||||
if tcx.parent(*def_id) == identity_future {
|
||||
break 'print;
|
||||
|
@ -3248,7 +3248,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
|
|||
// This corresponds to `<ExprTy as Iterator>::Item = _`.
|
||||
let trait_ref = ty::Binder::dummy(ty::PredicateKind::Clause(
|
||||
ty::Clause::Projection(ty::ProjectionPredicate {
|
||||
projection_ty: ty::ProjectionTy { substs, def_id: proj.def_id },
|
||||
projection_ty: ty::AliasTy { substs, def_id: proj.def_id },
|
||||
term: ty_var.into(),
|
||||
}),
|
||||
));
|
||||
|
|
|
@ -45,7 +45,7 @@ pub type PolyProjectionObligation<'tcx> = Obligation<'tcx, ty::PolyProjectionPre
|
|||
|
||||
pub type ProjectionObligation<'tcx> = Obligation<'tcx, ty::ProjectionPredicate<'tcx>>;
|
||||
|
||||
pub type ProjectionTyObligation<'tcx> = Obligation<'tcx, ty::ProjectionTy<'tcx>>;
|
||||
pub type ProjectionTyObligation<'tcx> = Obligation<'tcx, ty::AliasTy<'tcx>>;
|
||||
|
||||
pub(super) struct InProgress;
|
||||
|
||||
|
@ -496,7 +496,7 @@ impl<'a, 'b, 'tcx> TypeFolder<'tcx> for AssocTypeNormalizer<'a, 'b, 'tcx> {
|
|||
// This is really important. While we *can* handle this, this has
|
||||
// severe performance implications for large opaque types with
|
||||
// late-bound regions. See `issue-88862` benchmark.
|
||||
ty::Opaque(ty::OpaqueTy { def_id, substs }) if !substs.has_escaping_bound_vars() => {
|
||||
ty::Opaque(ty::AliasTy { def_id, substs }) if !substs.has_escaping_bound_vars() => {
|
||||
// Only normalize `impl Trait` outside of type inference, usually in codegen.
|
||||
match self.param_env.reveal() {
|
||||
Reveal::UserFacing => ty.super_fold_with(self),
|
||||
|
@ -957,7 +957,7 @@ impl<'tcx> TypeFolder<'tcx> for PlaceholderReplacer<'_, 'tcx> {
|
|||
pub fn normalize_projection_type<'a, 'b, 'tcx>(
|
||||
selcx: &'a mut SelectionContext<'b, 'tcx>,
|
||||
param_env: ty::ParamEnv<'tcx>,
|
||||
projection_ty: ty::ProjectionTy<'tcx>,
|
||||
projection_ty: ty::AliasTy<'tcx>,
|
||||
cause: ObligationCause<'tcx>,
|
||||
depth: usize,
|
||||
obligations: &mut Vec<PredicateObligation<'tcx>>,
|
||||
|
@ -995,7 +995,7 @@ pub fn normalize_projection_type<'a, 'b, 'tcx>(
|
|||
fn opt_normalize_projection_type<'a, 'b, 'tcx>(
|
||||
selcx: &'a mut SelectionContext<'b, 'tcx>,
|
||||
param_env: ty::ParamEnv<'tcx>,
|
||||
projection_ty: ty::ProjectionTy<'tcx>,
|
||||
projection_ty: ty::AliasTy<'tcx>,
|
||||
cause: ObligationCause<'tcx>,
|
||||
depth: usize,
|
||||
obligations: &mut Vec<PredicateObligation<'tcx>>,
|
||||
|
@ -1177,7 +1177,7 @@ fn opt_normalize_projection_type<'a, 'b, 'tcx>(
|
|||
fn normalize_to_error<'a, 'tcx>(
|
||||
selcx: &mut SelectionContext<'a, 'tcx>,
|
||||
param_env: ty::ParamEnv<'tcx>,
|
||||
projection_ty: ty::ProjectionTy<'tcx>,
|
||||
projection_ty: ty::AliasTy<'tcx>,
|
||||
cause: ObligationCause<'tcx>,
|
||||
depth: usize,
|
||||
) -> NormalizedTy<'tcx> {
|
||||
|
@ -1376,7 +1376,7 @@ fn assemble_candidates_from_trait_def<'cx, 'tcx>(
|
|||
// If so, extract what we know from the trait and try to come up with a good answer.
|
||||
let bounds = match *obligation.predicate.self_ty().kind() {
|
||||
ty::Projection(ref data) => tcx.bound_item_bounds(data.def_id).subst(tcx, data.substs),
|
||||
ty::Opaque(ty::OpaqueTy { def_id, substs }) => {
|
||||
ty::Opaque(ty::AliasTy { def_id, substs }) => {
|
||||
tcx.bound_item_bounds(def_id).subst(tcx, substs)
|
||||
}
|
||||
ty::Infer(ty::TyVar(_)) => {
|
||||
|
@ -1870,7 +1870,7 @@ fn confirm_generator_candidate<'cx, 'tcx>(
|
|||
};
|
||||
|
||||
ty::ProjectionPredicate {
|
||||
projection_ty: ty::ProjectionTy {
|
||||
projection_ty: ty::AliasTy {
|
||||
substs: trait_ref.substs,
|
||||
def_id: obligation.predicate.def_id,
|
||||
},
|
||||
|
@ -1912,7 +1912,7 @@ fn confirm_future_candidate<'cx, 'tcx>(
|
|||
debug_assert_eq!(tcx.associated_item(obligation.predicate.def_id).name, sym::Output);
|
||||
|
||||
ty::ProjectionPredicate {
|
||||
projection_ty: ty::ProjectionTy {
|
||||
projection_ty: ty::AliasTy {
|
||||
substs: trait_ref.substs,
|
||||
def_id: obligation.predicate.def_id,
|
||||
},
|
||||
|
@ -1969,7 +1969,7 @@ fn confirm_builtin_candidate<'cx, 'tcx>(
|
|||
};
|
||||
|
||||
let predicate = ty::ProjectionPredicate {
|
||||
projection_ty: ty::ProjectionTy { substs, def_id: item_def_id },
|
||||
projection_ty: ty::AliasTy { substs, def_id: item_def_id },
|
||||
term,
|
||||
};
|
||||
|
||||
|
@ -2040,7 +2040,7 @@ fn confirm_callable_candidate<'cx, 'tcx>(
|
|||
flag,
|
||||
)
|
||||
.map_bound(|(trait_ref, ret_type)| ty::ProjectionPredicate {
|
||||
projection_ty: ty::ProjectionTy { substs: trait_ref.substs, def_id: fn_once_output_def_id },
|
||||
projection_ty: ty::AliasTy { substs: trait_ref.substs, def_id: fn_once_output_def_id },
|
||||
term: ret_type.into(),
|
||||
});
|
||||
|
||||
|
|
|
@ -205,7 +205,7 @@ impl<'cx, 'tcx> FallibleTypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> {
|
|||
// This is really important. While we *can* handle this, this has
|
||||
// severe performance implications for large opaque types with
|
||||
// late-bound regions. See `issue-88862` benchmark.
|
||||
ty::Opaque(ty::OpaqueTy { def_id, substs }) if !substs.has_escaping_bound_vars() => {
|
||||
ty::Opaque(ty::AliasTy { def_id, substs }) if !substs.has_escaping_bound_vars() => {
|
||||
// Only normalize `impl Trait` outside of type inference, usually in codegen.
|
||||
match self.param_env.reveal() {
|
||||
Reveal::UserFacing => ty.try_super_fold_with(self),
|
||||
|
|
|
@ -536,10 +536,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
|
|||
let ty = traits::normalize_projection_type(
|
||||
self,
|
||||
param_env,
|
||||
ty::ProjectionTy {
|
||||
def_id: tcx.lang_items().deref_target()?,
|
||||
substs: trait_ref.substs,
|
||||
},
|
||||
ty::AliasTy { def_id: tcx.lang_items().deref_target()?, substs: trait_ref.substs },
|
||||
cause.clone(),
|
||||
0,
|
||||
// We're *intentionally* throwing these away,
|
||||
|
@ -830,7 +827,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
|
|||
| ty::GeneratorWitness(_)
|
||||
| ty::Never
|
||||
| ty::Projection(_)
|
||||
| ty::Opaque(ty::OpaqueTy { def_id: _, substs: _ })
|
||||
| ty::Opaque(ty::AliasTy { def_id: _, substs: _ })
|
||||
| ty::Param(_)
|
||||
| ty::Bound(_, _)
|
||||
| ty::Error(_)
|
||||
|
|
|
@ -156,7 +156,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
|
|||
let placeholder_trait_predicate = ty::Binder::dummy(placeholder_trait_predicate);
|
||||
let (def_id, substs) = match *placeholder_self_ty.kind() {
|
||||
ty::Projection(proj) => (proj.def_id, proj.substs),
|
||||
ty::Opaque(ty::OpaqueTy { def_id, substs }) => (def_id, substs),
|
||||
ty::Opaque(ty::AliasTy { def_id, substs }) => (def_id, substs),
|
||||
_ => bug!("projection candidate for unexpected type: {:?}", placeholder_self_ty),
|
||||
};
|
||||
|
||||
|
|
|
@ -1596,7 +1596,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
|
|||
let tcx = self.infcx.tcx;
|
||||
let (def_id, substs) = match *placeholder_trait_predicate.trait_ref.self_ty().kind() {
|
||||
ty::Projection(ref data) => (data.def_id, data.substs),
|
||||
ty::Opaque(ty::OpaqueTy { def_id, substs }) => (def_id, substs),
|
||||
ty::Opaque(ty::AliasTy { def_id, substs }) => (def_id, substs),
|
||||
_ => {
|
||||
span_bug!(
|
||||
obligation.cause.span,
|
||||
|
@ -2260,7 +2260,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
|
|||
t.rebind(def.all_fields().map(|f| f.ty(self.tcx(), substs)).collect())
|
||||
}
|
||||
|
||||
ty::Opaque(ty::OpaqueTy { def_id, substs }) => {
|
||||
ty::Opaque(ty::AliasTy { def_id, substs }) => {
|
||||
// We can resolve the `impl Trait` to its concrete type,
|
||||
// which enforces a DAG between the functions requiring
|
||||
// the auto trait bounds in question.
|
||||
|
|
|
@ -249,7 +249,7 @@ fn extend_cause_with_original_assoc_item_obligation<'tcx>(
|
|||
// An associated item obligation born out of the `trait` failed to be met. An example
|
||||
// can be seen in `ui/associated-types/point-at-type-on-obligation-failure-2.rs`.
|
||||
debug!("extended_cause_with_original_assoc_item_obligation trait proj {:?}", pred);
|
||||
if let ty::Projection(ty::ProjectionTy { def_id, .. }) = *pred.self_ty().kind()
|
||||
if let ty::Projection(ty::AliasTy { def_id, .. }) = *pred.self_ty().kind()
|
||||
&& let Some(&impl_item_id) =
|
||||
tcx.impl_item_implementor_ids(impl_def_id).get(&def_id)
|
||||
&& let Some(impl_item_span) = items
|
||||
|
@ -369,7 +369,7 @@ impl<'tcx> WfPredicates<'tcx> {
|
|||
|
||||
/// Pushes the obligations required for `trait_ref::Item` to be WF
|
||||
/// into `self.out`.
|
||||
fn compute_projection(&mut self, data: ty::ProjectionTy<'tcx>) {
|
||||
fn compute_projection(&mut self, data: ty::AliasTy<'tcx>) {
|
||||
// A projection is well-formed if
|
||||
//
|
||||
// (a) its predicates hold (*)
|
||||
|
@ -648,7 +648,7 @@ impl<'tcx> WfPredicates<'tcx> {
|
|||
// types appearing in the fn signature
|
||||
}
|
||||
|
||||
ty::Opaque(ty::OpaqueTy { def_id, substs }) => {
|
||||
ty::Opaque(ty::AliasTy { def_id, substs }) => {
|
||||
// All of the requirements on type parameters
|
||||
// have already been checked for `impl Trait` in
|
||||
// return position. We do need to check type-alias-impl-trait though.
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue