Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 1f34c1d

Browse files
borsbors
committedDec 2, 2023
Auto merge of #118553 - jackh726:lint-implied-bounds, r=<try>
lint incorrect implied bounds in wfcheck except for Bevy dependents Rebase of #109763 Additionally, special cases Bevy `ParamSet` types to not trigger the lint. Opening for crater r? `@ghost`
2 parents d5fab33 + b4485be commit 1f34c1d

File tree

19 files changed

+413
-45
lines changed

19 files changed

+413
-45
lines changed
 

‎compiler/rustc_hir_analysis/src/check/check.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -356,7 +356,7 @@ fn check_opaque_meets_bounds<'tcx>(
356356
// Can have different predicates to their defining use
357357
hir::OpaqueTyOrigin::TyAlias { .. } => {
358358
let wf_tys = ocx.assumed_wf_types_and_report_errors(param_env, def_id)?;
359-
let implied_bounds = infcx.implied_bounds_tys(param_env, def_id, wf_tys);
359+
let implied_bounds = infcx.implied_bounds_tys_compat(param_env, def_id, &wf_tys);
360360
let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
361361
ocx.resolve_regions_and_report_errors(defining_use_anchor, &outlives_env)?;
362362
}

‎compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -404,7 +404,7 @@ fn compare_method_predicate_entailment<'tcx>(
404404
// lifetime parameters.
405405
let outlives_env = OutlivesEnvironment::with_bounds(
406406
param_env,
407-
infcx.implied_bounds_tys(param_env, impl_m_def_id, wf_tys),
407+
infcx.implied_bounds_tys_compat(param_env, impl_m_def_id, &wf_tys),
408408
);
409409
let errors = infcx.resolve_regions(&outlives_env);
410410
if !errors.is_empty() {
@@ -880,7 +880,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
880880
// lifetime parameters.
881881
let outlives_env = OutlivesEnvironment::with_bounds(
882882
param_env,
883-
infcx.implied_bounds_tys(param_env, impl_m_def_id, wf_tys),
883+
infcx.implied_bounds_tys_compat(param_env, impl_m_def_id, &wf_tys),
884884
);
885885
ocx.resolve_regions_and_report_errors(impl_m_def_id, &outlives_env)?;
886886

@@ -2242,7 +2242,8 @@ pub(super) fn check_type_bounds<'tcx>(
22422242

22432243
// Finally, resolve all regions. This catches wily misuses of
22442244
// lifetime parameters.
2245-
let implied_bounds = infcx.implied_bounds_tys(param_env, impl_ty_def_id, assumed_wf_types);
2245+
let implied_bounds =
2246+
infcx.implied_bounds_tys_compat(param_env, impl_ty_def_id, &assumed_wf_types);
22462247
let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
22472248
ocx.resolve_regions_and_report_errors(impl_ty_def_id, &outlives_env)
22482249
}

