Skip to content

Commit fcc6d1b

Browse files
BoxyUwUBoxyUwU
committed
Split smir Const into TyConst and MirConst 
1 parent e8ec393 commit fcc6d1b

File tree

12 files changed

+230
-131
lines changed

12 files changed

+230
-131
lines changed

‎compiler/rustc_smir/src/rustc_internal/internal.rs

Lines changed: 19 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -5,17 +5,17 @@
55
66
// Prefer importing stable_mir over internal rustc constructs to make this file more readable.
77
use crate::rustc_smir::Tables;
8-
use rustc_middle::ty::{self as rustc_ty, Ty as InternalTy, TyCtxt};
8+
use rustc_middle::ty::{self as rustc_ty, Const as InternalConst, Ty as InternalTy, TyCtxt};
99
use rustc_span::Symbol;
1010
use stable_mir::abi::Layout;
1111
use stable_mir::mir::alloc::AllocId;
1212
use stable_mir::mir::mono::{Instance, MonoItem, StaticDef};
1313
use stable_mir::mir::{BinOp, Mutability, Place, ProjectionElem, Safety, UnOp};
1414
use stable_mir::ty::{
15-
Abi, AdtDef, Binder, BoundRegionKind, BoundTyKind, BoundVariableKind, ClosureKind, Const,
16-
DynKind, ExistentialPredicate, ExistentialProjection, ExistentialTraitRef, FloatTy, FnSig,
17-
GenericArgKind, GenericArgs, IndexedVal, IntTy, Movability, Pattern, Region, RigidTy, Span,
18-
TermKind, TraitRef, Ty, UintTy, VariantDef, VariantIdx,
15+
Abi, AdtDef, Binder, BoundRegionKind, BoundTyKind, BoundVariableKind, ClosureKind, DynKind,
16+
ExistentialPredicate, ExistentialProjection, ExistentialTraitRef, FloatTy, FnSig,
17+
GenericArgKind, GenericArgs, IndexedVal, IntTy, MirConst, Movability, Pattern, Region, RigidTy,
18+
Span, TermKind, TraitRef, Ty, TyConst, UintTy, VariantDef, VariantIdx,
1919
};
2020
use stable_mir::{CrateItem, CrateNum, DefId};
2121

@@ -55,7 +55,7 @@ impl RustcInternal for GenericArgKind {
5555
let arg: rustc_ty::GenericArg<'tcx> = match self {
5656
GenericArgKind::Lifetime(reg) => reg.internal(tables, tcx).into(),
5757
GenericArgKind::Type(ty) => ty.internal(tables, tcx).into(),
58-
GenericArgKind::Const(cnst) => ty_const(cnst, tables, tcx).into(),
58+
GenericArgKind::Const(cnst) => cnst.internal(tables, tcx).into(),
5959
};
6060
tcx.lift(arg).unwrap()
6161
}
@@ -76,13 +76,20 @@ impl RustcInternal for Ty {
7676
}
7777
}
7878

