lint incorrect implied bounds in wfcheck

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -330,7 +330,7 @@ fn compare_method_predicate_entailment<'tcx>(
     // lifetime parameters.
     let outlives_env = OutlivesEnvironment::with_bounds(
         param_env,
-        infcx.implied_bounds_tys(param_env, impl_m_def_id, wf_tys.clone()),
+        infcx.implied_bounds_tys_compat(param_env, impl_m_def_id, wf_tys.clone()),
     );
     let errors = infcx.resolve_regions(&outlives_env);
     if !errors.is_empty() {
@@ -724,7 +724,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
     // lifetime parameters.
     let outlives_env = OutlivesEnvironment::with_bounds(
         param_env,
-        infcx.implied_bounds_tys(param_env, impl_m_def_id, wf_tys),
+        infcx.implied_bounds_tys_compat(param_env, impl_m_def_id, wf_tys),
     );
     ocx.resolve_regions_and_report_errors(impl_m_def_id, &outlives_env)?;
 
@@ -2050,7 +2050,8 @@ pub(super) fn check_type_bounds<'tcx>(
 
     // Finally, resolve all regions. This catches wily misuses of
     // lifetime parameters.
-    let implied_bounds = infcx.implied_bounds_tys(param_env, impl_ty_def_id, assumed_wf_types);
+    let implied_bounds =
+        infcx.implied_bounds_tys_compat(param_env, impl_ty_def_id, assumed_wf_types);
     let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
     ocx.resolve_regions_and_report_errors(impl_ty_def_id, &outlives_env)
 }

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -106,17 +106,52 @@ pub(super) fn enter_wf_checking_ctxt<'tcx, F>(
     f(&mut wfcx);
 
     let assumed_wf_types = wfcx.ocx.assumed_wf_types(param_env, span, body_def_id);
-    let implied_bounds = infcx.implied_bounds_tys(param_env, body_def_id, assumed_wf_types);
 
     let errors = wfcx.select_all_or_error();
     if !errors.is_empty() {
         infcx.err_ctxt().report_fulfillment_errors(&errors);
         return;
     }
 
+    let infcx_compat = infcx.fork();
+
+    let implied_bounds = infcx.implied_bounds_tys(param_env, &assumed_wf_types);
     let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
+    let errors = infcx.resolve_regions(&outlives_env);
+    if errors.is_empty() {
+        return;
+    }
+
+    let implied_bounds =
+        infcx_compat.implied_bounds_tys_compat(param_env, body_def_id, assumed_wf_types);
+    let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
+    let errors_compat = infcx_compat.resolve_regions(&outlives_env);
+    if !errors_compat.is_empty() {
+        infcx_compat.err_ctxt().report_region_errors(body_def_id, &errors_compat);
+        return;
+    }
 