‎compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -161,7 +161,7 @@ pub(super) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
161161
}
162162
let outlives_env = OutlivesEnvironment::with_bounds(
163163
param_env,
164-
infcx.implied_bounds_tys(param_env, impl_m.def_id.expect_local(), implied_wf_types),
164+
infcx.implied_bounds_tys_compat(param_env, impl_m.def_id.expect_local(), &implied_wf_types),
165165
);
166166
let errors = infcx.resolve_regions(&outlives_env);
167167
if !errors.is_empty() {

‎compiler/rustc_hir_analysis/src/check/wfcheck.rs

Lines changed: 54 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ use rustc_infer::infer::outlives::obligations::TypeOutlives;
1313
use rustc_infer::infer::{self, InferCtxt, TyCtxtInferExt};
1414
use rustc_middle::mir::ConstraintCategory;
1515
use rustc_middle::query::Providers;
16+
use rustc_middle::ty::print::with_no_trimmed_paths;
1617
use rustc_middle::ty::trait_def::TraitSpecializationKind;
1718
use rustc_middle::ty::{
1819
self, AdtKind, GenericParamDefKind, ToPredicate, Ty, TyCtxt, TypeFoldable, TypeSuperVisitable,
@@ -110,8 +111,6 @@ where
110111

111112
let assumed_wf_types = wfcx.ocx.assumed_wf_types_and_report_errors(param_env, body_def_id)?;
112113

113-
let implied_bounds = infcx.implied_bounds_tys(param_env, body_def_id, assumed_wf_types);
114-
115114
let errors = wfcx.select_all_or_error();
116115
if !errors.is_empty() {
117116
let err = infcx.err_ctxt().report_fulfillment_errors(errors);
@@ -126,9 +125,60 @@ where
126125
}
127126
}
128127

128+
let infcx_compat = infcx.fork();
129+
130+
debug!(?assumed_wf_types);
131+
let implied_bounds = infcx.implied_bounds_tys(param_env, &assumed_wf_types);
129132
let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
130133

131-
wfcx.ocx.resolve_regions_and_report_errors(body_def_id, &outlives_env)?;
134+
let errors = infcx.resolve_regions(&outlives_env);
135+
if errors.is_empty() {
136+
return Ok(());
137+
}
138+
139+
let implied_bounds =
140+
infcx_compat.implied_bounds_tys_compat(param_env, body_def_id, &assumed_wf_types);
141+
let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
142+
let errors_compat = infcx_compat.resolve_regions(&outlives_env);
143+
if !errors_compat.is_empty() {
144+
return Err(infcx_compat.err_ctxt().report_region_errors(body_def_id, &errors_compat));
145+
}
146+
147+
// We don't want to emit this for dependents of Bevy, for now.
148+
for ty in assumed_wf_types.iter() {
149+
match ty.kind() {
150+
ty::Adt(def, _) => {
151+
let adt_did = with_no_trimmed_paths!(infcx.tcx.def_path_str(def.0.did));
152+
if adt_did == "bevy_ecs::system::ParamSet" {
153+
return Ok(());
154+
}
155+
}
156+
_ => {}
157+
}
158+
}
159+
160+
let hir_id = tcx.local_def_id_to_hir_id(body_def_id);
161+
let (lint_level, _) = tcx
162+
.lint_level_at_node(rustc_session::lint::builtin::IMPLIED_BOUNDS_FROM_TRAIT_IMPL, hir_id);
163+
tcx.struct_span_lint_hir(
164+
rustc_session::lint::builtin::IMPLIED_BOUNDS_FROM_TRAIT_IMPL,
165+
hir_id,
166+
tcx.def_span(body_def_id),
167+
format!("{} is missing necessary lifetime bounds", tcx.def_descr(body_def_id.into())),
168+
|lint| {
169+
if !lint_level.is_error() {
170+
lint.note(
171+
"to get more detailed errors, use `#[deny(implied_bounds_from_trait_impl)]`",
172+
)
173+
} else {
174+
lint.note("more concrete lifetime errors are emitted below")
175+
}
176+
},
177+
);
178+
if true || lint_level.is_error() {
179+
infcx.err_ctxt().report_region_errors(body_def_id, &errors);
180+
}
181+
132182
infcx.tainted_by_errors().error_reported()
133183
}
134184

@@ -717,7 +767,7 @@ fn resolve_regions_with_wf_tys<'tcx>(
717767
let infcx = tcx.infer_ctxt().build();
718768
let outlives_environment = OutlivesEnvironment::with_bounds(
719769
param_env,
720-
infcx.implied_bounds_tys(param_env, id, wf_tys.clone()),
770+
infcx.implied_bounds_tys_compat(param_env, id, wf_tys),
721771
);
722772
let region_bound_pairs = outlives_environment.region_bound_pairs();
723773

‎compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -202,7 +202,8 @@ fn get_impl_args(
202202
return Err(guar);
203203
}
204204

