Expand free alias types during variance computation

Author: fmease

compiler/rustc_hir_analysis/src/check/check.rs

@@ -951,7 +951,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);
             let ty = tcx.type_of(def_id).instantiate_identity();
             let span = tcx.def_span(def_id);
             if tcx.type_alias_is_lazy(def_id) {
@@ -965,8 +964,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);
                 res = res.and(enter_wf_checking_ctxt(tcx, def_id, |wfcx| {
                     // HACK: We sometimes incidentally check that const arguments have the correct
                     // type as a side effect of the anon const desugaring. To make this "consistent"
@@ -2013,12 +2012,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

@@ -2006,12 +2006,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:?}"),
     }
 
@@ -2158,7 +2152,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:?}"),
     };
 
@@ -2236,9 +2229,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(()),
         }
     }
@@ -2248,17 +2238,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,15 @@ 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) => {
+                // For performance reasons, we can't just call
+                // `expand_free_alias_tys` at the start of this function.
+                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/dump.rs

@@ -38,18 +38,16 @@ pub(crate) fn variances(tcx: TyCtxt<'_>) {
         }
 
         match tcx.def_kind(id) {
-            DefKind::AssocFn | DefKind::Fn | DefKind::Enum | DefKind::Struct | DefKind::Union => {}
-            DefKind::TyAlias if tcx.type_alias_is_lazy(id) => {}
+            DefKind::AssocFn | DefKind::Fn | DefKind::Enum | DefKind::Struct | DefKind::Union => {
+                tcx.dcx().span_err(tcx.def_span(id), format_variances(tcx, id.def_id));
+            }
             kind => {
                 let message = format!(
                     "attr parsing didn't report an error for `#[{}]` on {kind:?}",
                     rustc_span::sym::rustc_dump_variances,
                 );
                 tcx.dcx().span_delayed_bug(tcx.def_span(id), message);
-                continue;
             }
         }
-
-        tcx.dcx().span_err(tcx.def_span(id), format_variances(tcx, id.def_id));
     }
 }

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

@@ -1147,6 +1147,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
@@ -1160,7 +1161,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),
     }
 }
 

tests/ui/lazy-type-alias/def-site-body-wf.rs

@@ -0,0 +1,18 @@
+// Test that we check the body at the definition site for well-formedness.
+
+#![feature(lazy_type_alias)]
+
+// unsatisified trait bounds
+type _A<T> = <T as std::ops::Mul>::Output; //~ ERROR cannot multiply `T` by `T`
+type _B = Vec<str>; //~ ERROR the size for values of type `str` cannot be known at compilation time
+
+// unsatisfied outlives-bounds
+type _C<'a> = &'static &'a (); //~ ERROR reference has a longer lifetime than the data it references
+
+// diverging const exprs
+type _D = [(); panic!()]; //~ ERROR evaluation panicked
+
+// dyn incompatibility
+type _E = dyn Sized; //~ ERROR the trait `Sized` is not dyn compatible
+
+fn main() {}

tests/ui/lazy-type-alias/def-site-body-wf.stderr

@@ -0,0 +1,54 @@
+error[E0277]: cannot multiply `T` by `T`
+  --> $DIR/def-site-body-wf.rs:6:14
+   |
+LL | type _A<T> = <T as std::ops::Mul>::Output;
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no implementation for `T * T`
+   |
+help: consider restricting type parameter `T` with trait `Mul`
+   |
+LL | type _A<T: std::ops::Mul> = <T as std::ops::Mul>::Output;
+   |          +++++++++++++++
+
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+  --> $DIR/def-site-body-wf.rs:7:11
+   |
+LL | type _B = Vec<str>;
+   |           ^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `str`
+note: required by an implicit `Sized` bound in `Vec`
+  --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+
+error[E0491]: in type `&'static &'a ()`, reference has a longer lifetime than the data it references
+  --> $DIR/def-site-body-wf.rs:10:1
+   |
+LL | type _C<'a> = &'static &'a ();
+   | ^^^^^^^^^^^
+   |
+   = note: the pointer is valid for the static lifetime
+note: but the referenced data is only valid for the lifetime `'a` as defined here
+  --> $DIR/def-site-body-wf.rs:10:9
+   |
+LL | type _C<'a> = &'static &'a ();
+   |         ^^
+
+error[E0080]: evaluation panicked: explicit panic
+  --> $DIR/def-site-body-wf.rs:13:16
+   |
+LL | type _D = [(); panic!()];
+   |                ^^^^^^^^ evaluation of `_D::{constant#0}` failed here
+
+error[E0038]: the trait `Sized` is not dyn compatible
+  --> $DIR/def-site-body-wf.rs:16:11
+   |
+LL | type _E = dyn Sized;
+   |           ^^^^^^^^^ `Sized` is not dyn compatible
+   |
+   = note: the trait is not dyn compatible because it requires `Self: Sized`
+   = note: for a trait to be dyn compatible it needs to allow building a vtable
+           for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+
+error: aborting due to 5 previous errors
+
+Some errors have detailed explanations: E0038, E0080, E0277, E0491.
+For more information about an error, try `rustc --explain E0038`.

tests/ui/lazy-type-alias/inherent-impls-overflow.current.stderr

@@ -23,15 +23,15 @@ LL | type Poly0<T> = Poly1<(T,)>;
    = note: in case this is a recursive type alias, consider using a struct, enum, or union instead
 
 error[E0275]: overflow normalizing the type alias `Poly1<(((((((...,),),),),),),)>`
-  --> $DIR/inherent-impls-overflow.rs:21:1
+  --> $DIR/inherent-impls-overflow.rs:20:1
    |
 LL | type Poly1<T> = Poly0<(T,)>;
    | ^^^^^^^^^^^^^
    |
    = note: in case this is a recursive type alias, consider using a struct, enum, or union instead
 
 error[E0275]: overflow normalizing the type alias `Poly1<(((((((...,),),),),),),)>`
-  --> $DIR/inherent-impls-overflow.rs:26:1
+  --> $DIR/inherent-impls-overflow.rs:24:1
    |
 LL | impl Poly0<()> {}
    | ^^^^^^^^^^^^^^^^^