Skip to content
This repository was archived by the owner on May 28, 2025. It is now read-only.

Commit 93f1443

Browse files
matthiaskrgrmatthiaskrgr
authored
Rollup merge of rust-lang#123170 - compiler-errors:const-statics, r=lcnr
Replace regions in const canonical vars' types with `'static` in next-solver canonicalizer We shouldn't ever have non-static regions in consts on stable (or really any regions at all, lol). The test I committed is less minimal than, e.g., rust-lang#123155 -- however, I believe that it actually portrays the underlying issue here a bit better than that one. In the linked issue, we end up emitting a normalizes-to predicate for a const placeholder because we don't actually unify `false` and `""`. In the test I committed, we emit a normalizes-to predicate as a part of actually solving a negative coherence goal. Fixes rust-lang#123155 Fixes rust-lang#118783 r? lcnr
2 parents 5977d63 + 6439c7f commit 93f1443

File tree

7 files changed

+120
-73
lines changed

7 files changed

+120
-73
lines changed

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

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -140,6 +140,10 @@ impl<'tcx> rustc_type_ir::new::Region<TyCtxt<'tcx>> for Region<'tcx> {
140140
fn new_anon_bound(tcx: TyCtxt<'tcx>, debruijn: ty::DebruijnIndex, var: ty::BoundVar) -> Self {
141141
Region::new_bound(tcx, debruijn, ty::BoundRegion { var, kind: ty::BoundRegionKind::BrAnon })
142142
}
143+
144+
fn new_static(tcx: TyCtxt<'tcx>) -> Self {
145+
tcx.lifetimes.re_static
146+
}
143147
}
144148

145149
/// Region utilities

‎compiler/rustc_next_trait_solver/src/canonicalizer.rs‎

Lines changed: 58 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -296,10 +296,7 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I>
296296
Region::new_anon_bound(self.interner(), self.binder_index, var)
297297
}
298298

299-
fn fold_ty(&mut self, t: I::Ty) -> I::Ty
300-
where
301-
I::Ty: TypeSuperFoldable<I>,
302-
{
299+
fn fold_ty(&mut self, t: I::Ty) -> I::Ty {
303300
let kind = match t.kind() {
304301
ty::Infer(i) => match i {
305302
ty::TyVar(vid) => {
@@ -378,47 +375,48 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I>
378375
Ty::new_anon_bound(self.interner(), self.binder_index, var)
379376
}
380377

381-
fn fold_const(&mut self, c: I::Const) -> I::Const
382-
where
383-
I::Const: TypeSuperFoldable<I>,
384-
{
378+
fn fold_const(&mut self, c: I::Const) -> I::Const {
379+
// We could canonicalize all consts with static types, but the only ones we
380+
// *really* need to worry about are the ones that we end up putting into `CanonicalVarKind`
381+
// since canonical vars can't reference other canonical vars.
382+
let ty = c
383+
.ty()
384+
.fold_with(&mut RegionsToStatic { interner: self.interner(), binder: ty::INNERMOST });
385385
let kind = match c.kind() {
386-
ty::ConstKind::Infer(i) => {
387-
// FIXME: we should fold the ty too eventually
388-
match i {
389-
ty::InferConst::Var(vid) => {
390-
assert_eq!(
391-
self.infcx.root_ct_var(vid),
392-
vid,
393-
"region vid should have been resolved fully before canonicalization"
394-
);
395-
assert_eq!(
396-
self.infcx.probe_ct_var(vid),
397-
None,
398-
"region vid should have been resolved fully before canonicalization"
399-
);
400-
CanonicalVarKind::Const(self.infcx.universe_of_ct(vid).unwrap(), c.ty())
401-
}
402-
ty::InferConst::EffectVar(_) => CanonicalVarKind::Effect,
403-
ty::InferConst::Fresh(_) => todo!(),
386+
ty::ConstKind::Infer(i) => match i {
387+
ty::InferConst::Var(vid) => {
388+
assert_eq!(
389+
self.infcx.root_ct_var(vid),
390+
vid,
391+
"region vid should have been resolved fully before canonicalization"
392+
);
393+
assert_eq!(
394+
self.infcx.probe_ct_var(vid),
395+
None,
396+
"region vid should have been resolved fully before canonicalization"
397+
);
398+
CanonicalVarKind::Const(self.infcx.universe_of_ct(vid).unwrap(), ty)
404399
}
405-
}
400+
ty::InferConst::EffectVar(_) => CanonicalVarKind::Effect,
401+
ty::InferConst::Fresh(_) => todo!(),
402+
},
406403
ty::ConstKind::Placeholder(placeholder) => match self.canonicalize_mode {
407404
CanonicalizeMode::Input => CanonicalVarKind::PlaceholderConst(
408405
PlaceholderLike::new(placeholder.universe(), self.variables.len().into()),
409-
c.ty(),
406+
ty,
410407
),
411408
CanonicalizeMode::Response { .. } => {
412-
CanonicalVarKind::PlaceholderConst(placeholder, c.ty())
409+
CanonicalVarKind::PlaceholderConst(placeholder, ty)
413410
}
414411
},
415412
ty::ConstKind::Param(_) => match self.canonicalize_mode {
416413
CanonicalizeMode::Input => CanonicalVarKind::PlaceholderConst(
417414
PlaceholderLike::new(ty::UniverseIndex::ROOT, self.variables.len().into()),
418-
c.ty(),
415+
ty,
419416
),
420417
CanonicalizeMode::Response { .. } => panic!("param ty in response: {c:?}"),
421418
},
419+
// FIXME: See comment above -- we could fold the region separately or something.
422420
ty::ConstKind::Bound(_, _)
423421
| ty::ConstKind::Unevaluated(_)
424422
| ty::ConstKind::Value(_)
@@ -435,6 +433,35 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I>
435433
}),
436434
);
437435

438-
Const::new_anon_bound(self.interner(), self.binder_index, var, c.ty())
436+
Const::new_anon_bound(self.interner(), self.binder_index, var, ty)
437+
}
438+
}
439+
440+
struct RegionsToStatic<I> {
441+
interner: I,
442+
binder: ty::DebruijnIndex,
443+
}
444+
445+
impl<I: Interner> TypeFolder<I> for RegionsToStatic<I> {
446+
fn interner(&self) -> I {
447+
self.interner
448+
}
449+
450+
fn fold_binder<T>(&mut self, t: I::Binder<T>) -> I::Binder<T>
451+
where
452+
T: TypeFoldable<I>,
453+
I::Binder<T>: TypeSuperFoldable<I>,
454+
{
455+
self.binder.shift_in(1);
456+
let t = t.fold_with(self);
457+
self.binder.shift_out(1);
458+
t
459+
}
460+
461+
fn fold_region(&mut self, r: I::Region) -> I::Region {
462+
match r.kind() {
463+
ty::ReBound(db, _) if self.binder > db => r,
464+
_ => Region::new_static(self.interner()),
465+
}
439466
}
440467
}

‎compiler/rustc_type_ir/src/fold.rs‎

Lines changed: 11 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -136,31 +136,21 @@ pub trait TypeFolder<I: Interner>: FallibleTypeFolder<I, Error = Never> {
136136
t.super_fold_with(self)
137137
}
138138

139-
fn fold_ty(&mut self, t: I::Ty) -> I::Ty
140-
where
141-
I::Ty: TypeSuperFoldable<I>,
142-
{
139+
fn fold_ty(&mut self, t: I::Ty) -> I::Ty {
143140
t.super_fold_with(self)
144141
}
145142

146143
// The default region folder is a no-op because `Region` is non-recursive
147-
// and has no `super_fold_with` method to call. That also explains the
148-
// lack of `I::Region: TypeSuperFoldable<I>` bound on this method.
144+
// and has no `super_fold_with` method to call.
149145
fn fold_region(&mut self, r: I::Region) -> I::Region {
150146
r
151147
}
152148

153-
fn fold_const(&mut self, c: I::Const) -> I::Const
154-
where
155-
I::Const: TypeSuperFoldable<I>,
156-
{
149+
fn fold_const(&mut self, c: I::Const) -> I::Const {
157150
c.super_fold_with(self)
158151
}
159152

160-
fn fold_predicate(&mut self, p: I::Predicate) -> I::Predicate
161-
where
162-
I::Predicate: TypeSuperFoldable<I>,
163-
{
153+
fn fold_predicate(&mut self, p: I::Predicate) -> I::Predicate {
164154
p.super_fold_with(self)
165155
}
166156
}
@@ -185,31 +175,21 @@ pub trait FallibleTypeFolder<I: Interner>: Sized {
185175
t.try_super_fold_with(self)
186176
}
187177

188-
fn try_fold_ty(&mut self, t: I::Ty) -> Result<I::Ty, Self::Error>
189-
where
190-
I::Ty: TypeSuperFoldable<I>,
191-
{
178+
fn try_fold_ty(&mut self, t: I::Ty) -> Result<I::Ty, Self::Error> {
192179
t.try_super_fold_with(self)
193180
}
194181

195182
// The default region folder is a no-op because `Region` is non-recursive
196-
// and has no `super_fold_with` method to call. That also explains the
197-
// lack of `I::Region: TypeSuperFoldable<I>` bound on this method.
183+
// and has no `super_fold_with` method to call.
198184
fn try_fold_region(&mut self, r: I::Region) -> Result<I::Region, Self::Error> {
199185
Ok(r)
200186
}
201187

202-
fn try_fold_const(&mut self, c: I::Const) -> Result<I::Const, Self::Error>
203-
where
204-
I::Const: TypeSuperFoldable<I>,
205-
{
188+
fn try_fold_const(&mut self, c: I::Const) -> Result<I::Const, Self::Error> {
206189
c.try_super_fold_with(self)
207190
}
208191

209-
fn try_fold_predicate(&mut self, p: I::Predicate) -> Result<I::Predicate, Self::Error>
210-
where
211-
I::Predicate: TypeSuperFoldable<I>,
212-
{
192+
fn try_fold_predicate(&mut self, p: I::Predicate) -> Result<I::Predicate, Self::Error> {
213193
p.try_super_fold_with(self)
214194
}
215195
}
@@ -234,28 +214,19 @@ where
234214
Ok(self.fold_binder(t))
235215
}
236216

237-
fn try_fold_ty(&mut self, t: I::Ty) -> Result<I::Ty, Never>
238-
where
239-
I::Ty: TypeSuperFoldable<I>,
240-
{
217+
fn try_fold_ty(&mut self, t: I::Ty) -> Result<I::Ty, Never> {
241218
Ok(self.fold_ty(t))
242219
}
243220

244221
fn try_fold_region(&mut self, r: I::Region) -> Result<I::Region, Never> {
245222
Ok(self.fold_region(r))
246223
}
247224

248-
fn try_fold_const(&mut self, c: I::Const) -> Result<I::Const, Never>
249-
where
250-
I::Const: TypeSuperFoldable<I>,
251-
{
225+
fn try_fold_const(&mut self, c: I::Const) -> Result<I::Const, Never> {
252226
Ok(self.fold_const(c))
253227
}
254228

255-
fn try_fold_predicate(&mut self, p: I::Predicate) -> Result<I::Predicate, Never>
256-
where
257-
I::Predicate: TypeSuperFoldable<I>,
258-
{
229+
fn try_fold_predicate(&mut self, p: I::Predicate) -> Result<I::Predicate, Never> {
259230
Ok(self.fold_predicate(p))
260231
}
261232
}

‎compiler/rustc_type_ir/src/interner.rs‎

Lines changed: 11 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2,13 +2,14 @@ use smallvec::SmallVec;
22
use std::fmt::Debug;
33
use std::hash::Hash;
44

5+
use crate::fold::TypeSuperFoldable;
56
use crate::visit::{Flags, TypeSuperVisitable, TypeVisitable};
67
use crate::{
78
new, BoundVar, BoundVars, CanonicalVarInfo, ConstKind, DebugWithInfcx, RegionKind, TyKind,
89
UniverseIndex,
910
};
1011

11-
pub trait Interner: Sized {
12+
pub trait Interner: Sized + Copy {
1213
type DefId: Copy + Debug + Hash + Eq;
1314
type AdtDef: Copy + Debug + Hash + Eq;
1415

@@ -34,6 +35,7 @@ pub trait Interner: Sized {
3435
+ Into<Self::GenericArg>
3536
+ IntoKind<Kind = TyKind<Self>>
3637
+ TypeSuperVisitable<Self>
38+
+ TypeSuperFoldable<Self>
3739
+ Flags
3840
+ new::Ty<Self>;
3941
type Tys: Copy + Debug + Hash + Eq + IntoIterator<Item = Self::Ty>;
@@ -57,6 +59,7 @@ pub trait Interner: Sized {
5759
+ IntoKind<Kind = ConstKind<Self>>
5860
+ ConstTy<Self>
5961
+ TypeSuperVisitable<Self>
62+
+ TypeSuperFoldable<Self>
6063
+ Flags
6164
+ new::Const<Self>;
6265
type AliasConst: Copy + DebugWithInfcx<Self> + Hash + Eq;
@@ -82,7 +85,13 @@ pub trait Interner: Sized {
8285
type PlaceholderRegion: Copy + Debug + Hash + Eq + PlaceholderLike;
8386

8487
// Predicates
85-
type Predicate: Copy + Debug + Hash + Eq + TypeSuperVisitable<Self> + Flags;
88+
type Predicate: Copy
89+
+ Debug
90+
+ Hash
91+
+ Eq
92+
+ TypeSuperVisitable<Self>
93+
+ TypeSuperFoldable<Self>
94+
+ Flags;
8695
type TraitPredicate: Copy + Debug + Hash + Eq;
8796
type RegionOutlivesPredicate: Copy + Debug + Hash + Eq;
8897
type TypeOutlivesPredicate: Copy + Debug + Hash + Eq;

‎compiler/rustc_type_ir/src/new.rs‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,8 @@ pub trait Ty<I: Interner<Ty = Self>> {
66

77
pub trait Region<I: Interner<Region = Self>> {
88
fn new_anon_bound(interner: I, debruijn: DebruijnIndex, var: BoundVar) -> Self;
9+
10+
fn new_static(interner: I) -> Self;
911
}
1012

1113
pub trait Const<I: Interner<Const = Self>> {

‎tests/ui/coherence/negative-coherence/regions-in-canonical.rs‎

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
//@ check-pass
2+
3+
#![feature(adt_const_params)]
4+
//~^ WARN the feature `adt_const_params` is incomplete
5+
#![feature(with_negative_coherence, negative_impls)]
6+
7+
pub trait A<const K: &'static str> {}
8+
pub trait C {}
9+
10+
11+
struct W<T>(T);
12+
13+
// Negative coherence:
14+
// Proving `W<!T>: !A<"">` requires proving `CONST alias-eq ""`, which requires proving
15+
// `CONST normalizes-to (?1c: &str)`. The type's region is uniquified, so it ends up being
16+
// put in to the canonical vars list with an infer region => ICE.
17+
impl<T> C for T where T: A<""> {}
18+
impl<T> C for W<T> {}
19+
20+
impl<T> !A<CONST> for W<T> {}
21+
const CONST: &str = "";
22+
23+
fn main() {}

‎tests/ui/coherence/negative-coherence/regions-in-canonical.stderr‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
warning: the feature `adt_const_params` is incomplete and may not be safe to use and/or cause compiler crashes
2+
--> $DIR/regions-in-canonical.rs:3:12
3+
|
4+
LL | #![feature(adt_const_params)]
5+
| ^^^^^^^^^^^^^^^^
6+
|
7+
= note: see issue #95174 <https://github.com/rust-lang/rust/issues/95174> for more information
8+
= note: `#[warn(incomplete_features)]` on by default
9+
10+
warning: 1 warning emitted
11+

0 commit comments

Comments
 (0)