Skip to content

Commit 7e08f80

Browse files
BoxyUwUBoxyUwU
committed
Split smir Const into TyConst and MirConst 
1 parent 27529d5 commit 7e08f80

File tree

14 files changed

+285
-134
lines changed

14 files changed

+285
-134
lines changed

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

+19-25
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

+2-1
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

+46-13
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,45 @@ 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+
let ct = ty::Const::new_value(tcx, val_tree, ty);
412+
super::convert::mir_const_from_ty_const(&mut *tables, ct, ty)
404413
}
405414

406-
fn new_const_bool(&self, value: bool) -> Const {
415+
fn new_const_bool(&self, value: bool) -> MirConst {
407416
let mut tables = self.0.borrow_mut();
408-
ty::Const::from_bool(tables.tcx, value).stable(&mut *tables)
417+
let ct = ty::Const::from_bool(tables.tcx, value);
418+
let ty = tables.tcx.types.bool;
419+
super::convert::mir_const_from_ty_const(&mut *tables, ct, ty)
409420
}
410421

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

456-
fn const_pretty(&self, cnst: &stable_mir::ty::Const) -> String {
484+
fn mir_const_pretty(&self, cnst: &stable_mir::ty::MirConst) -> String {
457485
let mut tables = self.0.borrow_mut();
458486
let tcx = tables.tcx;
459487
cnst.internal(&mut *tables, tcx).to_string()
@@ -474,6 +502,11 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
474502
tables.types[ty].kind().stable(&mut *tables)
475503
}
476504

505+
fn ty_const_pretty(&self, ct: stable_mir::ty::TyConstId) -> String {
506+
let tables = self.0.borrow_mut();
507+
tables.ty_consts[ct].to_string()
508+
}
509+
477510
fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> stable_mir::ty::Ty {
478511
let mut tables = self.0.borrow_mut();
479512
let tcx = tables.tcx;

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

+11-9
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/mod.rs

+2
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,8 @@ mod error;
99
mod mir;
1010
mod ty;
1111

12+
pub use ty::mir_const_from_ty_const;
13+
1214
impl<'tcx> Stable<'tcx> for rustc_hir::Safety {
1315
type T = stable_mir::mir::Safety;
1416
fn stable(&self, _: &mut Tables<'_>) -> Self::T {

0 commit comments

Comments
 (0)