Auto merge of #148823 - lcnr:generalize-no-subtyping, r=<try>

TypeRelating emit WellFormed, not generalize

Author: rust-bors[bot]

compiler/rustc_borrowck/src/polonius/liveness_constraints.rs

@@ -2,7 +2,9 @@ use std::collections::BTreeMap;
 
 use rustc_index::bit_set::SparseBitMatrix;
 use rustc_middle::mir::{Body, Location};
-use rustc_middle::ty::relate::{self, Relate, RelateResult, TypeRelation};
+use rustc_middle::ty::relate::{
+    self, Relate, RelateResult, TypeRelation, relate_args_with_variances,
+};
 use rustc_middle::ty::{self, RegionVid, Ty, TyCtxt, TypeVisitable};
 use rustc_mir_dataflow::points::PointIndex;
 
@@ -256,6 +258,18 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for VarianceExtractor<'_, 'tcx> {
         self.tcx
     }
 
+    fn relate_item_args(
+        &mut self,
+        item_def_id: rustc_hir::def_id::DefId,
+        a_arg: ty::GenericArgsRef<'tcx>,
+        b_arg: ty::GenericArgsRef<'tcx>,
+        f: impl FnOnce(ty::GenericArgsRef<'tcx>) -> Ty<'tcx>,
+    ) -> RelateResult<'tcx, Ty<'tcx>> {
+        let variances = self.cx().variances_of(item_def_id);
+        let args = relate_args_with_variances(self, item_def_id, variances, a_arg, b_arg, false)?;
+        Ok(f(args))
+    }
+
     fn relate_with_variance<T: Relate<TyCtxt<'tcx>>>(
         &mut self,
         variance: ty::Variance,

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -10,6 +10,7 @@ use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::traits::ObligationCause;
 use rustc_middle::traits::query::NoSolution;
 use rustc_middle::ty::relate::combine::{super_combine_consts, super_combine_tys};
+use rustc_middle::ty::relate::relate_args_with_variances;
 use rustc_middle::ty::{self, FnMutDelegate, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::{bug, span_bug};
 use rustc_span::{Span, Symbol, sym};
@@ -303,6 +304,23 @@ impl<'b, 'tcx> TypeRelation<TyCtxt<'tcx>> for NllTypeRelating<'_, 'b, 'tcx> {
         self.type_checker.infcx.tcx
     }
 
+    fn relate_item_args(
+        &mut self,
+        item_def_id: rustc_hir::def_id::DefId,
+        a_arg: ty::GenericArgsRef<'tcx>,
+        b_arg: ty::GenericArgsRef<'tcx>,
+        f: impl FnOnce(ty::GenericArgsRef<'tcx>) -> Ty<'tcx>,
+    ) -> RelateResult<'tcx, Ty<'tcx>> {
+        let tcx = self.cx();
+        let variances = tcx.variances_of(item_def_id);
+        let args = relate_args_with_variances(self, item_def_id, variances, a_arg, b_arg, true)?;
+        let ty = f(args);
+        if variances.iter().any(|&v| v == ty::Bivariant) {
+            self.register_predicates([ty::ClauseKind::WellFormed(ty.into())]);
+        }
+        Ok(ty)
+    }
+
     #[instrument(skip(self, info), level = "trace", ret)]
     fn relate_with_variance<T: Relate<TyCtxt<'tcx>>>(
         &mut self,

compiler/rustc_infer/src/infer/outlives/test_type_match.rs

@@ -3,6 +3,7 @@ use std::collections::hash_map::Entry;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_middle::ty::error::TypeError;
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt};
+use rustc_type_ir::relate::relate_args_with_variances;
 use tracing::instrument;
 
 use crate::infer::region_constraints::VerifyIfEq;
@@ -137,6 +138,22 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for MatchAgainstHigherRankedOutlives<'tcx>
         self.tcx
     }
 
+    fn relate_item_args(
+        &mut self,
+        item_def_id: rustc_hir::def_id::DefId,
+        a_arg: ty::GenericArgsRef<'tcx>,
+        b_arg: ty::GenericArgsRef<'tcx>,
+        f: impl FnOnce(ty::GenericArgsRef<'tcx>) -> Ty<'tcx>,
+    ) -> RelateResult<'tcx, Ty<'tcx>> {
+        // FIXME(@lcnr): This is weird. We are ignoring variance
+        // here, effectively treating everything as either covariant
+        // or contravariant, as we only ever check whether the context is
+        // bivariant.
+        let variances = self.cx().variances_of(item_def_id);
+        let args = relate_args_with_variances(self, item_def_id, variances, a_arg, b_arg, false)?;
+        Ok(f(args))
+    }
+
     #[instrument(level = "trace", skip(self))]
     fn relate_with_variance<T: Relate<TyCtxt<'tcx>>>(
         &mut self,

compiler/rustc_infer/src/infer/relate/generalize.rs

@@ -70,14 +70,13 @@ impl<'tcx> InferCtxt<'tcx> {
         //
         // We then relate `generalized_ty <: source_ty`, adding constraints like `'x: '?2` and
         // `?1 <: ?3`.
-        let Generalization { value_may_be_infer: generalized_ty, has_unconstrained_ty_var } = self
-            .generalize(
-                relation.span(),
-                relation.structurally_relate_aliases(),
-                target_vid,
-                instantiation_variance,
-                source_ty,
-            )?;
+        let Generalization { value_may_be_infer: generalized_ty } = self.generalize(
+            relation.span(),
+            relation.structurally_relate_aliases(),
+            target_vid,
+            instantiation_variance,
+            source_ty,
+        )?;
 
         // Constrain `b_vid` to the generalized type `generalized_ty`.
         if let &ty::Infer(ty::TyVar(generalized_vid)) = generalized_ty.kind() {
@@ -86,11 +85,6 @@ impl<'tcx> InferCtxt<'tcx> {
             self.inner.borrow_mut().type_variables().instantiate(target_vid, generalized_ty);
         }
 
-        // See the comment on `Generalization::has_unconstrained_ty_var`.
-        if has_unconstrained_ty_var {
-            relation.register_predicates([ty::ClauseKind::WellFormed(generalized_ty.into())]);
-        }
-
         // Finally, relate `generalized_ty` to `source_ty`, as described in previous comment.
         //
         // FIXME(#16847): This code is non-ideal because all these subtype
@@ -210,19 +204,15 @@ impl<'tcx> InferCtxt<'tcx> {
     ) -> RelateResult<'tcx, ()> {
         // FIXME(generic_const_exprs): Occurs check failures for unevaluated
         // constants and generic expressions are not yet handled correctly.
-        let Generalization { value_may_be_infer: generalized_ct, has_unconstrained_ty_var } = self
-            .generalize(
-                relation.span(),
-                relation.structurally_relate_aliases(),
-                target_vid,
-                ty::Invariant,
-                source_ct,
-            )?;
+        let Generalization { value_may_be_infer: generalized_ct } = self.generalize(
+            relation.span(),
+            relation.structurally_relate_aliases(),
+            target_vid,
+            ty::Invariant,
+            source_ct,
+        )?;
 
         debug_assert!(!generalized_ct.is_ct_infer());
-        if has_unconstrained_ty_var {
-            bug!("unconstrained ty var when generalizing `{source_ct:?}`");
-        }
 
         self.inner
             .borrow_mut()
@@ -281,12 +271,10 @@ impl<'tcx> InferCtxt<'tcx> {
             ambient_variance,
             in_alias: false,
             cache: Default::default(),
-            has_unconstrained_ty_var: false,
         };
 
         let value_may_be_infer = generalizer.relate(source_term, source_term)?;
-        let has_unconstrained_ty_var = generalizer.has_unconstrained_ty_var;
-        Ok(Generalization { value_may_be_infer, has_unconstrained_ty_var })
+        Ok(Generalization { value_may_be_infer })
     }
 }
 
@@ -376,9 +364,6 @@ struct Generalizer<'me, 'tcx> {
     in_alias: bool,
 
     cache: SsoHashMap<(Ty<'tcx>, ty::Variance, bool), Ty<'tcx>>,
-
-    /// See the field `has_unconstrained_ty_var` in `Generalization`.
-    has_unconstrained_ty_var: bool,
 }
 
 impl<'tcx> Generalizer<'_, 'tcx> {
@@ -391,10 +376,8 @@ impl<'tcx> Generalizer<'_, 'tcx> {
     }
 
     /// Create a new type variable in the universe of the target when
-    /// generalizing an alias. This has to set `has_unconstrained_ty_var`
-    /// if we're currently in a bivariant context.
+    /// generalizing an alias.
     fn next_ty_var_for_alias(&mut self) -> Ty<'tcx> {
-        self.has_unconstrained_ty_var |= self.ambient_variance == ty::Bivariant;
         self.infcx.next_ty_var_in_universe(self.span, self.for_universe)
     }
 
@@ -466,24 +449,19 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
         item_def_id: DefId,
         a_arg: ty::GenericArgsRef<'tcx>,
         b_arg: ty::GenericArgsRef<'tcx>,
-    ) -> RelateResult<'tcx, ty::GenericArgsRef<'tcx>> {
-        if self.ambient_variance == ty::Invariant {
+        f: impl FnOnce(ty::GenericArgsRef<'tcx>) -> Ty<'tcx>,
+    ) -> RelateResult<'tcx, Ty<'tcx>> {
+        let args = if self.ambient_variance == ty::Invariant {
             // Avoid fetching the variance if we are in an invariant
             // context; no need, and it can induce dependency cycles
             // (e.g., #41849).
             relate::relate_args_invariantly(self, a_arg, b_arg)
         } else {
             let tcx = self.cx();
-            let opt_variances = tcx.variances_of(item_def_id);
-            relate::relate_args_with_variances(
-                self,
-                item_def_id,
-                opt_variances,
-                a_arg,
-                b_arg,
-                false,
-            )
-        }
+            let variances = tcx.variances_of(item_def_id);
+            relate::relate_args_with_variances(self, item_def_id, variances, a_arg, b_arg, false)
+        }?;
+        Ok(f(args))
     }
 
     #[instrument(level = "debug", skip(self, variance, b), ret)]
@@ -545,14 +523,8 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
                                     }
                                 }
 
