Skip to content

Commit c797096

Browse files
borsbors
committed
Auto merge of rust-lang#149140 - oli-obk:more-encoder-minimization, r=jdonszelmann
More encoder minimizations follow-up to rust-lang#149054
2 parents 6840234 + b93f2d8 commit c797096

File tree

5 files changed

+73
-95
lines changed

5 files changed

+73
-95
lines changed

‎compiler/rustc_hir/src/hir.rs‎

Lines changed: 12 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3841,8 +3841,12 @@ impl IsAsync {
38413841
}
38423842

38433843
#[derive(Copy, Clone, PartialEq, Eq, Debug, Encodable, Decodable, HashStable_Generic)]
3844+
#[derive(Default)]
38443845
pub enum Defaultness {
3845-
Default { has_value: bool },
3846+
Default {
3847+
has_value: bool,
3848+
},
3849+
#[default]
38463850
Final,
38473851
}
38483852

@@ -4186,8 +4190,13 @@ impl<'hir> Item<'hir> {
41864190
}
41874191

41884192
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
4189-
#[derive(Encodable, Decodable, HashStable_Generic)]
4193+
#[derive(Encodable, Decodable, HashStable_Generic, Default)]
41904194
pub enum Safety {
4195+
/// This is the default variant, because the compiler messing up
4196+
/// metadata encoding and failing to encode a `Safe` flag, means
4197+
/// downstream crates think a thing is `Unsafe` instead of silently
4198+
/// treating an unsafe thing as safe.
4199+
#[default]
41914200
Unsafe,
41924201
Safe,
41934202
}
@@ -4226,8 +4235,8 @@ impl fmt::Display for Safety {
42264235
#[derive(Copy, Clone, PartialEq, Eq, Debug, Encodable, Decodable, HashStable_Generic)]
42274236
#[derive(Default)]
42284237
pub enum Constness {
4229-
Const,
42304238
#[default]
4239+
Const,
42314240
NotConst,
42324241
}
42334242

‎compiler/rustc_metadata/src/rmeta/decoder.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1187,7 +1187,7 @@ impl<'a> CrateMetadataRef<'a> {
11871187
}
11881188

11891189
fn get_safety(self, id: DefIndex) -> Safety {
1190-
self.root.tables.safety.get(self, id).unwrap_or_else(|| self.missing("safety", id))
1190+
self.root.tables.safety.get(self, id)
11911191
}
11921192

11931193
fn get_default_field(self, id: DefIndex) -> Option<DefId> {

‎compiler/rustc_metadata/src/rmeta/encoder.rs‎

Lines changed: 5 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1524,17 +1524,11 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
15241524
}
15251525
if should_encode_constness(def_kind) {
15261526
let constness = self.tcx.constness(def_id);
1527-
match constness {
1528-
hir::Constness::Const => self.tables.constness.set(def_id.index, constness),
1529-
hir::Constness::NotConst => {}
1530-
}
1527+
self.tables.constness.set(def_id.index, constness);
15311528
}
15321529
if let DefKind::Fn | DefKind::AssocFn = def_kind {
15331530
let asyncness = tcx.asyncness(def_id);
1534-
match asyncness {
1535-
ty::Asyncness::Yes => self.tables.asyncness.set(def_id.index, asyncness),
1536-
ty::Asyncness::No => {}
1537-
}
1531+
self.tables.asyncness.set(def_id.index, asyncness);
15381532
record_array!(self.tables.fn_arg_idents[def_id] <- tcx.fn_arg_idents(def_id));
15391533
}
15401534
if let Some(name) = tcx.intrinsic(def_id) {
@@ -1697,7 +1691,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
16971691
}));
16981692

16991693
for field in &variant.fields {
1700-
self.tables.safety.set_some(field.did.index, field.safety);
1694+
self.tables.safety.set(field.did.index, field.safety);
17011695
}
17021696

