diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs index f4bbf03f0c26e..07ca6e1157edf 100644 --- a/compiler/rustc_hir_analysis/src/check/check.rs +++ b/compiler/rustc_hir_analysis/src/check/check.rs @@ -905,7 +905,6 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(), tcx.ensure_ok().generics_of(def_id); tcx.ensure_ok().type_of(def_id); tcx.ensure_ok().predicates_of(def_id); - check_type_alias_type_params_are_used(tcx, def_id); if tcx.type_alias_is_lazy(def_id) { res = res.and(enter_wf_checking_ctxt(tcx, def_id, |wfcx| { let ty = tcx.type_of(def_id).instantiate_identity(); @@ -919,7 +918,8 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(), check_where_clauses(wfcx, def_id); Ok(()) })); - check_variances_for_type_defn(tcx, def_id); + } else { + check_type_alias_type_params_are_used(tcx, def_id); } } DefKind::ForeignMod => { @@ -1763,12 +1763,6 @@ fn detect_discriminant_duplicate<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>) } fn check_type_alias_type_params_are_used<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) { - if tcx.type_alias_is_lazy(def_id) { - // Since we compute the variances for lazy type aliases and already reject bivariant - // parameters as unused, we can and should skip this check for lazy type aliases. - return; - } - let generics = tcx.generics_of(def_id); if generics.own_counts().types == 0 { return; diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs index 428d627ad6f2d..dfb42c2539baf 100644 --- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs +++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs @@ -73,7 +73,7 @@ impl<'tcx> WfCheckingCtxt<'_, 'tcx> { ) } - /// Convenience function to *deeply* normalize during wfcheck. In the old solver, + /// Convenience function to *deeply* gormalize during wfcheck. In the old solver, /// this just dispatches to [`WfCheckingCtxt::normalize`], but in the new solver /// this calls `deeply_normalize` and reports errors if they are encountered. /// @@ -1910,12 +1910,6 @@ pub(super) fn check_variances_for_type_defn<'tcx>(tcx: TyCtxt<'tcx>, def_id: Loc DefKind::Enum | DefKind::Struct | DefKind::Union => { // Ok } - DefKind::TyAlias => { - assert!( - tcx.type_alias_is_lazy(def_id), - "should not be computing variance of non-free type alias" - ); - } kind => span_bug!(tcx.def_span(def_id), "cannot compute the variances of {kind:?}"), } @@ -2062,7 +2056,6 @@ fn report_bivariance<'tcx>( errors::UnusedGenericParameterHelp::AdtNoPhantomData { param_name } } } - ItemKind::TyAlias(..) => errors::UnusedGenericParameterHelp::TyAlias { param_name }, item_kind => bug!("report_bivariance: unexpected item kind: {item_kind:?}"), }; @@ -2135,9 +2128,6 @@ impl<'tcx> IsProbablyCyclical<'tcx> { self.tcx.type_of(field.did).instantiate_identity().visit_with(self) }) } - DefKind::TyAlias if self.tcx.type_alias_is_lazy(def_id) => { - self.tcx.type_of(def_id).instantiate_identity().visit_with(self) - } _ => ControlFlow::Continue(()), } } @@ -2147,17 +2137,12 @@ impl<'tcx> TypeVisitor> for IsProbablyCyclical<'tcx> { type Result = ControlFlow<(), ()>; fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<(), ()> { - let def_id = match ty.kind() { - ty::Adt(adt_def, _) => Some(adt_def.did()), - ty::Alias(ty::Free, alias_ty) => Some(alias_ty.def_id), - _ => None, - }; - if let Some(def_id) = def_id { - if def_id == self.item_def_id { + if let Some(adt_def) = ty.ty_adt_def() { + if adt_def.did() == self.item_def_id { return ControlFlow::Break(()); } - if self.seen.insert(def_id) { - self.visit_def(def_id)?; + if self.seen.insert(adt_def.did()) { + self.visit_def(adt_def.did())?; } } ty.super_visit_with(self) diff --git a/compiler/rustc_hir_analysis/src/variance/constraints.rs b/compiler/rustc_hir_analysis/src/variance/constraints.rs index 960ec7f66ab15..2a2a5900699da 100644 --- a/compiler/rustc_hir_analysis/src/variance/constraints.rs +++ b/compiler/rustc_hir_analysis/src/variance/constraints.rs @@ -79,9 +79,6 @@ pub(crate) fn add_constraints_from_crate<'a, 'tcx>( } } DefKind::Fn | DefKind::AssocFn => constraint_cx.build_constraints_for_item(def_id), - DefKind::TyAlias if tcx.type_alias_is_lazy(def_id) => { - constraint_cx.build_constraints_for_item(def_id) - } _ => {} } } @@ -107,15 +104,6 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { let current_item = &CurrentItem { inferred_start }; let ty = tcx.type_of(def_id).instantiate_identity(); - // The type as returned by `type_of` is the underlying type and generally not a free alias. - // Therefore we need to check the `DefKind` first. - if let DefKind::TyAlias = tcx.def_kind(def_id) - && tcx.type_alias_is_lazy(def_id) - { - self.add_constraints_from_ty(current_item, ty, self.covariant); - return; - } - match ty.kind() { ty::Adt(def, _) => { // Not entirely obvious: constraints on structs/enums do not @@ -216,14 +204,13 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { /// Adds constraints appropriate for an instance of `ty` appearing /// in a context with the generics defined in `generics` and /// ambient variance `variance` + #[instrument(level = "debug", skip(self, current))] fn add_constraints_from_ty( &mut self, current: &CurrentItem, ty: Ty<'tcx>, variance: VarianceTermPtr<'a>, ) { - debug!("add_constraints_from_ty(ty={:?}, variance={:?})", ty, variance); - match *ty.kind() { ty::Bool | ty::Char @@ -273,12 +260,13 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { self.add_constraints_from_args(current, def.did(), args, variance); } - ty::Alias(ty::Projection | ty::Inherent | ty::Opaque, ref data) => { - self.add_constraints_from_invariant_args(current, data.args, variance); + ty::Alias(ty::Free, alias_ty) => { + let ty = self.tcx().type_of(alias_ty.def_id).instantiate(self.tcx(), alias_ty.args); + self.add_constraints_from_ty(current, ty, variance); } - ty::Alias(ty::Free, ref data) => { - self.add_constraints_from_args(current, data.def_id, data.args, variance); + ty::Alias(_, ref alias_ty) => { + self.add_constraints_from_invariant_args(current, alias_ty.args, variance); } ty::Dynamic(data, r, _) => { diff --git a/compiler/rustc_hir_analysis/src/variance/mod.rs b/compiler/rustc_hir_analysis/src/variance/mod.rs index 0666b335e093b..044816a4cc7d1 100644 --- a/compiler/rustc_hir_analysis/src/variance/mod.rs +++ b/compiler/rustc_hir_analysis/src/variance/mod.rs @@ -51,11 +51,6 @@ pub(super) fn variances_of(tcx: TyCtxt<'_>, item_def_id: LocalDefId) -> &[ty::Va let crate_map = tcx.crate_variances(()); return crate_map.variances.get(&item_def_id.to_def_id()).copied().unwrap_or(&[]); } - DefKind::TyAlias if tcx.type_alias_is_lazy(item_def_id) => { - // These are inferred. - let crate_map = tcx.crate_variances(()); - return crate_map.variances.get(&item_def_id.to_def_id()).copied().unwrap_or(&[]); - } DefKind::AssocTy => match tcx.opt_rpitit_info(item_def_id.to_def_id()) { Some(ty::ImplTraitInTraitData::Trait { opaque_def_id, .. }) => { return variance_of_opaque( diff --git a/compiler/rustc_hir_analysis/src/variance/terms.rs b/compiler/rustc_hir_analysis/src/variance/terms.rs index cf38957bf24aa..69020db8cf070 100644 --- a/compiler/rustc_hir_analysis/src/variance/terms.rs +++ b/compiler/rustc_hir_analysis/src/variance/terms.rs @@ -99,9 +99,6 @@ pub(crate) fn determine_parameters_to_be_inferred<'a, 'tcx>( } } DefKind::Fn | DefKind::AssocFn => terms_cx.add_inferreds_for_item(def_id), - DefKind::TyAlias if tcx.type_alias_is_lazy(def_id) => { - terms_cx.add_inferreds_for_item(def_id) - } _ => {} } } diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index b0ec605a85fe5..291a838acc044 100644 --- a/compiler/rustc_metadata/src/rmeta/encoder.rs +++ b/compiler/rustc_metadata/src/rmeta/encoder.rs @@ -1163,6 +1163,7 @@ fn should_encode_variances<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, def_kind: Def | DefKind::Static { .. } | DefKind::Const | DefKind::ForeignMod + | DefKind::TyAlias | DefKind::Impl { .. } | DefKind::Trait | DefKind::TraitAlias @@ -1176,7 +1177,6 @@ fn should_encode_variances<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, def_kind: Def | DefKind::Closure | DefKind::ExternCrate | DefKind::SyntheticCoroutineBody => false, - DefKind::TyAlias => tcx.type_alias_is_lazy(def_id), } }