79+
impl RustcInternal for TyConst {
80+
type T<'tcx> = InternalConst<'tcx>;
81+
fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> {
82+
tcx.lift(tables.ty_consts[self.id]).unwrap()
83+
}
84+
}
85+
7986
impl RustcInternal for Pattern {
8087
type T<'tcx> = rustc_ty::Pattern<'tcx>;
8188
fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> {
8289
tcx.mk_pat(match self {
8390
Pattern::Range { start, end, include_end } => rustc_ty::PatternKind::Range {
84-
start: start.as_ref().map(|c| ty_const(c, tables, tcx)),
85-
end: end.as_ref().map(|c| ty_const(c, tables, tcx)),
91+
start: start.as_ref().map(|c| c.internal(tables, tcx)),
92+
end: end.as_ref().map(|c| c.internal(tables, tcx)),
8693
include_end: *include_end,
8794
},
8895
})
@@ -101,7 +108,7 @@ impl RustcInternal for RigidTy {
101108
RigidTy::Float(float_ty) => rustc_ty::TyKind::Float(float_ty.internal(tables, tcx)),
102109
RigidTy::Never => rustc_ty::TyKind::Never,
103110
RigidTy::Array(ty, cnst) => {
104-
rustc_ty::TyKind::Array(ty.internal(tables, tcx), ty_const(cnst, tables, tcx))
111+
rustc_ty::TyKind::Array(ty.internal(tables, tcx), cnst.internal(tables, tcx))
105112
}
106113
RigidTy::Pat(ty, pat) => {
107114
rustc_ty::TyKind::Pat(ty.internal(tables, tcx), pat.internal(tables, tcx))
@@ -239,23 +246,10 @@ impl RustcInternal for VariantDef {
239246
}
240247
}
241248

242-
fn ty_const<'tcx>(
243-
constant: &Const,
244-
tables: &mut Tables<'_>,
245-
tcx: TyCtxt<'tcx>,
246-
) -> rustc_ty::Const<'tcx> {
247-
match constant.internal(tables, tcx) {
248-
rustc_middle::mir::Const::Ty(c) => c,
249-
cnst => {
250-
panic!("Trying to convert constant `{constant:?}` to type constant, but found {cnst:?}")
251-
}
252-
}
253-
}
254-
255-
impl RustcInternal for Const {
249+
impl RustcInternal for MirConst {
256250
type T<'tcx> = rustc_middle::mir::Const<'tcx>;
257251
fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> {
258-
let constant = tables.constants[self.id];
252+
let constant = tables.mir_consts[self.id];
259253
match constant {
260254
rustc_middle::mir::Const::Ty(ty) => rustc_middle::mir::Const::Ty(tcx.lift(ty).unwrap()),
261255
rustc_middle::mir::Const::Unevaluated(uneval, ty) => {
@@ -392,7 +386,7 @@ impl RustcInternal for TermKind {
392386
fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> {
393387
match self {
394388
TermKind::Type(ty) => ty.internal(tables, tcx).into(),
395-
TermKind::Const(const_) => ty_const(const_, tables, tcx).into(),
389+
TermKind::Const(cnst) => cnst.internal(tables, tcx).into(),
396390
}
397391
}
398392
}

‎compiler/rustc_smir/src/rustc_internal/mod.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -214,7 +214,8 @@ where
214214
spans: IndexMap::default(),
215215
types: IndexMap::default(),
216216
instances: IndexMap::default(),
217-
constants: IndexMap::default(),
217+
ty_consts: IndexMap::default(),
218+
mir_consts: IndexMap::default(),
218219
layouts: IndexMap::default(),
219220
}));
220221
stable_mir::compiler_interface::run(&tables, || init(&tables, f))

‎compiler/rustc_smir/src/rustc_smir/context.rs

Lines changed: 43 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -6,14 +6,14 @@
66
#![allow(rustc::usage_of_qualified_ty)]
77

88
use rustc_abi::HasDataLayout;
9-
use rustc_middle::ty;
109
use rustc_middle::ty::layout::{
1110
FnAbiOf, FnAbiOfHelpers, HasParamEnv, HasTyCtxt, LayoutOf, LayoutOfHelpers,
1211
};
1312
use rustc_middle::ty::print::{with_forced_trimmed_paths, with_no_trimmed_paths};
1413
use rustc_middle::ty::{
1514
GenericPredicates, Instance, List, ParamEnv, ScalarInt, TyCtxt, TypeVisitableExt, ValTree,
1615
};
16+
use rustc_middle::{mir, ty};
1717
use rustc_span::def_id::LOCAL_CRATE;
1818
use stable_mir::abi::{FnAbi, Layout, LayoutShape};
1919
use stable_mir::compiler_interface::Context;
@@ -22,9 +22,9 @@ use stable_mir::mir::mono::{InstanceDef, StaticDef};
2222
use stable_mir::mir::{BinOp, Body, Place, UnOp};
2323
use stable_mir::target::{MachineInfo, MachineSize};
2424
use stable_mir::ty::{
25-
AdtDef, AdtKind, Allocation, ClosureDef, ClosureKind, Const, FieldDef, FnDef, ForeignDef,
26-
ForeignItemKind, GenericArgs, IntrinsicDef, LineInfo, PolyFnSig, RigidTy, Span, Ty, TyKind,
27-
UintTy, VariantDef,
25+
AdtDef, AdtKind, Allocation, ClosureDef, ClosureKind, FieldDef, FnDef, ForeignDef,
26+
ForeignItemKind, GenericArgs, IntrinsicDef, LineInfo, MirConst, PolyFnSig, RigidTy, Span, Ty,
27+
TyConst, TyKind, UintTy, VariantDef,
2828
};
2929
use stable_mir::{Crate, CrateDef, CrateItem, CrateNum, DefId, Error, Filename, ItemKind, Symbol};
3030
use std::cell::RefCell;
@@ -360,7 +360,15 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
360360
def.internal(&mut *tables, tcx).fields.iter().map(|f| f.stable(&mut *tables)).collect()
361361
}
362362

363-
fn eval_target_usize(&self, cnst: &Const) -> Result<u64, Error> {
363+
fn eval_target_usize(&self, cnst: &MirConst) -> Result<u64, Error> {
364+
let mut tables = self.0.borrow_mut();
365+
let tcx = tables.tcx;
366+
let mir_const = cnst.internal(&mut *tables, tcx);
367+
mir_const
368+
.try_eval_target_usize(tables.tcx, ParamEnv::empty())
369+
.ok_or_else(|| Error::new(format!("Const `{cnst:?}` cannot be encoded as u64")))
370+
}
371+
fn eval_target_usize_ty(&self, cnst: &TyConst) -> Result<u64, Error> {
364372
let mut tables = self.0.borrow_mut();
365373
let tcx = tables.tcx;
366374
let mir_const = cnst.internal(&mut *tables, tcx);
@@ -369,7 +377,7 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
369377
.ok_or_else(|| Error::new(format!("Const `{cnst:?}` cannot be encoded as u64")))
370378
}
371379

372-
fn try_new_const_zst(&self, ty: Ty) -> Result<Const, Error> {
380+
fn try_new_const_zst(&self, ty: Ty) -> Result<MirConst, Error> {
373381
let mut tables = self.0.borrow_mut();
374382
let tcx = tables.tcx;
375383
let ty_internal = ty.internal(&mut *tables, tcx);
@@ -390,25 +398,42 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
390398
)));
391399
}
392400

393-
Ok(ty::Const::zero_sized(tables.tcx, ty_internal).stable(&mut *tables))
401+
Ok(mir::Const::Ty(ty::Const::zero_sized(tables.tcx, ty_internal)).stable(&mut *tables))
394402
}
395403

