Expand free alias types during variance computation

Author: fmease

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;

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<TyCtxt<'tcx>> 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)

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, _) => {

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(

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)
-            }
             _ => {}
         }
     }

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),
     }
 }