Don't emit IMPLIED_BOUNDS_FROM_TRAIT_IMPL for Bevy dependents

Author: jackh726

compiler/rustc_hir_analysis/src/check/check.rs

@@ -355,7 +355,7 @@ fn check_opaque_meets_bounds<'tcx>(
         // Can have different predicates to their defining use
         hir::OpaqueTyOrigin::TyAlias { .. } => {
             let wf_tys = ocx.assumed_wf_types_and_report_errors(param_env, def_id)?;
-            let implied_bounds = infcx.implied_bounds_tys_compat(param_env, def_id, wf_tys);
+            let implied_bounds = infcx.implied_bounds_tys_compat(param_env, def_id, &wf_tys);
             let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
             ocx.resolve_regions_and_report_errors(defining_use_anchor, &outlives_env)?;
         }

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -404,7 +404,7 @@ fn compare_method_predicate_entailment<'tcx>(
     // lifetime parameters.
     let outlives_env = OutlivesEnvironment::with_bounds(
         param_env,
-        infcx.implied_bounds_tys_compat(param_env, impl_m_def_id, wf_tys),
+        infcx.implied_bounds_tys_compat(param_env, impl_m_def_id, &wf_tys),
     );
     let errors = infcx.resolve_regions(&outlives_env);
     if !errors.is_empty() {
@@ -880,7 +880,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_compat(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)?;
 
@@ -2240,7 +2240,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_compat(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/compare_impl_item/refine.rs

@@ -161,7 +161,7 @@ pub(super) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
     }
     let outlives_env = OutlivesEnvironment::with_bounds(
         param_env,
-        infcx.implied_bounds_tys_compat(param_env, impl_m.def_id.expect_local(), implied_wf_types),
+        infcx.implied_bounds_tys_compat(param_env, impl_m.def_id.expect_local(), &implied_wf_types),
     );
     let errors = infcx.resolve_regions(&outlives_env);
     if !errors.is_empty() {

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -13,6 +13,7 @@ use rustc_infer::infer::outlives::obligations::TypeOutlives;
 use rustc_infer::infer::{self, InferCtxt, TyCtxtInferExt};
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::query::Providers;
+use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::trait_def::TraitSpecializationKind;
 use rustc_middle::ty::{
     self, AdtKind, GenericParamDefKind, ToPredicate, Ty, TyCtxt, TypeFoldable, TypeSuperVisitable,
@@ -126,6 +127,7 @@ where
 
     let infcx_compat = infcx.fork();
 
+    debug!(?assumed_wf_types);
     let implied_bounds = infcx.implied_bounds_tys(param_env, &assumed_wf_types);
     let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
 
@@ -135,13 +137,26 @@ where
     }
 
     let implied_bounds =
-        infcx_compat.implied_bounds_tys_compat(param_env, body_def_id, assumed_wf_types);
+        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() {
         return Err(infcx_compat.err_ctxt().report_region_errors(body_def_id, &errors_compat));
     }
 
+    // We don't want to emit this for dependents of Bevy, for now.
+    for ty in assumed_wf_types.iter() {
+        match ty.kind() {
+            ty::Adt(def, _) => {
+                let adt_did = with_no_trimmed_paths!(infcx.tcx.def_path_str(def.0.did));
+                if adt_did == "bevy_ecs::system::ParamSet" {
+                    return Ok(());
+                }
+            }
+            _ => {}
+        }
+    }
+
     let hir_id = tcx.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);
@@ -752,7 +767,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_compat(param_env, id, wf_tys.clone()),
+        infcx.implied_bounds_tys_compat(param_env, id, wf_tys),
     );
     let region_bound_pairs = outlives_environment.region_bound_pairs();
 

compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs

@@ -202,7 +202,8 @@ fn get_impl_args(
         return Err(guar);
     }
 
-    let implied_bounds = infcx.implied_bounds_tys_compat(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_args) = infcx.fully_resolve(impl2_args) else {

compiler/rustc_trait_selection/src/traits/misc.rs

@@ -194,7 +194,7 @@ pub fn all_fields_implement_trait<'tcx>(
                 infcx.implied_bounds_tys_compat(
                     param_env,
                     parent_cause.body_id,
-                    FxIndexSet::from_iter([self_type]),
+                    &FxIndexSet::from_iter([self_type]),
                 ),
             );
             let errors = infcx.resolve_regions(&outlives_env);

compiler/rustc_trait_selection/src/traits/outlives_bounds.rs

@@ -23,7 +23,7 @@ pub trait InferCtxtExt<'a, 'tcx> {
         &'a self,
         param_env: ty::ParamEnv<'tcx>,
         body_id: LocalDefId,
-        tys: FxIndexSet<Ty<'tcx>>,
+        tys: &'a FxIndexSet<Ty<'tcx>>,
     ) -> BoundsCompat<'a, 'tcx>;
 
     fn implied_bounds_tys(
@@ -132,10 +132,9 @@ impl<'a, 'tcx: 'a> InferCtxtExt<'a, 'tcx> for InferCtxt<'tcx> {
         &'a self,
         param_env: ParamEnv<'tcx>,
         body_id: LocalDefId,
-        tys: FxIndexSet<Ty<'tcx>>,
+        tys: &'a FxIndexSet<Ty<'tcx>>,
     ) -> BoundsCompat<'a, 'tcx> {
-        tys.into_iter()
-            .flat_map(move |ty| self.implied_outlives_bounds_compat(param_env, body_id, ty))
+        tys.iter().flat_map(move |ty| self.implied_outlives_bounds_compat(param_env, body_id, *ty))
     }
 
     fn implied_bounds_tys(

tests/ui/implied-bounds/auxiliary/bevy_ecs.rs

@@ -0,0 +1,16 @@
+pub mod system {
+    pub trait WorldQuery {}
+    impl WorldQuery for &u8 {}
+
+    pub struct Query<Q: WorldQuery>(Q);
+
+    pub trait SystemParam {
+        type State;
+    }
+    impl<Q: WorldQuery + 'static> SystemParam for Query<Q> {
+        type State = ();
+        // `Q: 'static` is required because we need the TypeId of Q ...
+    }
+
+    pub struct ParamSet<T: SystemParam>(T) where T::State: Sized;
+}

tests/ui/implied-bounds/bevy_world_query.rs

@@ -0,0 +1,13 @@
+// aux-crate:bevy_ecs=bevy_ecs.rs
+// check-pass
+
+// We currently special case bevy from emitting the `IMPLIED_BOUNDS_FROM_TRAIT_IMPL` lint.
+// Otherwise, we would expect this to hit the lint.
+
+extern crate bevy_ecs;
+
+use bevy_ecs::system::*;
+
+fn handler<'a>(_: ParamSet<Query<&'a u8>>) {}
+
+fn main() {}