396-
fn new_const_str(&self, value: &str) -> Const {
404+
fn new_const_str(&self, value: &str) -> MirConst {
397405
let mut tables = self.0.borrow_mut();
398406
let tcx = tables.tcx;
399407
let ty = ty::Ty::new_static_str(tcx);
400408
let bytes = value.as_bytes();
401409
let val_tree = ty::ValTree::from_raw_bytes(tcx, bytes);
402410

403-
ty::Const::new_value(tcx, val_tree, ty).stable(&mut *tables)
411+
mir::Const::Ty(ty::Const::new_value(tcx, val_tree, ty)).stable(&mut *tables)
404412
}
405413

406-
fn new_const_bool(&self, value: bool) -> Const {
414+
fn new_const_bool(&self, value: bool) -> MirConst {
407415
let mut tables = self.0.borrow_mut();
408-
ty::Const::from_bool(tables.tcx, value).stable(&mut *tables)
416+
mir::Const::Ty(ty::Const::from_bool(tables.tcx, value)).stable(&mut *tables)
409417
}
410418

411-
fn try_new_const_uint(&self, value: u128, uint_ty: UintTy) -> Result<Const, Error> {
419+
fn try_new_const_uint(&self, value: u128, uint_ty: UintTy) -> Result<MirConst, Error> {
420+
let mut tables = self.0.borrow_mut();
421+
let tcx = tables.tcx;
422+
let ty = ty::Ty::new_uint(tcx, uint_ty.internal(&mut *tables, tcx));
423+
let size = tables.tcx.layout_of(ParamEnv::empty().and(ty)).unwrap().size;
424+
425+
// We don't use Const::from_bits since it doesn't have any error checking.
426+
let scalar = ScalarInt::try_from_uint(value, size).ok_or_else(|| {
427+
Error::new(format!("Value overflow: cannot convert `{value}` to `{ty}`."))
428+
})?;
429+
Ok(mir::Const::Ty(ty::Const::new_value(tables.tcx, ValTree::from_scalar_int(scalar), ty))
430+
.stable(&mut *tables))
431+
}
432+
fn try_new_ty_const_uint(
433+
&self,
434+
value: u128,
435+
uint_ty: UintTy,
436+
) -> Result<stable_mir::ty::TyConst, Error> {
412437
let mut tables = self.0.borrow_mut();
413438
let tcx = tables.tcx;
414439
let ty = ty::Ty::new_uint(tcx, uint_ty.internal(&mut *tables, tcx));
@@ -453,7 +478,7 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
453478
.stable(&mut *tables)
454479
}
455480

456-
fn const_pretty(&self, cnst: &stable_mir::ty::Const) -> String {
481+
fn mir_const_pretty(&self, cnst: &stable_mir::ty::MirConst) -> String {
457482
let mut tables = self.0.borrow_mut();
458483
let tcx = tables.tcx;
459484
cnst.internal(&mut *tables, tcx).to_string()
@@ -474,6 +499,11 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
474499
tables.types[ty].kind().stable(&mut *tables)
475500
}
476501

502+
fn ty_const_pretty(&self, ct: stable_mir::ty::TyConstId) -> String {
503+
let tables = self.0.borrow_mut();
504+
tables.ty_consts[ct].to_string()
505+
}
506+
477507
fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> stable_mir::ty::Ty {
478508
let mut tables = self.0.borrow_mut();
479509
let tcx = tables.tcx;

‎compiler/rustc_smir/src/rustc_smir/convert/mir.rs

Lines changed: 11 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ use rustc_middle::mir::interpret::alloc_range;
66
use rustc_middle::mir::mono::MonoItem;
77
use stable_mir::mir::alloc::GlobalAlloc;
88
use stable_mir::mir::{ConstOperand, Statement, UserTypeProjection, VarDebugInfoFragment};
9-
use stable_mir::ty::{Allocation, Const, ConstantKind};
9+
use stable_mir::ty::{Allocation, ConstantKind, MirConst};
1010
use stable_mir::{opaque, Error};
1111

1212
use crate::rustc_smir::{alloc, Stable, Tables};
@@ -724,11 +724,16 @@ impl<'tcx> Stable<'tcx> for mir::interpret::GlobalAlloc<'tcx> {
724724
}
725725

726726
impl<'tcx> Stable<'tcx> for rustc_middle::mir::Const<'tcx> {
727-
type T = stable_mir::ty::Const;
727+
type T = stable_mir::ty::MirConst;
728728

729729
fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
730+
let id = tables.intern_mir_const(tables.tcx.lift(*self).unwrap());
730731
match *self {
731-
mir::Const::Ty(c) => c.stable(tables),
732+
mir::Const::Ty(c) => MirConst::new(
733+
stable_mir::ty::ConstantKind::Ty(c.stable(tables)),
734+
c.ty().stable(tables),
735+
id,
736+
),
732737
mir::Const::Unevaluated(unev_const, ty) => {
733738
let kind =
734739
stable_mir::ty::ConstantKind::Unevaluated(stable_mir::ty::UnevaluatedConst {
@@ -737,21 +742,18 @@ impl<'tcx> Stable<'tcx> for rustc_middle::mir::Const<'tcx> {
737742
promoted: unev_const.promoted.map(|u| u.as_u32()),
738743
});
739744
let ty = ty.stable(tables);
740-
let id = tables.intern_const(tables.tcx.lift(*self).unwrap());
741-
Const::new(kind, ty, id)
745+
MirConst::new(kind, ty, id)
742746
}
743747
mir::Const::Val(mir::ConstValue::ZeroSized, ty) => {
744748
let ty = ty.stable(tables);
745-
let id = tables.intern_const(tables.tcx.lift(*self).unwrap());
746-
Const::new(ConstantKind::ZeroSized, ty, id)
749+
MirConst::new(ConstantKind::ZeroSized, ty, id)
747750
}
748751
mir::Const::Val(val, ty) => {
749752
let ty = tables.tcx.lift(ty).unwrap();
750753
let val = tables.tcx.lift(val).unwrap();
751754
let kind = ConstantKind::Allocated(alloc::new_allocation(ty, val, tables));
752755
let ty = ty.stable(tables);
753-
let id = tables.intern_const(tables.tcx.lift(*self).unwrap());
754-
Const::new(kind, ty, id)
756+
MirConst::new(kind, ty, id)
755757
}
756758
}
757759
}

‎compiler/rustc_smir/src/rustc_smir/convert/ty.rs

Lines changed: 14 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -3,8 +3,7 @@
33
use rustc_middle::ty::Ty;
44
use rustc_middle::{mir, ty};
55
use stable_mir::ty::{
6-
AdtKind, Const, ConstantKind, FloatTy, GenericArgs, GenericParamDef, IntTy, Region, RigidTy,
7-
TyKind, UintTy,
6+
AdtKind, FloatTy, GenericArgs, GenericParamDef, IntTy, Region, RigidTy, TyKind, UintTy,
87
};
98

109
use crate::rustc_smir::{alloc, Stable, Tables};
@@ -411,7 +410,7 @@ impl<'tcx> Stable<'tcx> for ty::Pattern<'tcx> {
411410
}
412411

413412
impl<'tcx> Stable<'tcx> for ty::Const<'tcx> {
414-
type T = stable_mir::ty::Const;
413+
type T = stable_mir::ty::TyConst;
415414

416415
fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
417416
let kind = match self.kind() {
@@ -425,30 +424,27 @@ impl<'tcx> Stable<'tcx> for ty::Const<'tcx> {
425424
let ty = tables.tcx.lift(self.ty()).unwrap();
426425
let const_val = tables.tcx.valtree_to_const_val((ty, val));
427426
if matches!(const_val, mir::ConstValue::ZeroSized) {
428-
ConstantKind::ZeroSized
427+
stable_mir::ty::TyConstKind::ZSTValue(ty.stable(tables))
429428
} else {
430-
stable_mir::ty::ConstantKind::Allocated(alloc::new_allocation(
431-
ty, const_val, tables,
432-
))
429+
stable_mir::ty::TyConstKind::Value(
430+
ty.stable(tables),
431+
alloc::new_allocation(ty, const_val, tables),
432+
)
433433
}
434434
}
435-
ty::ParamCt(param) => stable_mir::ty::ConstantKind::Param(param.stable(tables)),
435+
ty::ParamCt(param) => stable_mir::ty::TyConstKind::Param(param.stable(tables)),
436+
ty::Unevaluated(uv) => stable_mir::ty::TyConstKind::Unevaluated(
437+
tables.const_def(uv.def),
438+
uv.args.stable(tables),
439+
),
436440
ty::ErrorCt(_) => unreachable!(),
437441
ty::InferCt(_) => unreachable!(),
438442
ty::BoundCt(_, _) => unimplemented!(),
439443
ty::PlaceholderCt(_) => unimplemented!(),
440-
ty::Unevaluated(uv) => {
441-
stable_mir::ty::ConstantKind::Unevaluated(stable_mir::ty::UnevaluatedConst {
442-
def: tables.const_def(uv.def),
443-
args: uv.args.stable(tables),
444-
promoted: None,
445-
})
446-
}
447444
ty::ExprCt(_) => unimplemented!(),
448445
};
449-
let ty = self.ty().stable(tables);
450-
let id = tables.intern_const(mir::Const::Ty(tables.tcx.lift(*self).unwrap()));
451-
Const::new(kind, ty, id)
446+
let id = tables.intern_ty_const(tables.tcx.lift(*self).unwrap());
447+
stable_mir::ty::TyConst::new(kind, id)
452448
}
453449
}
454450

