Skip to content

Commit a5dc684

Browse files
compiler-errorscompiler-errors
authored
Rollup merge of #125968 - BoxyUwU:shrink_ty_expr, r=oli-obk
Store the types of `ty::Expr` arguments in the `ty::Expr` Part of #125958 In attempting to remove the `ty` field on `Const` it will become necessary to store the `Ty<'tcx>` inside of `Expr<'tcx>`. In order to do this without blowing up the size of `ConstKind`, we start storing the type/const args as `GenericArgs` r? `@oli-obk`
2 parents 288727e + 67a73f2 commit a5dc684

File tree

13 files changed

+259
-165
lines changed

13 files changed

+259
-165
lines changed

Diff for: ‎compiler/rustc_middle/src/ty/consts.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@ pub type ConstKind<'tcx> = ir::ConstKind<TyCtxt<'tcx>>;
2424
pub type UnevaluatedConst<'tcx> = ir::UnevaluatedConst<TyCtxt<'tcx>>;
2525

2626
#[cfg(target_pointer_width = "64")]
27-
rustc_data_structures::static_assert_size!(ConstKind<'_>, 32);
27+
rustc_data_structures::static_assert_size!(ConstKind<'_>, 24);
2828

2929
/// Use this rather than `ConstData`, whenever possible.
3030
#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable)]
@@ -58,7 +58,7 @@ pub struct ConstData<'tcx> {
5858
}
5959

6060
#[cfg(target_pointer_width = "64")]
61-
rustc_data_structures::static_assert_size!(ConstData<'_>, 40);
61+
rustc_data_structures::static_assert_size!(ConstData<'_>, 32);
6262

6363
impl<'tcx> Const<'tcx> {
6464
#[inline]

Diff for: ‎compiler/rustc_middle/src/ty/consts/kind.rs

+118-7
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
use super::Const;
22
use crate::mir;
33
use crate::ty::abstract_const::CastKind;
4-
use crate::ty::{self, visit::TypeVisitableExt as _, List, Ty, TyCtxt};
4+
use crate::ty::{self, visit::TypeVisitableExt as _, Ty, TyCtxt};
55
use rustc_macros::{extension, HashStable, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable};
66

77
#[extension(pub(crate) trait UnevaluatedConstEvalExt<'tcx>)]
@@ -40,14 +40,125 @@ impl<'tcx> ty::UnevaluatedConst<'tcx> {
4040
}
4141
}
4242

43+
#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
44+
#[derive(HashStable, TyEncodable, TyDecodable, TypeVisitable, TypeFoldable)]
45+
pub enum ExprKind {
46+
Binop(mir::BinOp),
47+
UnOp(mir::UnOp),
48+
FunctionCall,
49+
Cast(CastKind),
50+
}
4351
#[derive(Copy, Clone, Eq, PartialEq, Hash)]
4452
#[derive(HashStable, TyEncodable, TyDecodable, TypeVisitable, TypeFoldable)]
45-
pub enum Expr<'tcx> {
46-
Binop(mir::BinOp, Const<'tcx>, Const<'tcx>),
47-
UnOp(mir::UnOp, Const<'tcx>),
48-
FunctionCall(Const<'tcx>, &'tcx List<Const<'tcx>>),
49-
Cast(CastKind, Const<'tcx>, Ty<'tcx>),
53+
pub struct Expr<'tcx> {
54+
pub kind: ExprKind,
55+
args: ty::GenericArgsRef<'tcx>,
56+
}
57+
impl<'tcx> Expr<'tcx> {
58+
pub fn new_binop(
59+
tcx: TyCtxt<'tcx>,
60+
binop: mir::BinOp,
61+
lhs_ty: Ty<'tcx>,
62+
rhs_ty: Ty<'tcx>,
63+
lhs_ct: Const<'tcx>,
64+
rhs_ct: Const<'tcx>,
65+
) -> Self {
66+
let args = tcx.mk_args_from_iter::<_, ty::GenericArg<'tcx>>(
67+
[lhs_ty.into(), rhs_ty.into(), lhs_ct.into(), rhs_ct.into()].into_iter(),
68+
);
69+
70+
Self { kind: ExprKind::Binop(binop), args }
71+
}
72+
73+
pub fn binop_args(self) -> (Ty<'tcx>, Ty<'tcx>, Const<'tcx>, Const<'tcx>) {
74+
assert!(matches!(self.kind, ExprKind::Binop(_)));
75+
76+
match self.args().as_slice() {
77+
[lhs_ty, rhs_ty, lhs_ct, rhs_ct] => (
78+
lhs_ty.expect_ty(),
79+
rhs_ty.expect_ty(),
80+
lhs_ct.expect_const(),
81+
rhs_ct.expect_const(),
82+
),
83+
_ => bug!("Invalid args for `Binop` expr {self:?}"),
84+
}
85+
}
86+
87+
pub fn new_unop(tcx: TyCtxt<'tcx>, unop: mir::UnOp, ty: Ty<'tcx>, ct: Const<'tcx>) -> Self {
88+
let args =
89+
tcx.mk_args_from_iter::<_, ty::GenericArg<'tcx>>([ty.into(), ct.into()].into_iter());
90+
91+
Self { kind: ExprKind::UnOp(unop), args }
92+
}
93+
94+
pub fn unop_args(self) -> (Ty<'tcx>, Const<'tcx>) {
95+
assert!(matches!(self.kind, ExprKind::UnOp(_)));
96+
97+
match self.args().as_slice() {
98+
[ty, ct] => (ty.expect_ty(), ct.expect_const()),
99+
_ => bug!("Invalid args for `UnOp` expr {self:?}"),
100+
}
101+
}
102+
103+
pub fn new_call(
104+
tcx: TyCtxt<'tcx>,
105+
func_ty: Ty<'tcx>,
106+
func_expr: Const<'tcx>,
107+
arguments: impl Iterator<Item = Const<'tcx>>,
108+
) -> Self {
109+
let args = tcx.mk_args_from_iter::<_, ty::GenericArg<'tcx>>(
110+
[func_ty.into(), func_expr.into()].into_iter().chain(arguments.map(|ct| ct.into())),
111+
);
112+
113+
Self { kind: ExprKind::FunctionCall, args }
114+
}
115+
116+
pub fn call_args(self) -> (Ty<'tcx>, Const<'tcx>, impl Iterator<Item = Const<'tcx>>) {
117+
assert!(matches!(self.kind, ExprKind::FunctionCall));
118+
119+
match self.args().as_slice() {
120+
[func_ty, func, rest @ ..] => (
121+
func_ty.expect_ty(),
122+
func.expect_const(),
123+
rest.iter().map(|arg| arg.expect_const()),
124+
),
125+
_ => bug!("Invalid args for `Call` expr {self:?}"),
126+
}
127+
}
128+
129+
pub fn new_cast(
130+
tcx: TyCtxt<'tcx>,
131+
cast: CastKind,
132+
value_ty: Ty<'tcx>,
133+
value: Const<'tcx>,
134+
to_ty: Ty<'tcx>,
135+
) -> Self {
136+
let args = tcx.mk_args_from_iter::<_, ty::GenericArg<'tcx>>(
137+
[value_ty.into(), value.into(), to_ty.into()].into_iter(),
138+
);
139+
140+
Self { kind: ExprKind::Cast(cast), args }
141+
}
142+
143+
pub fn cast_args(self) -> (Ty<'tcx>, Const<'tcx>, Ty<'tcx>) {
144+
assert!(matches!(self.kind, ExprKind::Cast(_)));
145+
146+
match self.args().as_slice() {
147+
[value_ty, value, to_ty] => {
148+
(value_ty.expect_ty(), value.expect_const(), to_ty.expect_ty())
149+
}
150+
_ => bug!("Invalid args for `Cast` expr {self:?}"),
151+
}
152+
}
153+
154+
pub fn new(kind: ExprKind, args: ty::GenericArgsRef<'tcx>) -> Self {
155+
Self { kind, args }
156+
}
157+
158+
pub fn args(&self) -> ty::GenericArgsRef<'tcx> {
159+
self.args
160+
}
50161
}
51162