17031697
if let Some((CtorKind::Fn, ctor_def_id)) = variant.ctor {
@@ -1759,7 +1753,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
17591753
let item = tcx.associated_item(def_id);
17601754

17611755
if matches!(item.container, AssocContainer::Trait | AssocContainer::TraitImpl(_)) {
1762-
self.tables.defaultness.set_some(def_id.index, item.defaultness(tcx));
1756+
self.tables.defaultness.set(def_id.index, item.defaultness(tcx));
17631757
}
17641758

17651759
record!(self.tables.assoc_container[def_id] <- item.container);
@@ -2161,7 +2155,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
21612155
let header = tcx.impl_trait_header(def_id);
21622156
record!(self.tables.impl_trait_header[def_id] <- header);
21632157

2164-
self.tables.defaultness.set_some(def_id.index, tcx.defaultness(def_id));
2158+
self.tables.defaultness.set(def_id.index, tcx.defaultness(def_id));
21652159

21662160
let trait_ref = header.trait_ref.instantiate_identity();
21672161
let simplified_self_ty = fast_reject::simplify_type(

‎compiler/rustc_metadata/src/rmeta/mod.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -402,6 +402,8 @@ define_tables! {
402402
cross_crate_inlinable: Table<DefIndex, bool>,
403403
asyncness: Table<DefIndex, ty::Asyncness>,
404404
constness: Table<DefIndex, hir::Constness>,
405+
safety: Table<DefIndex, hir::Safety>,
406+
defaultness: Table<DefIndex, hir::Defaultness>,
405407

406408
- optional:
407409
attributes: Table<DefIndex, LazyArray<hir::Attribute>>,
@@ -411,7 +413,6 @@ define_tables! {
411413
associated_item_or_field_def_ids: Table<DefIndex, LazyArray<DefIndex>>,
412414
def_kind: Table<DefIndex, DefKind>,
413415
visibility: Table<DefIndex, LazyValue<ty::Visibility<DefIndex>>>,
414-
safety: Table<DefIndex, hir::Safety>,
415416
def_span: Table<DefIndex, LazyValue<Span>>,
416417
def_ident_span: Table<DefIndex, LazyValue<Span>>,
417418
lookup_stability: Table<DefIndex, LazyValue<hir::Stability>>,
@@ -436,7 +437,6 @@ define_tables! {
436437
thir_abstract_const: Table<DefIndex, LazyValue<ty::EarlyBinder<'static, ty::Const<'static>>>>,
437438
impl_parent: Table<DefIndex, RawDefId>,
438439
const_conditions: Table<DefIndex, LazyValue<ty::ConstConditions<'static>>>,
439-
defaultness: Table<DefIndex, hir::Defaultness>,
440440
// FIXME(eddyb) perhaps compute this on the fly if cheap enough?
441441
coerce_unsized_info: Table<DefIndex, LazyValue<ty::adjustment::CoerceUnsizedInfo>>,
442442
mir_const_qualif: Table<DefIndex, LazyValue<mir::ConstQualifs>>,

‎compiler/rustc_metadata/src/rmeta/table.rs‎

Lines changed: 53 additions & 78 deletions
Original file line numberDiff line numberDiff line change
@@ -25,24 +25,6 @@ impl IsDefault for bool {
2525
}
2626
}
2727

28-
impl IsDefault for ty::Asyncness {
29-
fn is_default(&self) -> bool {
30-
match self {
31-
ty::Asyncness::Yes => false,
32-
ty::Asyncness::No => true,
33-
}
34-
}
35-
}
36-
37-
impl IsDefault for hir::Constness {
38-
fn is_default(&self) -> bool {
39-
match self {
40-
rustc_hir::Constness::Const => false,
41-
rustc_hir::Constness::NotConst => true,
42-
}
43-
}
44-
}
45-
4628
impl IsDefault for u32 {
4729
fn is_default(&self) -> bool {
4830
*self == 0
@@ -130,6 +112,43 @@ macro_rules! fixed_size_enum {
130112
}
131113
}
132114

115+
macro_rules! defaulted_enum {
116+
($ty:ty { $(($($pat:tt)*))* } $( unreachable { $(($($upat:tt)*))+ } )?) => {
117+
impl FixedSizeEncoding for $ty {
118+
type ByteArray = [u8; 1];
119+
120+
#[inline]
121+
fn from_bytes(b: &[u8; 1]) -> Self {
122+
use $ty::*;
123+
let val = match b[0] {
124+
$(${index()} => $($pat)*,)*
125+
_ => panic!("Unexpected {} code: {:?}", stringify!($ty), b[0]),
126+
};
127+
// Make sure the first entry is always the default value,
128+
// and none of the other values are the default value
129+
debug_assert_ne!((b[0] != 0), IsDefault::is_default(&val));
130+
val
131+
}
132+
133+
#[inline]
134+
fn write_to_bytes(self, b: &mut [u8; 1]) {
135+
debug_assert!(!IsDefault::is_default(&self));
136+
use $ty::*;
137+
b[0] = match self {
138+
$($($pat)* => ${index()},)*
139+
$($($($upat)*)|+ => unreachable!(),)?
140+
};
141+
debug_assert_ne!(b[0], 0);
142+
}
143+
}
144+
impl IsDefault for $ty {
145+
fn is_default(&self) -> bool {
146+
<$ty as Default>::default() == *self
147+
}
148+
}
149+
}
150+
}
151+
133152
// Workaround; need const traits to construct bitflags in a const
134153
macro_rules! const_macro_kinds {
135154
($($name:ident),+$(,)?) => (MacroKinds::from_bits_truncate($(MacroKinds::$name.bits())|+))
@@ -196,32 +215,32 @@ fixed_size_enum! {
196215
}
197216
}
198217

199-
fixed_size_enum! {
200-
hir::Constness {
201-
( NotConst )
202-
( Const )
203-
}
204-
}
205-
206-
fixed_size_enum! {
218+
defaulted_enum! {
207219
hir::Defaultness {
208220
( Final )
209221
( Default { has_value: false } )
210222
( Default { has_value: true } )
211223
}
212224
}
213225

214-
fixed_size_enum! {
215-
hir::Safety {
216-
( Unsafe )
217-
( Safe )
226+
defaulted_enum! {
227+
ty::Asyncness {
228+
( No )
229+
( Yes )
218230
}
219231
}
220232

221-
fixed_size_enum! {
222-
ty::Asyncness {
223-
( Yes )
224-
( No )
233+
defaulted_enum! {
234+
hir::Constness {
235+
( Const )
236+
( NotConst )
237+
}
238+
}
239+
240+
defaulted_enum! {
241+
hir::Safety {
242+
( Unsafe )
243+
( Safe )
225244
}
226245
}
227246

@@ -313,50 +332,6 @@ impl FixedSizeEncoding for bool {
313332
}
314333
}
315334

316-
impl FixedSizeEncoding for ty::Asyncness {
317-
type ByteArray = [u8; 1];
318-
319-
#[inline]
320-
fn from_bytes(b: &[u8; 1]) -> Self {
321-
match b[0] {
322-
0 => ty::Asyncness::No,
323-
1 => ty::Asyncness::Yes,
324-
_ => unreachable!(),
325-
}
326-
}
327-
328-
#[inline]
329-
fn write_to_bytes(self, b: &mut [u8; 1]) {
330-
debug_assert!(!self.is_default());
331-
b[0] = match self {
332-
ty::Asyncness::No => 0,
333-
ty::Asyncness::Yes => 1,
334-
}
335-
}
336-
}
337-
338-
impl FixedSizeEncoding for hir::Constness {
339-
type ByteArray = [u8; 1];
340-
341-
#[inline]
342-
fn from_bytes(b: &[u8; 1]) -> Self {
343-
match b[0] {
344-
0 => hir::Constness::NotConst,
345-
1 => hir::Constness::Const,
346-
_ => unreachable!(),
347-
}
348-
}
349-
350-
#[inline]
351-
fn write_to_bytes(self, b: &mut [u8; 1]) {
352-
debug_assert!(!self.is_default());
353-
b[0] = match self {
354-
hir::Constness::NotConst => 0,
355-
hir::Constness::Const => 1,
356-
}
357-
}
358-
}
359-
360335
// NOTE(eddyb) there could be an impl for `usize`, which would enable a more
361336
// generic `LazyValue<T>` impl, but in the general case we might not need / want
362337
// to fit every `usize` in `u32`.

0 commit comments

Comments
 (0)