‎compiler/rustc_smir/src/rustc_smir/mod.rs

Lines changed: 9 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
1414
use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE};
1515
use stable_mir::abi::Layout;
1616
use stable_mir::mir::mono::InstanceDef;
17-
use stable_mir::ty::{ConstId, Span};
17+
use stable_mir::ty::{MirConstId, Span, TyConstId};
1818
use stable_mir::{CtorKind, ItemKind};
1919
use std::ops::RangeInclusive;
2020
use tracing::debug;
@@ -33,7 +33,8 @@ pub struct Tables<'tcx> {
3333
pub(crate) spans: IndexMap<rustc_span::Span, Span>,
3434
pub(crate) types: IndexMap<Ty<'tcx>, stable_mir::ty::Ty>,
3535
pub(crate) instances: IndexMap<ty::Instance<'tcx>, InstanceDef>,
36-
pub(crate) constants: IndexMap<mir::Const<'tcx>, ConstId>,
36+
pub(crate) ty_consts: IndexMap<ty::Const<'tcx>, TyConstId>,
37+
pub(crate) mir_consts: IndexMap<mir::Const<'tcx>, MirConstId>,
3738
pub(crate) layouts: IndexMap<rustc_target::abi::Layout<'tcx>, Layout>,
3839
}
3940

@@ -42,8 +43,12 @@ impl<'tcx> Tables<'tcx> {
4243
self.types.create_or_fetch(ty)
4344
}
4445

45-
pub(crate) fn intern_const(&mut self, constant: mir::Const<'tcx>) -> ConstId {
46-
self.constants.create_or_fetch(constant)
46+
pub(crate) fn intern_ty_const(&mut self, ct: ty::Const<'tcx>) -> TyConstId {
47+
self.ty_consts.create_or_fetch(ct)
48+
}
49+
50+
pub(crate) fn intern_mir_const(&mut self, constant: mir::Const<'tcx>) -> MirConstId {
51+
self.mir_consts.create_or_fetch(constant)
4752
}
4853

4954
pub(crate) fn has_body(&self, instance: Instance<'tcx>) -> bool {

0 commit comments

Comments
 (0)