52163
#[cfg(target_pointer_width = "64")]
53-
rustc_data_structures::static_assert_size!(Expr<'_>, 24);
164+
rustc_data_structures::static_assert_size!(Expr<'_>, 16);

Diff for: ‎compiler/rustc_middle/src/ty/flags.rs

+1-20
Original file line numberDiff line numberDiff line change
@@ -374,26 +374,7 @@ impl FlagComputation {
374374
self.add_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
375375
}
376376
ty::ConstKind::Value(_) => {}
377-
ty::ConstKind::Expr(e) => {
378-
use ty::Expr;
379-
match e {
380-
Expr::Binop(_, l, r) => {
381-
self.add_const(l);
382-
self.add_const(r);
383-
}
384-
Expr::UnOp(_, v) => self.add_const(v),
385-
Expr::FunctionCall(f, args) => {
386-
self.add_const(f);
387-
for arg in args {
388-
self.add_const(arg);
389-
}
390-
}
391-
Expr::Cast(_, c, t) => {
392-
self.add_ty(t);
393-
self.add_const(c);
394-
}
395-
}
396-
}
377+
ty::ConstKind::Expr(e) => self.add_args(e.args()),
397378
ty::ConstKind::Error(_) => self.add_flags(TypeFlags::HAS_ERROR),
398379
}
399380
}