-                                // Bivariant: make a fresh var, but remember that
-                                // it is unconstrained. See the comment in
-                                // `Generalization`.
-                                ty::Bivariant => self.has_unconstrained_ty_var = true,
-
-                                // Co/contravariant: this will be
-                                // sufficiently constrained later on.
-                                ty::Covariant | ty::Contravariant => (),
+                                // We do need a fresh type variable otherwise.
+                                ty::Bivariant | ty::Covariant | ty::Contravariant => (),
                             }
 
                             let origin = inner.type_variables().var_origin(vid);
@@ -771,32 +743,8 @@ struct Generalization<T> {
     /// for `?0` generalization returns an inference
     /// variable.
     ///
-    /// This has to be handled wotj care as it can
+    /// This has to be handled with care as it can
     /// otherwise very easily result in infinite
     /// recursion.
     pub value_may_be_infer: T,
-
-    /// In general, we do not check whether all types which occur during
-    /// type checking are well-formed. We only check wf of user-provided types
-    /// and when actually using a type, e.g. for method calls.
-    ///
-    /// This means that when subtyping, we may end up with unconstrained
-    /// inference variables if a generalized type has bivariant parameters.
-    /// A parameter may only be bivariant if it is constrained by a projection
-    /// bound in a where-clause. As an example, imagine a type:
-    ///
-    ///     struct Foo<A, B> where A: Iterator<Item = B> {
-    ///         data: A
-    ///     }
-    ///
-    /// here, `A` will be covariant, but `B` is unconstrained.
-    ///
-    /// However, whatever it is, for `Foo` to be WF, it must be equal to `A::Item`.
-    /// If we have an input `Foo<?A, ?B>`, then after generalization we will wind
-    /// up with a type like `Foo<?C, ?D>`. When we enforce `Foo<?A, ?B> <: Foo<?C, ?D>`,
-    /// we will wind up with the requirement that `?A <: ?C`, but no particular
-    /// relationship between `?B` and `?D` (after all, these types may be completely
-    /// different). If we do nothing else, this may mean that `?D` goes unconstrained
-    /// (as in #41677). To avoid this we emit a `WellFormed` obligation in these cases.
-    pub has_unconstrained_ty_var: bool,
 }