205-
let implied_bounds = infcx.implied_bounds_tys(param_env, impl1_def_id, assumed_wf_types);
205+
let implied_bounds =
206+
infcx.implied_bounds_tys_compat(param_env, impl1_def_id, &assumed_wf_types);
206207
let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
207208
let _ = ocx.resolve_regions_and_report_errors(impl1_def_id, &outlives_env);
208209
let Ok(impl2_args) = infcx.fully_resolve(impl2_args) else {

‎compiler/rustc_lint_defs/src/builtin.rs

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3388,6 +3388,7 @@ declare_lint_pass! {
33883388
ILL_FORMED_ATTRIBUTE_INPUT,
33893389
ILLEGAL_FLOATING_POINT_LITERAL_PATTERN,
33903390
IMPLIED_BOUNDS_ENTAILMENT,
3391+
IMPLIED_BOUNDS_FROM_TRAIT_IMPL,
33913392
INCOMPLETE_INCLUDE,
33923393
INDIRECT_STRUCTURAL_MATCH,
33933394
INEFFECTIVE_UNSTABLE_TRAIT_IMPL,
@@ -4620,3 +4621,44 @@ declare_lint! {
46204621
reference: "issue #115010 <https://github.com/rust-lang/rust/issues/115010>",
46214622
};
46224623
}
4624+
4625+
declare_lint! {
4626+
/// The `implied_bounds_from_trait_impl` lint detects
4627+
/// a compiler bug allowed some code to assume invalid implied lifetime bounds.
4628+
///
4629+
/// ### Example
4630+
///
4631+
/// ```rust,compile_fail
4632+
/// #![deny(implied_bounds_from_trait_impl)]
4633+
///
4634+
/// trait Trait {
4635+
/// type Assoc;
4636+
/// }
4637+
///
4638+
/// impl<X: 'static> Trait for (X,) {
4639+
/// type Assoc = ();
4640+
/// }
4641+
///
4642+
/// struct Foo<T: Trait>(T)
4643+
/// where
4644+
/// T::Assoc: Clone; // any bound using `T::Assoc`
4645+
///
4646+
/// fn func(foo: Foo<(&str,)>) {
4647+
/// let _: &'static str = foo.0.0;
4648+
/// }
4649+
/// ```
4650+
///
4651+
/// {{produces}}
4652+
///
4653+
/// ### Explanation
4654+
///
4655+
/// FIXME: explanataion
4656+
///
4657+
pub IMPLIED_BOUNDS_FROM_TRAIT_IMPL,
4658+
Warn,
4659+
"item uses illegal implied bounds derived from a trait impl",
4660+
@future_incompatible = FutureIncompatibleInfo {
4661+
reason: FutureIncompatibilityReason::FutureReleaseErrorDontReportInDeps,
4662+
reference: "issue #109628 <https://github.com/rust-lang/rust/issues/109628>",
4663+
};
4664+
}

‎compiler/rustc_middle/src/arena.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -53,7 +53,7 @@ macro_rules! arena_types {
5353
rustc_middle::traits::query::NormalizationResult<'tcx>
5454
>
5555
>,
56-
[] implied_outlives_bounds:
56+
[] implied_outlives_bounds_compat:
5757
rustc_middle::infer::canonical::Canonical<'tcx,
5858
rustc_middle::infer::canonical::QueryResponse<'tcx,
5959
Vec<rustc_middle::traits::query::OutlivesBound<'tcx>>

‎compiler/rustc_middle/src/query/erase.rs

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -74,6 +74,10 @@ impl<T> EraseType for Result<&'_ T, traits::query::NoSolution> {
7474
type Result = [u8; size_of::<Result<&'static (), traits::query::NoSolution>>()];
7575
}
7676

77+
impl<T> EraseType for Result<&'_ [T], traits::query::NoSolution> {
78+
type Result = [u8; size_of::<Result<&'static [()], traits::query::NoSolution>>()];
79+
}
80+
7781
impl<T> EraseType for Result<&'_ T, rustc_errors::ErrorGuaranteed> {
7882
type Result = [u8; size_of::<Result<&'static (), rustc_errors::ErrorGuaranteed>>()];
7983
}

‎compiler/rustc_middle/src/query/mod.rs

Lines changed: 10 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1953,7 +1953,7 @@ rustc_queries! {
19531953
desc { "normalizing `{}`", goal.value }
19541954
}
19551955

1956-
query implied_outlives_bounds(
1956+
query implied_outlives_bounds_compat(
19571957
goal: CanonicalTyGoal<'tcx>
19581958
) -> Result<
19591959
&'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, Vec<OutlivesBound<'tcx>>>>,
@@ -1962,6 +1962,15 @@ rustc_queries! {
19621962
desc { "computing implied outlives bounds for `{}`", goal.value.value }
19631963
}
19641964

1965+
query implied_outlives_bounds(
1966+
goal: ty::ParamEnvAnd<'tcx, Ty<'tcx>>
1967+
) -> Result<
1968+
&'tcx [OutlivesBound<'tcx>],
1969+
NoSolution,
1970+
> {
1971+
desc { "computing implied outlives bounds v2 for `{}`", goal.value }
1972+
}
1973+
19651974
/// Do not call this query directly:
19661975
/// invoke `DropckOutlives::new(dropped_ty)).fully_perform(typeck.infcx)` instead.
19671976
query dropck_outlives(

‎compiler/rustc_middle/src/traits/query.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -191,7 +191,7 @@ pub struct NormalizationResult<'tcx> {
191191
/// case they are called implied bounds). They are fed to the
192192
/// `OutlivesEnv` which in turn is supplied to the region checker and
193193
/// other parts of the inference system.
194-
#[derive(Clone, Debug, TypeFoldable, TypeVisitable, HashStable)]
194+
#[derive(Copy, Clone, Debug, TypeFoldable, TypeVisitable, HashStable)]
195195
pub enum OutlivesBound<'tcx> {
196196
RegionSubRegion(ty::Region<'tcx>, ty::Region<'tcx>),
197197
RegionSubParam(ty::Region<'tcx>, ty::ParamTy),

‎compiler/rustc_trait_selection/src/traits/misc.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -191,10 +191,10 @@ pub fn all_fields_implement_trait<'tcx>(
191191
// Check regions assuming the self type of the impl is WF
192192
let outlives_env = OutlivesEnvironment::with_bounds(
193193
param_env,
194-
infcx.implied_bounds_tys(
194+
infcx.implied_bounds_tys_compat(
195195
param_env,
196196
parent_cause.body_id,
197-
FxIndexSet::from_iter([self_type]),
197+
&FxIndexSet::from_iter([self_type]),
198198
),
199199
);
200200
let errors = infcx.resolve_regions(&outlives_env);

‎compiler/rustc_trait_selection/src/traits/outlives_bounds.rs

Lines changed: 35 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -9,20 +9,27 @@ use rustc_span::def_id::LocalDefId;
99

1010
pub use rustc_middle::traits::query::OutlivesBound;
1111

12+
pub type BoundsCompat<'a, 'tcx: 'a> = impl Iterator<Item = OutlivesBound<'tcx>> + 'a;
1213
pub type Bounds<'a, 'tcx: 'a> = impl Iterator<Item = OutlivesBound<'tcx>> + 'a;
1314
pub trait InferCtxtExt<'a, 'tcx> {
14-
fn implied_outlives_bounds(
15+
fn implied_outlives_bounds_compat(
1516
&self,
1617
param_env: ty::ParamEnv<'tcx>,
1718
body_id: LocalDefId,
1819
ty: Ty<'tcx>,
1920
) -> Vec<OutlivesBound<'tcx>>;
2021

21-
fn implied_bounds_tys(
22+
fn implied_bounds_tys_compat(
2223
&'a self,
2324
param_env: ty::ParamEnv<'tcx>,
2425
body_id: LocalDefId,
25-
tys: FxIndexSet<Ty<'tcx>>,
26+
tys: &'a FxIndexSet<Ty<'tcx>>,
27+
) -> BoundsCompat<'a, 'tcx>;
28+
29+
fn implied_bounds_tys(
30+
&'a self,
31+
param_env: ty::ParamEnv<'tcx>,
32+
tys: &'a FxIndexSet<Ty<'tcx>>,
2633
) -> Bounds<'a, 'tcx>;
2734
}
2835

@@ -47,7 +54,7 @@ impl<'a, 'tcx: 'a> InferCtxtExt<'a, 'tcx> for InferCtxt<'tcx> {
4754
/// into the inference context with this body-id.
4855
/// - `ty`, the type that we are supposed to assume is WF.
4956
#[instrument(level = "debug", skip(self, param_env, body_id), ret)]
50-
fn implied_outlives_bounds(
57+
fn implied_outlives_bounds_compat(
5158
&self,
5259
param_env: ty::ParamEnv<'tcx>,
5360
body_id: LocalDefId,
@@ -67,7 +74,7 @@ impl<'a, 'tcx: 'a> InferCtxtExt<'a, 'tcx> for InferCtxt<'tcx> {
6774
let mut canonical_var_values = OriginalQueryValues::default();
6875
let canonical_ty =
6976
self.canonicalize_query_keep_static(param_env.and(ty), &mut canonical_var_values);
70-
let Ok(canonical_result) = self.tcx.implied_outlives_bounds(canonical_ty) else {
77+
let Ok(canonical_result) = self.tcx.implied_outlives_bounds_compat(canonical_ty) else {
7178
return vec![];
7279
};
7380

@@ -113,20 +120,39 @@ impl<'a, 'tcx: 'a> InferCtxtExt<'a, 'tcx> for InferCtxt<'tcx> {
113120
if !errors.is_empty() {
114121
self.tcx.sess.span_delayed_bug(
115122
span,
116-
"implied_outlives_bounds failed to solve obligations from instantiation",
123+
"implied_outlives_bounds_compat failed to solve obligations from instantiation",
117124
);
118125
}
119126
};
120127

121128
bounds
122129
}
123130

124-
fn implied_bounds_tys(
131+
fn implied_bounds_tys_compat(
125132
&'a self,
126133
param_env: ParamEnv<'tcx>,
127134
body_id: LocalDefId,
128-
tys: FxIndexSet<Ty<'tcx>>,
135+
tys: &'a FxIndexSet<Ty<'tcx>>,
136+
) -> BoundsCompat<'a, 'tcx> {
137+
tys.iter().flat_map(move |ty| self.implied_outlives_bounds_compat(param_env, body_id, *ty))
138+
}
139+
140+
fn implied_bounds_tys(
141+
&'a self,
142+
param_env: ParamEnv<'tcx>,
143+
tys: &'a FxIndexSet<Ty<'tcx>>,
129144
) -> Bounds<'a, 'tcx> {
130-
tys.into_iter().flat_map(move |ty| self.implied_outlives_bounds(param_env, body_id, ty))
145+
tys.iter()
146+
.flat_map(move |&ty| {
147+
let ty = self.resolve_vars_if_possible(ty);
148+
let ty = OpportunisticRegionResolver::new(self).fold_ty(ty);
149+
150+
if ty.has_infer() {
151+
return &[] as &[OutlivesBound<'_>];
152+
}
153+
154+
self.tcx.implied_outlives_bounds(param_env.and(ty)).unwrap_or(&[])
155+
})
156+
.copied()
131157
}
132158
}

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

Lines changed: 88 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -5,10 +5,11 @@ use crate::traits::ObligationCtxt;
55

66
use rustc_infer::infer::canonical::Canonical;
77
use rustc_infer::infer::outlives::components::{push_outlives_components, Component};
8+
use rustc_infer::infer::resolve::OpportunisticRegionResolver;
89
use rustc_infer::traits::query::OutlivesBound;
910
use rustc_middle::infer::canonical::CanonicalQueryResponse;
1011
use rustc_middle::traits::ObligationCause;
11-
use rustc_middle::ty::{self, ParamEnvAnd, Ty, TyCtxt, TypeVisitableExt};
12+
use rustc_middle::ty::{self, ParamEnvAnd, Ty, TyCtxt, TypeFolder, TypeVisitableExt};
1213
use rustc_span::def_id::CRATE_DEF_ID;
1314
use rustc_span::DUMMY_SP;
1415
use smallvec::{smallvec, SmallVec};
@@ -47,21 +48,104 @@ impl<'tcx> super::QueryTypeOp<'tcx> for ImpliedOutlivesBounds<'tcx> {
4748
param_env.and(ty)
4849
});
4950

50-
tcx.implied_outlives_bounds(canonicalized)
51+
tcx.implied_outlives_bounds_compat(canonicalized)
5152
}
5253

5354
fn perform_locally_in_new_solver(
5455
ocx: &ObligationCtxt<'_, 'tcx>,
5556
key: ParamEnvAnd<'tcx, Self>,
5657
) -> Result<Self::QueryResponse, NoSolution> {
57-
compute_implied_outlives_bounds_inner(ocx, key.param_env, key.value.ty)
58+
compute_implied_outlives_bounds_compat_inner(ocx, key.param_env, key.value.ty)
5859
}
5960
}
6061

62+
/// For the sake of completeness, we should be careful when dealing with inference artifacts:
63+
/// - `ty` must be fully resolved.
64+
/// - `normalize_op` must return a fully resolved type.
6165
pub fn compute_implied_outlives_bounds_inner<'tcx>(
6266
ocx: &ObligationCtxt<'_, 'tcx>,
6367
param_env: ty::ParamEnv<'tcx>,
6468
ty: Ty<'tcx>,
69+
) -> Result<&'tcx [OutlivesBound<'tcx>], NoSolution> {
70+
let normalize_op = |ty| {
71+
let ty = ocx.normalize(&ObligationCause::dummy(), param_env, ty);
72+
if !ocx.select_all_or_error().is_empty() {
73+
return Err(NoSolution);
74+
}
75+
let ty = ocx.infcx.resolve_vars_if_possible(ty);
76+
let ty = OpportunisticRegionResolver::new(&ocx.infcx).fold_ty(ty);
77+
assert!(!ty.has_infer());
78+
Ok(ty)
79+
};
80+
81+
// Sometimes when we ask what it takes for T: WF, we get back that
82+
// U: WF is required; in that case, we push U onto this stack and
83+
// process it next. Because the resulting predicates aren't always
84+
// guaranteed to be a subset of the original type, so we need to store the
85+
// WF args we've computed in a set.
86+
let mut checked_wf_args = rustc_data_structures::fx::FxHashSet::default();
87+
let mut wf_args = vec![ty.into(), normalize_op(ty)?.into()];
88+
89+
let mut outlives_bounds: Vec<OutlivesBound<'tcx>> = vec![];
90+
91+
while let Some(arg) = wf_args.pop() {
92+
if !checked_wf_args.insert(arg) {
93+
continue;
94+
}
95+
96+
// From the full set of obligations, just filter down to the region relationships.
97+
for obligation in
98+
wf::unnormalized_obligations(ocx.infcx, param_env, arg).into_iter().flatten()
99+
{
100+
assert!(!obligation.has_escaping_bound_vars());
101+
let Some(pred) = obligation.predicate.kind().no_bound_vars() else {
102+
continue;
103+
};
104+
match pred {
105+
ty::PredicateKind::Clause(ty::ClauseKind::Trait(..))
106+
// FIXME(const_generics): Make sure that `<'a, 'b, const N: &'a &'b u32>` is sound
107+
// if we ever support that
108+
| ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(..))
109+
| ty::PredicateKind::Subtype(..)
110+
| ty::PredicateKind::Coerce(..)
111+
| ty::PredicateKind::Clause(ty::ClauseKind::Projection(..))
112+
| ty::PredicateKind::ObjectSafe(..)
113+
| ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(..))
114+
| ty::PredicateKind::ConstEquate(..)
115+
| ty::PredicateKind::Ambiguous
116+
| ty::PredicateKind::AliasRelate(..)
117+
=> {}
118+
119+
// We need to search through *all* WellFormed predicates
120+
ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(arg)) => {
121+
wf_args.push(arg);
122+
}
123+
124+
// We need to register region relationships
125+
ty::PredicateKind::Clause(ty::ClauseKind::RegionOutlives(
126+
ty::OutlivesPredicate(r_a, r_b),
127+
)) => outlives_bounds.push(OutlivesBound::RegionSubRegion(r_b, r_a)),
128+
129+
ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives(ty::OutlivesPredicate(
130+
ty_a,
131+
r_b,
132+
))) => {
133+
let ty_a = normalize_op(ty_a)?;
134+
let mut components = smallvec![];
135+
push_outlives_components(ocx.infcx.tcx, ty_a, &mut components);
136+
outlives_bounds.extend(implied_bounds_from_components(r_b, components))
137+
}
138+
}
139+
}
140+
}
141+
142+
Ok(ocx.infcx.tcx.arena.alloc_slice(&outlives_bounds))
143+
}
144+
145+
pub fn compute_implied_outlives_bounds_compat_inner<'tcx>(
146+
ocx: &ObligationCtxt<'_, 'tcx>,
147+
param_env: ty::ParamEnv<'tcx>,
148+
ty: Ty<'tcx>,
65149
) -> Result<Vec<OutlivesBound<'tcx>>, NoSolution> {
66150
let tcx = ocx.infcx.tcx;
67151

@@ -196,7 +280,7 @@ pub fn compute_implied_outlives_bounds_inner<'tcx>(
196280
/// this down to determine what relationships would have to hold for
197281
/// `T: 'a` to hold. We get to assume that the caller has validated
198282
/// those relationships.
199-
fn implied_bounds_from_components<'tcx>(
283+
pub fn implied_bounds_from_components<'tcx>(
200284
sub_region: ty::Region<'tcx>,
201285
sup_components: SmallVec<[Component<'tcx>; 4]>,
202286
) -> Vec<OutlivesBound<'tcx>> {

‎compiler/rustc_traits/src/implied_outlives_bounds.rs

Lines changed: 18 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -6,16 +6,20 @@ use rustc_infer::infer::canonical::{self, Canonical};
66
use rustc_infer::infer::TyCtxtInferExt;
77
use rustc_infer::traits::query::OutlivesBound;
88
use rustc_middle::query::Providers;
9-
use rustc_middle::ty::TyCtxt;
9+
use rustc_middle::ty::{self, Ty, TyCtxt};
1010
use rustc_trait_selection::infer::InferCtxtBuilderExt;
11-
use rustc_trait_selection::traits::query::type_op::implied_outlives_bounds::compute_implied_outlives_bounds_inner;
11+
use rustc_trait_selection::traits::query::type_op::implied_outlives_bounds::{
12+
compute_implied_outlives_bounds_compat_inner, compute_implied_outlives_bounds_inner,
13+
};
1214
use rustc_trait_selection::traits::query::{CanonicalTyGoal, NoSolution};
15+
use rustc_trait_selection::traits::ObligationCtxt;
1316

1417
pub(crate) fn provide(p: &mut Providers) {
18+
*p = Providers { implied_outlives_bounds_compat, ..*p };
1519
*p = Providers { implied_outlives_bounds, ..*p };
1620
}
1721

18-
fn implied_outlives_bounds<'tcx>(
22+
fn implied_outlives_bounds_compat<'tcx>(
1923
tcx: TyCtxt<'tcx>,
2024
goal: CanonicalTyGoal<'tcx>,
2125
) -> Result<
@@ -24,6 +28,16 @@ fn implied_outlives_bounds<'tcx>(
2428
> {
2529
tcx.infer_ctxt().enter_canonical_trait_query(&goal, |ocx, key| {
2630
let (param_env, ty) = key.into_parts();
27-
compute_implied_outlives_bounds_inner(ocx, param_env, ty)
31+
compute_implied_outlives_bounds_compat_inner(ocx, param_env, ty)
2832
})
2933
}
34+
35+
fn implied_outlives_bounds<'tcx>(
36+
tcx: TyCtxt<'tcx>,
37+
goal: ty::ParamEnvAnd<'tcx, Ty<'tcx>>,
38+
) -> Result<&'tcx [OutlivesBound<'tcx>], NoSolution> {
39+
let (param_env, goal_ty) = goal.into_parts();
40+
let infcx = tcx.infer_ctxt().build();
41+
let ocx = ObligationCtxt::new(&infcx);
42+
compute_implied_outlives_bounds_inner(&ocx, param_env, goal_ty)
43+
}

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

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
pub mod system {
2+
pub trait WorldQuery {}
3+
impl WorldQuery for &u8 {}
4+
5+
pub struct Query<Q: WorldQuery>(Q);
6+
7+
pub trait SystemParam {
8+
type State;
9+
}
10+
impl<Q: WorldQuery + 'static> SystemParam for Query<Q> {
11+
type State = ();
12+
// `Q: 'static` is required because we need the TypeId of Q ...
13+
}
14+
15+
pub struct ParamSet<T: SystemParam>(T) where T::State: Sized;
16+
}