Diff for: ‎compiler/rustc_middle/src/ty/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -87,7 +87,7 @@ pub use self::closure::{
8787
CAPTURE_STRUCT_LOCAL,
8888
};
8989
pub use self::consts::{
90-
Const, ConstData, ConstInt, ConstKind, Expr, ScalarInt, UnevaluatedConst, ValTree,
90+
Const, ConstData, ConstInt, ConstKind, Expr, ExprKind, ScalarInt, UnevaluatedConst, ValTree,
9191
};
9292
pub use self::context::{
9393
tls, CtxtInterners, CurrentGcx, DeducedParamAttrs, Feed, FreeRegionInfo, GlobalCtxt, Lift,

Diff for: ‎compiler/rustc_middle/src/ty/print/pretty.rs

+44-58
Original file line numberDiff line numberDiff line change
@@ -1533,8 +1533,10 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
15331533
print_ty: bool,
15341534
) -> Result<(), PrintError> {
15351535
define_scoped_cx!(self);
1536-
match expr {
1537-
Expr::Binop(op, c1, c2) => {
1536+
match expr.kind {
1537+
ty::ExprKind::Binop(op) => {
1538+
let (_, _, c1, c2) = expr.binop_args();
1539+
15381540
let precedence = |binop: rustc_middle::mir::BinOp| {
15391541
use rustc_ast::util::parser::AssocOp;
15401542
AssocOp::from_ast_binop(binop.to_hir_binop().into()).precedence()
@@ -1543,22 +1545,26 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
15431545
let formatted_op = op.to_hir_binop().as_str();
15441546
let (lhs_parenthesized, rhs_parenthesized) = match (c1.kind(), c2.kind()) {
15451547
(
1546-
ty::ConstKind::Expr(Expr::Binop(lhs_op, _, _)),
1547-
ty::ConstKind::Expr(Expr::Binop(rhs_op, _, _)),
1548+
ty::ConstKind::Expr(ty::Expr { kind: ty::ExprKind::Binop(lhs_op), .. }),
1549+
ty::ConstKind::Expr(ty::Expr { kind: ty::ExprKind::Binop(rhs_op), .. }),
15481550
) => (precedence(lhs_op) < op_precedence, precedence(rhs_op) < op_precedence),
1549-
(ty::ConstKind::Expr(Expr::Binop(lhs_op, ..)), ty::ConstKind::Expr(_)) => {
1550-
(precedence(lhs_op) < op_precedence, true)
1551-
}
1552-
(ty::ConstKind::Expr(_), ty::ConstKind::Expr(Expr::Binop(rhs_op, ..))) => {
1553-
(true, precedence(rhs_op) < op_precedence)
1554-
}
1551+
(
1552+
ty::ConstKind::Expr(ty::Expr { kind: ty::ExprKind::Binop(lhs_op), .. }),
1553+
ty::ConstKind::Expr(_),
1554+
) => (precedence(lhs_op) < op_precedence, true),
1555+
(
1556+
ty::ConstKind::Expr(_),
1557+
ty::ConstKind::Expr(ty::Expr { kind: ty::ExprKind::Binop(rhs_op), .. }),
1558+
) => (true, precedence(rhs_op) < op_precedence),
15551559
(ty::ConstKind::Expr(_), ty::ConstKind::Expr(_)) => (true, true),
1556-
(ty::ConstKind::Expr(Expr::Binop(lhs_op, ..)), _) => {
1557-
(precedence(lhs_op) < op_precedence, false)
1558-
}
1559-
(_, ty::ConstKind::Expr(Expr::Binop(rhs_op, ..))) => {
1560-
(false, precedence(rhs_op) < op_precedence)
1561-
}
1560+
(
1561+
ty::ConstKind::Expr(ty::Expr { kind: ty::ExprKind::Binop(lhs_op), .. }),
1562+
_,
1563+
) => (precedence(lhs_op) < op_precedence, false),
1564+
(
1565+
_,
1566+
ty::ConstKind::Expr(ty::Expr { kind: ty::ExprKind::Binop(rhs_op), .. }),
1567+
) => (false, precedence(rhs_op) < op_precedence),
15621568
(ty::ConstKind::Expr(_), _) => (true, false),
15631569
(_, ty::ConstKind::Expr(_)) => (false, true),
15641570
_ => (false, false),
@@ -1574,7 +1580,9 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
15741580
rhs_parenthesized,
15751581
)?;
15761582
}
1577-
Expr::UnOp(op, ct) => {
1583+
ty::ExprKind::UnOp(op) => {
1584+
let (_, ct) = expr.unop_args();
1585+
15781586
use rustc_middle::mir::UnOp;
15791587
let formatted_op = match op {
15801588
UnOp::Not => "!",
@@ -1583,7 +1591,9 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
15831591
};
15841592
let parenthesized = match ct.kind() {
15851593
_ if op == UnOp::PtrMetadata => true,
1586-
ty::ConstKind::Expr(Expr::UnOp(c_op, ..)) => c_op != op,
1594+
ty::ConstKind::Expr(ty::Expr { kind: ty::ExprKind::UnOp(c_op), .. }) => {
1595+
c_op != op
1596+
}
15871597
ty::ConstKind::Expr(_) => true,
15881598
_ => false,
15891599
};
@@ -1593,61 +1603,37 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
15931603
parenthesized,
15941604
)?
15951605
}
1596-
Expr::FunctionCall(fn_def, fn_args) => {
1597-
use ty::TyKind;
1598-
match fn_def.ty().kind() {
1599-
TyKind::FnDef(def_id, gen_args) => {
1600-
p!(print_value_path(*def_id, gen_args), "(");
1601-
if print_ty {
1602-
let tcx = self.tcx();
1603-
let sig = tcx.fn_sig(def_id).instantiate(tcx, gen_args).skip_binder();
1604-
1605-
let mut args_with_ty = fn_args.iter().map(|ct| (ct, ct.ty()));
1606-
let output_ty = sig.output();
1607-
1608-
if let Some((ct, ty)) = args_with_ty.next() {
1609-
self.typed_value(
1610-
|this| this.pretty_print_const(ct, print_ty),
1611-
|this| this.pretty_print_type(ty),
1612-
": ",
1613-
)?;
1614-
for (ct, ty) in args_with_ty {
1615-
p!(", ");
1616-
self.typed_value(
1617-
|this| this.pretty_print_const(ct, print_ty),
1618-
|this| this.pretty_print_type(ty),
1619-
": ",
1620-
)?;
1621-
}
1622-
}
1623-
p!(write(") -> {output_ty}"));
1624-
} else {
1625-
p!(comma_sep(fn_args.iter()), ")");
1626-
}
1627-
}
1628-
_ => bug!("unexpected type of fn def"),
1629-
}
1606+
ty::ExprKind::FunctionCall => {
1607+
let (_, fn_def, fn_args) = expr.call_args();
1608+
1609+
write!(self, "(")?;
1610+
self.pretty_print_const(fn_def, print_ty)?;
1611+
p!(")(", comma_sep(fn_args), ")");
16301612
}
1631-
Expr::Cast(kind, ct, ty) => {
1613+
ty::ExprKind::Cast(kind) => {
1614+
let (_, value, to_ty) = expr.cast_args();
1615+
16321616
use ty::abstract_const::CastKind;
16331617
if kind == CastKind::As || (kind == CastKind::Use && self.should_print_verbose()) {
1634-
let parenthesized = match ct.kind() {
1635-
ty::ConstKind::Expr(Expr::Cast(_, _, _)) => false,
1618+
let parenthesized = match value.kind() {
1619+
ty::ConstKind::Expr(ty::Expr {
1620+
kind: ty::ExprKind::Cast { .. }, ..
1621+
}) => false,
16361622
ty::ConstKind::Expr(_) => true,
16371623
_ => false,
16381624
};
16391625
self.maybe_parenthesized(
16401626
|this| {
16411627
this.typed_value(
1642-
|this| this.pretty_print_const(ct, print_ty),
1643-
|this| this.pretty_print_type(ty),
1628+
|this| this.pretty_print_const(value, print_ty),
1629+
|this| this.pretty_print_type(to_ty),
16441630
" as ",
16451631
)
16461632
},
16471633
parenthesized,
16481634
)?;
16491635
} else {
1650-
self.pretty_print_const(ct, print_ty)?
1636+
self.pretty_print_const(value, print_ty)?
16511637
}
16521638
}
16531639
}

0 commit comments

Comments
 (0)