compiler/rustc_infer/src/infer/relate/lattice.rs

@@ -22,6 +22,7 @@ use rustc_middle::ty::relate::combine::{super_combine_consts, super_combine_tys}
 use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation};
 use rustc_middle::ty::{self, Ty, TyCtxt, TyVar, TypeVisitableExt};
 use rustc_span::Span;
+use rustc_type_ir::relate::relate_args_with_variances;
 use tracing::{debug, instrument};
 
 use super::StructurallyRelateAliases;
@@ -75,6 +76,22 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for LatticeOp<'_, 'tcx> {
         self.infcx.tcx
     }
 
+    fn relate_item_args(
+        &mut self,
+        item_def_id: rustc_hir::def_id::DefId,
+        a_arg: ty::GenericArgsRef<'tcx>,
+        b_arg: ty::GenericArgsRef<'tcx>,
+        f: impl FnOnce(ty::GenericArgsRef<'tcx>) -> Ty<'tcx>,
+    ) -> RelateResult<'tcx, Ty<'tcx>> {
+        let variances = self.cx().variances_of(item_def_id);
+        let args = relate_args_with_variances(self, item_def_id, variances, a_arg, b_arg, false)?;
+        let ty = f(args);
+        if variances.iter().any(|&v| v == ty::Bivariant) {
+            self.register_predicates([ty::ClauseKind::WellFormed(ty.into())]);
+        }
+        Ok(ty)
+    }
+
     fn relate_with_variance<T: Relate<TyCtxt<'tcx>>>(
         &mut self,
         variance: ty::Variance,

compiler/rustc_infer/src/infer/relate/type_relating.rs

@@ -84,17 +84,24 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for TypeRelating<'_, 'tcx> {
         item_def_id: rustc_hir::def_id::DefId,
         a_arg: ty::GenericArgsRef<'tcx>,
         b_arg: ty::GenericArgsRef<'tcx>,
-    ) -> RelateResult<'tcx, ty::GenericArgsRef<'tcx>> {
+        f: impl FnOnce(ty::GenericArgsRef<'tcx>) -> Ty<'tcx>,
+    ) -> RelateResult<'tcx, Ty<'tcx>> {
         if self.ambient_variance == ty::Invariant {
             // Avoid fetching the variance if we are in an invariant
             // context; no need, and it can induce dependency cycles
             // (e.g., #41849).
-            relate_args_invariantly(self, a_arg, b_arg)
-        } else {
-            let tcx = self.cx();
-            let opt_variances = tcx.variances_of(item_def_id);
-            relate_args_with_variances(self, item_def_id, opt_variances, a_arg, b_arg, false)
+            let args = relate_args_invariantly(self, a_arg, b_arg)?;
+            return Ok(f(args));
+        }
+
+        let tcx = self.cx();
+        let variances = tcx.variances_of(item_def_id);
+        let args = relate_args_with_variances(self, item_def_id, variances, a_arg, b_arg, false)?;
+        let ty = f(args);
+        if variances.iter().any(|&v| v == ty::Bivariant) {
+            self.register_predicates([ty::ClauseKind::WellFormed(ty.into())]);
         }
+        Ok(ty)
     }
 
     fn relate_with_variance<T: Relate<TyCtxt<'tcx>>>(

compiler/rustc_lint/src/impl_trait_overcaptures.rs

@@ -12,7 +12,8 @@ use rustc_infer::infer::outlives::env::OutlivesEnvironment;
 use rustc_macros::LintDiagnostic;
 use rustc_middle::middle::resolve_bound_vars::ResolvedArg;
 use rustc_middle::ty::relate::{
-    Relate, RelateResult, TypeRelation, structurally_relate_consts, structurally_relate_tys,
+    Relate, RelateResult, TypeRelation, relate_args_with_variances, structurally_relate_consts,
+    structurally_relate_tys,
 };
 use rustc_middle::ty::{
     self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
@@ -502,6 +503,18 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for FunctionalVariances<'tcx> {
         self.tcx
     }
 
+    fn relate_item_args(
+        &mut self,
+        item_def_id: rustc_hir::def_id::DefId,
+        a_arg: ty::GenericArgsRef<'tcx>,
+        b_arg: ty::GenericArgsRef<'tcx>,
+        f: impl FnOnce(ty::GenericArgsRef<'tcx>) -> Ty<'tcx>,
+    ) -> RelateResult<'tcx, Ty<'tcx>> {
+        let variances = self.cx().variances_of(item_def_id);
+        let args = relate_args_with_variances(self, item_def_id, variances, a_arg, b_arg, false)?;
+        Ok(f(args))
+    }
+
     fn relate_with_variance<T: Relate<TyCtxt<'tcx>>>(
         &mut self,
         variance: ty::Variance,

compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs

@@ -235,8 +235,9 @@ where
             // See <https://github.com/rust-lang/trait-system-refactor-initiative/issues/185>.
             ecx.try_evaluate_added_goals()?;
 
-            // Add GAT where clauses from the trait's definition.
-            // FIXME: We don't need these, since these are the type's own WF obligations.
+            // Add GAT where clauses from the trait's definition. This is necessary
+            // for soundness until we properly handle implied bounds on binders,
+            // see tests/ui/generic-associated-types/must-prove-where-clauses-on-norm.rs.
             ecx.add_goals(
                 GoalSource::AliasWellFormed,
                 cx.own_predicates_of(goal.predicate.def_id())

compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs

@@ -2258,6 +2258,17 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for SameTypeModuloInfer<'_, 'tcx> {
         self.0.tcx
     }
 
+    fn relate_item_args(
+        &mut self,
+        _: rustc_hir::def_id::DefId,
+        a_arg: ty::GenericArgsRef<'tcx>,
+        b_arg: ty::GenericArgsRef<'tcx>,
+        f: impl FnOnce(ty::GenericArgsRef<'tcx>) -> Ty<'tcx>,
+    ) -> RelateResult<'tcx, Ty<'tcx>> {
+        let args = relate::relate_args_invariantly(self, a_arg, b_arg)?;
+        Ok(f(args))
+    }
+
     fn relate_with_variance<T: relate::Relate<TyCtxt<'tcx>>>(
         &mut self,
         _variance: ty::Variance,