‎tests/ui/implied-bounds/bevy_world_query.rs

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
// aux-crate:bevy_ecs=bevy_ecs.rs
2+
// check-pass
3+
4+
// We currently special case bevy from emitting the `IMPLIED_BOUNDS_FROM_TRAIT_IMPL` lint.
5+
// Otherwise, we would expect this to hit the lint.
6+
7+
extern crate bevy_ecs;
8+
9+
use bevy_ecs::system::*;
10+
11+
fn handler<'a>(_: ParamSet<Query<&'a u8>>) {}
12+
13+
fn main() {}

‎tests/ui/implied-bounds/from-trait-impl.rs

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
trait Trait {
2+
type Assoc;
3+
}
4+
5+
impl<X: 'static> Trait for (X,) {
6+
type Assoc = ();
7+
}
8+
9+
struct Foo<T: Trait>(T)
10+
where
11+
T::Assoc: Clone; // any predicate using `T::Assoc` works here
12+
13+
fn func1(foo: Foo<(&str,)>) {
14+
//~^ WARN function is missing necessary lifetime bounds
15+
//~| WARN this was previously accepted
16+
let _: &'static str = foo.0.0;
17+
}
18+
19+
#[deny(implied_bounds_from_trait_impl)]
20+
fn func2(foo: Foo<(&str,)>) {
21+
//~^ ERROR function is missing necessary lifetime bounds
22+
//~| WARN this was previously accepted
23+
//~| ERROR `&str` does not fulfill the required lifetime
24+
let _: &'static str = foo.0.0;
25+
}
26+
27+
trait TestTrait {}
28+
29+
impl<X> TestTrait for [Foo<(X,)>; 1] {}
30+
//~^ WARN implementation is missing necessary lifetime bounds
31+
//~| WARN this was previously accepted
32+
33+
#[deny(implied_bounds_from_trait_impl)]
34+
impl<X> TestTrait for [Foo<(X,)>; 2] {}
35+
//~^ ERROR implementation is missing necessary lifetime bounds
36+
//~| WARN this was previously accepted
37+
//~| ERROR `X` may not live long enough
38+
39+
fn main() {}

