Skip to content

Commit f04a2f4

Browse files
borsbors
committed
Auto merge of #91255 - b-naber:normalization-ice, r=jackh276
Implement version of normalize_erasing_regions that allows for normalization failure Fixes #59324 Fixes #67684 Fixes #69398 Fixes #71113 Fixes #82079 Fixes #85103 Fixes #88856 Fixes #91231 Fixes #91234 Previously we called `normalize_erasing_regions` inside `layout_of`. `normalize_erasing_regions` assumes that the normalization succeeds. Since some `layout_of` calls happen before typecheck has finished, we introduce a new variant that allows for returning an error.
2 parents 26b4557 + 6952470 commit f04a2f4

18 files changed

+600
-5
lines changed

‎compiler/rustc_lint/src/types.rs

+3-1
Original file line numberDiff line numberDiff line change
@@ -1337,7 +1337,9 @@ impl<'tcx> LateLintPass<'tcx> for VariantSizeDifferences {
13371337
let layout = match cx.layout_of(ty) {
13381338
Ok(layout) => layout,
13391339
Err(
1340-
ty::layout::LayoutError::Unknown(_) | ty::layout::LayoutError::SizeOverflow(_),
1340+
ty::layout::LayoutError::Unknown(_)
1341+
| ty::layout::LayoutError::SizeOverflow(_)
1342+
| ty::layout::LayoutError::NormalizationFailure(_, _),
13411343
) => return,
13421344
};
13431345
let (variants, tag) = match layout.variants {

‎compiler/rustc_middle/src/mir/interpret/error.rs

-3
Original file line numberDiff line numberDiff line change
@@ -492,9 +492,6 @@ impl dyn MachineStopType {
492492
}
493493
}
494494

495-
#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
496-
static_assert_size!(InterpError<'_>, 64);
497-
498495
pub enum InterpError<'tcx> {
499496
/// The program caused undefined behavior.
500497
UndefinedBehavior(UndefinedBehaviorInfo<'tcx>),

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

+19
Original file line numberDiff line numberDiff line change
@@ -1644,6 +1644,11 @@ rustc_queries! {
16441644
desc { "normalizing `{:?}`", goal }
16451645
}
16461646

1647+
// FIXME: Implement `normalize_generic_arg_after_erasing_regions` and
1648+
// `normalize_mir_const_after_erasing_regions` in terms of
1649+
// `try_normalize_generic_arg_after_erasing_regions` and
1650+
// `try_normalize_mir_const_after_erasing_regions`, respectively.
1651+
16471652
/// Do not call this query directly: invoke `normalize_erasing_regions` instead.
16481653
query normalize_generic_arg_after_erasing_regions(
16491654
goal: ParamEnvAnd<'tcx, GenericArg<'tcx>>
@@ -1658,6 +1663,20 @@ rustc_queries! {
16581663
desc { "normalizing `{}`", goal.value }
16591664
}
16601665

1666+
/// Do not call this query directly: invoke `try_normalize_erasing_regions` instead.
1667+
query try_normalize_generic_arg_after_erasing_regions(
1668+
goal: ParamEnvAnd<'tcx, GenericArg<'tcx>>
1669+
) -> Result<GenericArg<'tcx>, NoSolution> {
1670+
desc { "normalizing `{}`", goal.value }
1671+
}
1672+
1673+
/// Do not call this query directly: invoke `try_normalize_erasing_regions` instead.
1674+
query try_normalize_mir_const_after_erasing_regions(
1675+
goal: ParamEnvAnd<'tcx, mir::ConstantKind<'tcx>>
1676+
) -> Result<mir::ConstantKind<'tcx>, NoSolution> {
1677+
desc { "normalizing `{}`", goal.value }
1678+
}
1679+
16611680
query implied_outlives_bounds(
16621681
goal: CanonicalTyGoal<'tcx>
16631682
) -> Result<

‎compiler/rustc_middle/src/ty/layout.rs

+22-1
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
use crate::middle::codegen_fn_attrs::CodegenFnAttrFlags;
22
use crate::mir::{GeneratorLayout, GeneratorSavedLocal};
3+
use crate::ty::normalize_erasing_regions::NormalizationError;
34
use crate::ty::subst::Subst;
45
use crate::ty::{self, subst::SubstsRef, ReprOptions, Ty, TyCtxt, TypeFoldable};
56
use rustc_ast as ast;
@@ -199,6 +200,7 @@ pub const MAX_SIMD_LANES: u64 = 1 << 0xF;
199200
pub enum LayoutError<'tcx> {
200201
Unknown(Ty<'tcx>),
201202
SizeOverflow(Ty<'tcx>),
203+
NormalizationFailure(Ty<'tcx>, NormalizationError<'tcx>),
202204
}
203205

204206
impl<'tcx> fmt::Display for LayoutError<'tcx> {
@@ -208,16 +210,24 @@ impl<'tcx> fmt::Display for LayoutError<'tcx> {
208210
LayoutError::SizeOverflow(ty) => {
209211
write!(f, "values of the type `{}` are too big for the current architecture", ty)
210212
}
213+
LayoutError::NormalizationFailure(t, e) => write!(
214+
f,
215+
"unable to determine layout for `{}` because `{}` cannot be normalized",
216+
t,
217+
e.get_type_for_failure()
218+
),
211219
}
212220
}
213221
}
214222

223+
#[instrument(skip(tcx, query), level = "debug")]
215224
fn layout_of<'tcx>(
216225
tcx: TyCtxt<'tcx>,
217226
query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>,
218227
) -> Result<TyAndLayout<'tcx>, LayoutError<'tcx>> {
219228
ty::tls::with_related_context(tcx, move |icx| {
220229
let (param_env, ty) = query.into_parts();
230+
debug!(?ty);
221231

222232
if !tcx.recursion_limit().value_within_limit(icx.layout_depth) {
223233
tcx.sess.fatal(&format!("overflow representing the type `{}`", ty));
@@ -229,7 +239,18 @@ fn layout_of<'tcx>(
229239
ty::tls::enter_context(&icx, |_| {
230240
let param_env = param_env.with_reveal_all_normalized(tcx);
231241
let unnormalized_ty = ty;
232-
let ty = tcx.normalize_erasing_regions(param_env, ty);
242+
243+
// FIXME: We might want to have two different versions of `layout_of`:
244+
// One that can be called after typecheck has completed and can use
245+
// `normalize_erasing_regions` here and another one that can be called
246+
// before typecheck has completed and uses `try_normalize_erasing_regions`.
247+
let ty = match tcx.try_normalize_erasing_regions(param_env, ty) {
248+
Ok(t) => t,
249+
Err(normalization_error) => {
250+
return Err(LayoutError::NormalizationFailure(ty, normalization_error));
251+
}
252+
};
253+
233254
if ty != unnormalized_ty {
234255
// Ensure this layout is also cached for the normalized type.
235256
return tcx.layout_of(param_env.and(ty));

‎compiler/rustc_middle/src/ty/normalize_erasing_regions.rs

+115
Original file line numberDiff line numberDiff line change
@@ -8,10 +8,28 @@
88
//! or constant found within. (This underlying query is what is cached.)
99
1010
use crate::mir;
11+
use crate::traits::query::NoSolution;
1112
use crate::ty::fold::{TypeFoldable, TypeFolder};
1213
use crate::ty::subst::{Subst, SubstsRef};
1314
use crate::ty::{self, Ty, TyCtxt};
1415

16+
#[derive(Debug, Copy, Clone, HashStable, TyEncodable, TyDecodable)]
17+
pub enum NormalizationError<'tcx> {
18+
Type(Ty<'tcx>),
19+
Const(ty::Const<'tcx>),
20+
ConstantKind(mir::ConstantKind<'tcx>),
21+
}
22+
23+
impl<'tcx> NormalizationError<'tcx> {
24+
pub fn get_type_for_failure(&self) -> String {
25+
match self {
26+
NormalizationError::Type(t) => format!("{}", t),
27+
NormalizationError::Const(c) => format!("{}", c),
28+
NormalizationError::ConstantKind(ck) => format!("{}", ck),
29+
}
30+
}
31+
}
32+
1533
impl<'tcx> TyCtxt<'tcx> {
1634
/// Erase the regions in `value` and then fully normalize all the
1735
/// types found within. The result will also have regions erased.
@@ -32,6 +50,8 @@ impl<'tcx> TyCtxt<'tcx> {
3250
// Erase first before we do the real query -- this keeps the
3351
// cache from being too polluted.
3452
let value = self.erase_regions(value);
53+
debug!(?value);
54+
3555
if !value.has_projections() {
3656
value
3757
} else {
@@ -41,6 +61,39 @@ impl<'tcx> TyCtxt<'tcx> {
4161
}
4262
}
4363

64+
/// Tries to erase the regions in `value` and then fully normalize all the
65+
/// types found within. The result will also have regions erased.
66+
///
67+
/// Contrary to `normalize_erasing_regions` this function does not assume that normalization
68+
/// succeeds.
69+
pub fn try_normalize_erasing_regions<T>(
70+
self,
71+
param_env: ty::ParamEnv<'tcx>,
72+
value: T,
73+
) -> Result<T, NormalizationError<'tcx>>
74+
where
75+
T: TypeFoldable<'tcx>,
76+
{
77+
debug!(
78+
"try_normalize_erasing_regions::<{}>(value={:?}, param_env={:?})",
79+
std::any::type_name::<T>(),
80+
value,
81+
param_env,
82+
);
83+
84+
// Erase first before we do the real query -- this keeps the
85+
// cache from being too polluted.
86+
let value = self.erase_regions(value);
87+
debug!(?value);
88+
89+
if !value.has_projections() {
90+
Ok(value)
91+
} else {
92+
let mut folder = TryNormalizeAfterErasingRegionsFolder::new(self, param_env);
93+
value.fold_with(&mut folder)
94+
}
95+
}
96+
4497
/// If you have a `Binder<'tcx, T>`, you can do this to strip out the
4598
/// late-bound regions and then normalize the result, yielding up
4699
/// a `T` (with regions erased). This is appropriate when the
@@ -91,11 +144,14 @@ struct NormalizeAfterErasingRegionsFolder<'tcx> {
91144
}
92145

93146
impl<'tcx> NormalizeAfterErasingRegionsFolder<'tcx> {
147+
#[instrument(skip(self), level = "debug")]
94148
fn normalize_generic_arg_after_erasing_regions(
95149
&self,
96150
arg: ty::GenericArg<'tcx>,
97151
) -> ty::GenericArg<'tcx> {
98152
let arg = self.param_env.and(arg);
153+
debug!(?arg);
154+
99155
self.tcx.normalize_generic_arg_after_erasing_regions(arg)
100156
}
101157
}
@@ -126,3 +182,62 @@ impl TypeFolder<'tcx> for NormalizeAfterErasingRegionsFolder<'tcx> {
126182
Ok(self.tcx.normalize_mir_const_after_erasing_regions(arg))
127183
}
128184
}
185+
186+
struct TryNormalizeAfterErasingRegionsFolder<'tcx> {
187+
tcx: TyCtxt<'tcx>,
188+
param_env: ty::ParamEnv<'tcx>,
189+
}
190+
191+
impl<'tcx> TryNormalizeAfterErasingRegionsFolder<'tcx> {
192+
fn new(tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> Self {
193+
TryNormalizeAfterErasingRegionsFolder { tcx, param_env }
194+
}
195+
196+
#[instrument(skip(self), level = "debug")]
197+
fn try_normalize_generic_arg_after_erasing_regions(
198+
&self,
199+
arg: ty::GenericArg<'tcx>,
200+
) -> Result<ty::GenericArg<'tcx>, NoSolution> {
201+
let arg = self.param_env.and(arg);
202+
debug!(?arg);
203+
204+
self.tcx.try_normalize_generic_arg_after_erasing_regions(arg)
205+
}
206+
}
207+
208+
impl TypeFolder<'tcx> for TryNormalizeAfterErasingRegionsFolder<'tcx> {
209+
type Error = NormalizationError<'tcx>;
210+
211+
fn tcx(&self) -> TyCtxt<'tcx> {
212+
self.tcx
213+
}
214+
215+
fn fold_ty(&mut self, ty: Ty<'tcx>) -> Result<Ty<'tcx>, Self::Error> {
216+
match self.try_normalize_generic_arg_after_erasing_regions(ty.into()) {
217+
Ok(t) => Ok(t.expect_ty()),
218+
Err(_) => Err(NormalizationError::Type(ty)),
219+
}
220+
}
221+
222+
fn fold_const(
223+
&mut self,
224+
c: &'tcx ty::Const<'tcx>,
225+
) -> Result<&'tcx ty::Const<'tcx>, Self::Error> {
226+
match self.try_normalize_generic_arg_after_erasing_regions(c.into()) {
227+
Ok(t) => Ok(t.expect_const()),
228+
Err(_) => Err(NormalizationError::Const(*c)),
229+
}
230+
}
231+
232+
fn fold_mir_const(
233+
&mut self,
234+
c: mir::ConstantKind<'tcx>,
235+
) -> Result<mir::ConstantKind<'tcx>, Self::Error> {
236+
// FIXME: This *probably* needs canonicalization too!
237+
let arg = self.param_env.and(c);
238+
match self.tcx.try_normalize_mir_const_after_erasing_regions(arg) {
239+
Ok(c) => Ok(c),
240+
Err(_) => Err(NormalizationError::ConstantKind(c)),
241+
}
242+
}
243+
}

‎compiler/rustc_traits/src/normalize_erasing_regions.rs

+40
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,14 @@ crate fn provide(p: &mut Providers) {
2020
normalize_mir_const_after_erasing_regions: |tcx, goal| {
2121
normalize_after_erasing_regions(tcx, goal)
2222
},
23+
try_normalize_generic_arg_after_erasing_regions: |tcx, goal| {
24+
debug!("try_normalize_generic_arg_after_erasing_regions(goal={:#?}", goal);
25+
26+
try_normalize_after_erasing_regions(tcx, goal)
27+
},
28+
try_normalize_mir_const_after_erasing_regions: |tcx, goal| {
29+
try_normalize_after_erasing_regions(tcx, goal)
30+
},
2331
..*p
2432
};
2533
}
@@ -56,6 +64,38 @@ fn normalize_after_erasing_regions<'tcx, T: TypeFoldable<'tcx> + PartialEq + Cop
5664
})
5765
}
5866

67+
#[instrument(level = "debug", skip(tcx))]
68+
fn try_normalize_after_erasing_regions<'tcx, T: TypeFoldable<'tcx> + PartialEq + Copy>(
69+
tcx: TyCtxt<'tcx>,
70+
goal: ParamEnvAnd<'tcx, T>,
71+
) -> Result<T, NoSolution> {
72+
let ParamEnvAnd { param_env, value } = goal;
73+
tcx.infer_ctxt().enter(|infcx| {
74+
let cause = ObligationCause::dummy();
75+
match infcx.at(&cause, param_env).normalize(value) {
76+
Ok(Normalized { value: normalized_value, obligations: normalized_obligations }) => {
77+
// We don't care about the `obligations`; they are
78+
// always only region relations, and we are about to
79+
// erase those anyway:
80+
debug_assert_eq!(
81+
normalized_obligations.iter().find(|p| not_outlives_predicate(&p.predicate)),
82+
None,
83+
);
84+
85+
let resolved_value = infcx.resolve_vars_if_possible(normalized_value);
86+
// It's unclear when `resolve_vars` would have an effect in a
87+
// fresh `InferCtxt`. If this assert does trigger, it will give
88+
// us a test case.
89+
debug_assert_eq!(normalized_value, resolved_value);
90+
let erased = infcx.tcx.erase_regions(resolved_value);
91+
debug_assert!(!erased.needs_infer(), "{:?}", erased);
92+
Ok(erased)
93+
}
94+
Err(NoSolution) => Err(NoSolution),
95+
}
96+
})
97+
}
98+
5999
fn not_outlives_predicate(p: &ty::Predicate<'tcx>) -> bool {
60100
match p.kind().skip_binder() {
61101
ty::PredicateKind::RegionOutlives(..) | ty::PredicateKind::TypeOutlives(..) => false,

‎src/librustdoc/html/render/print_item.rs

+7
Original file line numberDiff line numberDiff line change
@@ -1769,6 +1769,13 @@ fn document_type_layout(w: &mut Buffer, cx: &Context<'_>, ty_def_id: DefId) {
17691769
the type was too big.</p>"
17701770
);
17711771
}
1772+
Err(LayoutError::NormalizationFailure(_, _)) => {
1773+
writeln!(
1774+
w,
1775+
"<p><strong>Note:</strong> Encountered an error during type layout; \
1776+
the type failed to be normalized.</p>"
1777+
)
1778+
}
17721779
}
17731780

17741781
writeln!(w, "</div>");

‎src/test/ui/associated-types/issue-59324.rs

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
trait NotFoo {}
2+
3+
pub trait Foo: NotFoo {
4+
type OnlyFoo;
5+
}
6+
7+
pub trait Service {
8+
type AssocType;
9+
}
10+
11+
pub trait ThriftService<Bug: NotFoo>:
12+
//~^ ERROR the trait bound `Bug: Foo` is not satisfied
13+
//~| ERROR the trait bound `Bug: Foo` is not satisfied
14+
Service<AssocType = <Bug as Foo>::OnlyFoo>
15+
{
16+
fn get_service(
17+
//~^ ERROR the trait bound `Bug: Foo` is not satisfied
18+
//~| ERROR the trait bound `Bug: Foo` is not satisfied
19+
&self,
20+
) -> Self::AssocType;
21+
}
22+
23+
fn with_factory<H>(factory: dyn ThriftService<()>) {}
24+
//~^ ERROR the trait bound `(): Foo` is not satisfied
25+
26+
fn main() {}

0 commit comments

Comments
 (0)