-    let _ = wfcx.ocx.resolve_regions_and_report_errors(body_def_id, &outlives_env);
+    let hir_id = tcx.hir().local_def_id_to_hir_id(body_def_id);
+    let (lint_level, _) = tcx
+        .lint_level_at_node(rustc_session::lint::builtin::IMPLIED_BOUNDS_FROM_TRAIT_IMPL, hir_id);
+    tcx.struct_span_lint_hir(
+        rustc_session::lint::builtin::IMPLIED_BOUNDS_FROM_TRAIT_IMPL,
+        hir_id,
+        tcx.def_span(body_def_id),
+        format!("{} is missing necessary lifetime bounds", tcx.def_descr(body_def_id.into())),
+        |lint| {
+            if !lint_level.is_error() {
+                lint.note(
+                    "to get more detailed errors, use `#[deny(implied_bounds_from_trait_impl)]`",
+                )
+            } else {
+                lint.note("more concrete lifetime errors are emitted below")
+            }
+        },
+    );
+    if lint_level.is_error() {
+        infcx.err_ctxt().report_region_errors(body_def_id, &errors);
+    }
 }
 
 fn check_well_formed(tcx: TyCtxt<'_>, def_id: hir::OwnerId) {
@@ -674,7 +709,7 @@ fn resolve_regions_with_wf_tys<'tcx>(
     let infcx = tcx.infer_ctxt().build();
     let outlives_environment = OutlivesEnvironment::with_bounds(
         param_env,
-        infcx.implied_bounds_tys(param_env, id, wf_tys.clone()),
+        infcx.implied_bounds_tys_compat(param_env, id, wf_tys.clone()),
     );
     let region_bound_pairs = outlives_environment.region_bound_pairs();
 

compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs

@@ -176,7 +176,7 @@ fn get_impl_substs(
         return None;
     }
 
-    let implied_bounds = infcx.implied_bounds_tys(param_env, impl1_def_id, assumed_wf_types);
+    let implied_bounds = infcx.implied_bounds_tys_compat(param_env, impl1_def_id, assumed_wf_types);
     let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
     let _ = ocx.resolve_regions_and_report_errors(impl1_def_id, &outlives_env);
     let Ok(impl2_substs) = infcx.fully_resolve(impl2_substs) else {

compiler/rustc_lint_defs/src/builtin.rs

@@ -3304,6 +3304,7 @@ declare_lint_pass! {
         ILL_FORMED_ATTRIBUTE_INPUT,
         ILLEGAL_FLOATING_POINT_LITERAL_PATTERN,
         IMPLIED_BOUNDS_ENTAILMENT,
+        IMPLIED_BOUNDS_FROM_TRAIT_IMPL,
         INCOMPLETE_INCLUDE,
         INDIRECT_STRUCTURAL_MATCH,
         INEFFECTIVE_UNSTABLE_TRAIT_IMPL,
@@ -4172,3 +4173,44 @@ declare_lint! {
     Warn,
     "\"invalid_parameter\" isn't a valid argument for `#[macro_export]`",
 }
+
+declare_lint! {
+    /// The `implied_bounds_from_trait_impl` lint detects
+    /// a compiler bug allowed some code to assume invalid implied lifetime bounds.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,compile_fail
+    /// #![deny(implied_bounds_from_trait_impl)]
+    ///
+    /// trait Trait {
+    ///     type Assoc;
+    /// }
+    ///
+    /// impl<X: 'static> Trait for (X,) {
+    ///     type Assoc = ();
+    /// }
+    ///
+    /// struct Foo<T: Trait>(T)
+    /// where
+    ///     T::Assoc: Clone; // any bound using `T::Assoc`
+    ///
+    /// fn func(foo: Foo<(&str,)>) {
+    ///     let _: &'static str = foo.0.0;
+    /// }
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// FIXME: explanataion
+    ///
+    pub IMPLIED_BOUNDS_FROM_TRAIT_IMPL,
+    Warn,
+    "item uses illegal implied bounds derived from a trait impl",
+    @future_incompatible = FutureIncompatibleInfo {
+        reference: "issue #109628 <https://github.com/rust-lang/rust/issues/109628>",
+        reason: FutureIncompatibilityReason::FutureReleaseError,
+    };
+}

compiler/rustc_middle/src/arena.rs

@@ -56,7 +56,7 @@ macro_rules! arena_types {
                         rustc_middle::traits::query::NormalizationResult<'tcx>
                     >
                 >,
-            [] implied_outlives_bounds:
+            [] implied_outlives_bounds_compat:
                 rustc_middle::infer::canonical::Canonical<'tcx,
                     rustc_middle::infer::canonical::QueryResponse<'tcx,
                         Vec<rustc_middle::traits::query::OutlivesBound<'tcx>>

compiler/rustc_middle/src/query/erase.rs

@@ -59,6 +59,10 @@ impl<T> EraseType for Result<&'_ T, traits::query::NoSolution> {
     type Result = [u8; size_of::<Result<&'static (), traits::query::NoSolution>>()];
 }
 
+impl<T> EraseType for Result<&'_ [T], traits::query::NoSolution> {
+    type Result = [u8; size_of::<Result<&'static [()], traits::query::NoSolution>>()];
+}
+
 impl<T> EraseType for Result<&'_ T, rustc_errors::ErrorGuaranteed> {
     type Result = [u8; size_of::<Result<&'static (), rustc_errors::ErrorGuaranteed>>()];
 }

compiler/rustc_middle/src/query/mod.rs

@@ -1828,7 +1828,7 @@ rustc_queries! {
         desc { "normalizing `{}`", goal.value }
     }
 
-    query implied_outlives_bounds(
+    query implied_outlives_bounds_compat(
         goal: CanonicalTyGoal<'tcx>
     ) -> Result<
         &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, Vec<OutlivesBound<'tcx>>>>,
@@ -1837,6 +1837,12 @@ rustc_queries! {
         desc { "computing implied outlives bounds for `{}`", goal.value.value }
     }
 
+    query implied_outlives_bounds(
+        goal: ParamEnvAnd<'tcx, Ty<'tcx>>
+    ) -> Result<&'tcx [OutlivesBound<'tcx>], NoSolution> {
+        desc { "computing implied outlives bounds v2 for `{}`", goal.value }
+    }
+
     /// Do not call this query directly:
     /// invoke `DropckOutlives::new(dropped_ty)).fully_perform(typeck.infcx)` instead.
     query dropck_outlives(

compiler/rustc_middle/src/traits/query.rs

@@ -209,7 +209,7 @@ pub struct NormalizationResult<'tcx> {
 /// case they are called implied bounds). They are fed to the
 /// `OutlivesEnv` which in turn is supplied to the region checker and
 /// other parts of the inference system.
-#[derive(Clone, Debug, TypeFoldable, TypeVisitable, Lift, HashStable)]
+#[derive(Copy, Clone, Debug, TypeFoldable, TypeVisitable, Lift, HashStable)]
 pub enum OutlivesBound<'tcx> {
     RegionSubRegion(ty::Region<'tcx>, ty::Region<'tcx>),
     RegionSubParam(ty::Region<'tcx>, ty::ParamTy),

compiler/rustc_trait_selection/src/solve/eval_ctxt.rs

@@ -658,8 +658,13 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
         param_env: ty::ParamEnv<'tcx>,
         arg: ty::GenericArg<'tcx>,
     ) -> Option<impl Iterator<Item = Goal<'tcx, ty::Predicate<'tcx>>>> {
-        crate::traits::wf::unnormalized_obligations(self.infcx, param_env, arg)
-            .map(|obligations| obligations.into_iter().map(|obligation| obligation.into()))
+        debug_assert_eq!(arg, self.infcx.resolve_vars_if_possible(arg));
+        // FIXME: useless `Option` in return type?
+        Some(
+            crate::traits::wf::unnormalized_obligations(self.tcx(), param_env, arg)
+                .into_iter()
+                .map(|obligation| obligation.into()),
+        )
     }
 
     pub(super) fn is_transmutable(

compiler/rustc_trait_selection/src/traits/coherence.rs

@@ -403,7 +403,7 @@ fn resolve_negative_obligation<'tcx>(
     let wf_tys = ocx.assumed_wf_types(param_env, DUMMY_SP, body_def_id);
     let outlives_env = OutlivesEnvironment::with_bounds(
         param_env,
-        infcx.implied_bounds_tys(param_env, body_def_id, wf_tys),
+        infcx.implied_bounds_tys_compat(param_env, body_def_id, wf_tys),
     );
     infcx.resolve_regions(&outlives_env).is_empty()
 }

compiler/rustc_trait_selection/src/traits/misc.rs

@@ -190,7 +190,7 @@ pub fn all_fields_implement_trait<'tcx>(
             // Check regions assuming the self type of the impl is WF
             let outlives_env = OutlivesEnvironment::with_bounds(
                 param_env,
-                infcx.implied_bounds_tys(
+                infcx.implied_bounds_tys_compat(
                     param_env,
                     parent_cause.body_id,
                     FxIndexSet::from_iter([self_type]),

compiler/rustc_trait_selection/src/traits/outlives_bounds.rs

@@ -3,26 +3,34 @@ use crate::traits::query::type_op::{self, TypeOp, TypeOpOutput};
 use crate::traits::query::NoSolution;
 use crate::traits::{ObligationCause, ObligationCtxt};
 use rustc_data_structures::fx::FxIndexSet;
+use rustc_hir::def_id::LocalDefId;
 use rustc_infer::infer::resolve::OpportunisticRegionResolver;
 use rustc_middle::ty::{self, ParamEnv, Ty, TypeFolder, TypeVisitableExt};
-use rustc_span::def_id::LocalDefId;
+use rustc_span::DUMMY_SP;
 
 pub use rustc_middle::traits::query::OutlivesBound;
 
+type BoundsCompat<'a, 'tcx: 'a> = impl Iterator<Item = OutlivesBound<'tcx>> + 'a;
 type Bounds<'a, 'tcx: 'a> = impl Iterator<Item = OutlivesBound<'tcx>> + 'a;
 pub trait InferCtxtExt<'a, 'tcx> {
-    fn implied_outlives_bounds(
+    fn implied_outlives_bounds_compat(
         &self,
         param_env: ty::ParamEnv<'tcx>,
         body_id: LocalDefId,
         ty: Ty<'tcx>,
     ) -> Vec<OutlivesBound<'tcx>>;
 
-    fn implied_bounds_tys(
+    fn implied_bounds_tys_compat(
         &'a self,
         param_env: ty::ParamEnv<'tcx>,
         body_id: LocalDefId,
         tys: FxIndexSet<Ty<'tcx>>,
+    ) -> BoundsCompat<'a, 'tcx>;
+
+    fn implied_bounds_tys(
+        &'a self,
+        param_env: ty::ParamEnv<'tcx>,
+        tys: &'a FxIndexSet<Ty<'tcx>>,
     ) -> Bounds<'a, 'tcx>;
 }
 
@@ -47,7 +55,7 @@ impl<'a, 'tcx: 'a> InferCtxtExt<'a, 'tcx> for InferCtxt<'tcx> {
     ///   into the inference context with this body-id.
     /// - `ty`, the type that we are supposed to assume is WF.
     #[instrument(level = "debug", skip(self, param_env, body_id), ret)]
-    fn implied_outlives_bounds(
+    fn implied_outlives_bounds_compat(
         &self,
         param_env: ty::ParamEnv<'tcx>,
         body_id: LocalDefId,
@@ -115,12 +123,33 @@ impl<'a, 'tcx: 'a> InferCtxtExt<'a, 'tcx> for InferCtxt<'tcx> {
         output
     }
 
-    fn implied_bounds_tys(
+    fn implied_bounds_tys_compat(
         &'a self,
         param_env: ParamEnv<'tcx>,
         body_id: LocalDefId,
         tys: FxIndexSet<Ty<'tcx>>,
+    ) -> BoundsCompat<'a, 'tcx> {
+        tys.into_iter()
+            .flat_map(move |ty| self.implied_outlives_bounds_compat(param_env, body_id, ty))
+    }
+
+    fn implied_bounds_tys(
+        &'a self,
+        param_env: ParamEnv<'tcx>,
+        tys: &'a FxIndexSet<Ty<'tcx>>,
     ) -> Bounds<'a, 'tcx> {
-        tys.into_iter().flat_map(move |ty| self.implied_outlives_bounds(param_env, body_id, ty))
+        tys.iter()
+            .flat_map(move |&ty| {
+                let ty = self.resolve_vars_if_possible(ty);
+                let ty = OpportunisticRegionResolver::new(self).fold_ty(ty);
+                if ty.has_infer() {
+                    // Infer vars can appear only in invalid code. See #110161.
+                    self.tcx.sess.delay_span_bug(DUMMY_SP, "infer vars in implied bounds");
+                    return &[] as &[OutlivesBound<'_>];
+                }
+
+                self.tcx.implied_outlives_bounds(param_env.and(ty)).unwrap_or(&[])
+            })
+            .copied()
     }
 }

compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs

@@ -37,6 +37,6 @@ impl<'tcx> super::QueryTypeOp<'tcx> for ImpliedOutlivesBounds<'tcx> {
             param_env.and(ty)
         });
 
-        tcx.implied_outlives_bounds(canonicalized)
+        tcx.implied_outlives_bounds_compat(canonicalized)
     }
 }

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -77,21 +77,20 @@ pub fn obligations<'tcx>(
 
 /// Compute the predicates that are required for a type to be well-formed.
 ///
-/// This is only intended to be used in the new solver, since it does not
-/// take into account recursion depth or proper error-reporting spans.
+/// This is only intended to be used in implied bounds computation and in
+/// the new solver, since it does not take into account recursion depth or
+/// proper error-reporting spans.
 pub fn unnormalized_obligations<'tcx>(
-    infcx: &InferCtxt<'tcx>,
+    tcx: TyCtxt<'tcx>,
     param_env: ty::ParamEnv<'tcx>,
     arg: GenericArg<'tcx>,
-) -> Option<Vec<traits::PredicateObligation<'tcx>>> {
+) -> Vec<traits::PredicateObligation<'tcx>> {
     if let ty::GenericArgKind::Lifetime(..) = arg.unpack() {
-        return Some(vec![]);
+        return vec![];
     }
 
-    debug_assert_eq!(arg, infcx.resolve_vars_if_possible(arg));
-
     let mut wf = WfPredicates {
-        tcx: infcx.tcx,
+        tcx,
         param_env,
         body_id: CRATE_DEF_ID,
         span: DUMMY_SP,
@@ -100,7 +99,7 @@ pub fn unnormalized_obligations<'tcx>(
         item: None,
     };
     wf.compute(arg);
-    Some(wf.out)
+    wf.out
 }
 
 /// Returns the obligations that make this trait reference