‎tests/ui/implied-bounds/from-trait-impl.stderr

Lines changed: 77 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,77 @@
1+
warning: function is missing necessary lifetime bounds
2+
--> $DIR/from-trait-impl.rs:13:1
3+
|
4+
LL | fn func1(foo: Foo<(&str,)>) {
5+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
6+
|
7+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
8+
= note: for more information, see issue #109628 <https://github.com/rust-lang/rust/issues/109628>
9+
= note: to get more detailed errors, use `#[deny(implied_bounds_from_trait_impl)]`
10+
= note: `#[warn(implied_bounds_from_trait_impl)]` on by default
11+
12+
error: function is missing necessary lifetime bounds
13+
--> $DIR/from-trait-impl.rs:20:1
14+
|
15+
LL | fn func2(foo: Foo<(&str,)>) {
16+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
17+
|
18+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
19+
= note: for more information, see issue #109628 <https://github.com/rust-lang/rust/issues/109628>
20+
= note: more concrete lifetime errors are emitted below
21+
note: the lint level is defined here
22+
--> $DIR/from-trait-impl.rs:19:8
23+
|
24+
LL | #[deny(implied_bounds_from_trait_impl)]
25+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
26+
27+
error[E0477]: the type `&str` does not fulfill the required lifetime
28+
--> $DIR/from-trait-impl.rs:20:15
29+
|
30+
LL | fn func2(foo: Foo<(&str,)>) {
31+
| ^^^^^^^^^^^^
32+
|
33+
= note: type must satisfy the static lifetime
34+
35+
warning: implementation is missing necessary lifetime bounds
36+
--> $DIR/from-trait-impl.rs:29:1
37+
|
38+
LL | impl<X> TestTrait for [Foo<(X,)>; 1] {}
39+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
40+
|
41+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
42+
= note: for more information, see issue #109628 <https://github.com/rust-lang/rust/issues/109628>
43+
= note: to get more detailed errors, use `#[deny(implied_bounds_from_trait_impl)]`
44+
45+
error: implementation is missing necessary lifetime bounds
46+
--> $DIR/from-trait-impl.rs:34:1
47+
|
48+
LL | impl<X> TestTrait for [Foo<(X,)>; 2] {}
49+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
50+
|
51+
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
52+
= note: for more information, see issue #109628 <https://github.com/rust-lang/rust/issues/109628>
53+
= note: more concrete lifetime errors are emitted below
54+
note: the lint level is defined here
55+
--> $DIR/from-trait-impl.rs:33:8
56+
|
57+
LL | #[deny(implied_bounds_from_trait_impl)]
58+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
59+
60+
error[E0310]: the parameter type `X` may not live long enough
61+
--> $DIR/from-trait-impl.rs:34:23
62+
|
63+
LL | impl<X> TestTrait for [Foo<(X,)>; 2] {}
64+
| ^^^^^^^^^^^^^^
65+
| |
66+
| the parameter type `X` must be valid for the static lifetime...
67+
| ...so that the type `X` will meet its required lifetime bounds
68+
|
69+
help: consider adding an explicit lifetime bound
70+
|
71+
LL | impl<X: 'static> TestTrait for [Foo<(X,)>; 2] {}
72+
| +++++++++
73+
74+
error: aborting due to 4 previous errors; 2 warnings emitted
75+
76+
Some errors have detailed explanations: E0310, E0477.
77+
For more information about an error, try `rustc --explain E0310`.

‎tests/ui/implied-bounds/normalization-nested.lifetime.stderr

Lines changed: 5 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,10 @@
1-
error[E0759]: `fn` parameter has lifetime `'x` but it needs to satisfy a `'static` lifetime requirement
2-
--> $DIR/normalization-nested.rs:35:20
1+
error: lifetime may not live long enough
2+
--> $DIR/normalization-nested.rs:37:5
33
|
44
LL | pub fn test<'x>(_: Map<Vec<&'x ()>>, s: &'x str) -> &'static str {
5-
| ^^^^^^^^^^^^^^^^
6-
| |
7-
| this data with lifetime `'x`...
8-
| ...is used and required to live as long as `'static` here
9-
|
10-
note: `'static` lifetime requirement introduced by this bound
11-
--> $DIR/normalization-nested.rs:33:14
12-
|
13-
LL | I::Item: 'static;
14-
| ^^^^^^^
5+
| -- lifetime `'x` defined here
6+
LL | s
7+
| ^ returning this value requires that `'x` must outlive `'static`
158

169
error: aborting due to 1 previous error
1710

18-
For more information about this error, try `rustc --explain E0759`.

0 commit comments

Comments
 (0)
Please sign in to comment.