Skip to content

Commit 9677cbe

Browse files
skinnyBatskinnyBat
committed
Refactor pretty print const to use a big match statement
1 parent 43badf9 commit 9677cbe

File tree

3 files changed

+106
-123
lines changed

3 files changed

+106
-123
lines changed

‎src/librustc/ty/print/pretty.rs

Lines changed: 104 additions & 121 deletions
Original file line numberDiff line numberDiff line change
@@ -863,137 +863,120 @@ pub trait PrettyPrinter<'tcx>:
863863
}
864864

865865
let u8 = self.tcx().types.u8;
866-
if let ty::FnDef(did, substs) = ct.ty.kind {
867-
p!(print_value_path(did, substs));
868-
return Ok(self);
869-
}
870-
if let ConstValue::Unevaluated(did, substs) = ct.val {
871-
match self.tcx().def_kind(did) {
872-
| Some(DefKind::Static)
873-
| Some(DefKind::Const)
874-
| Some(DefKind::AssocConst) => p!(print_value_path(did, substs)),
875-
_ => if did.is_local() {
876-
let span = self.tcx().def_span(did);
877-
if let Ok(snip) = self.tcx().sess.source_map().span_to_snippet(span) {
878-
p!(write("{}", snip))
879-
} else {
880-
p!(write("_: "), print(ct.ty))
881-
}
882-
} else {
883-
p!(write("_: "), print(ct.ty))
884-
},
885-
}
886-
return Ok(self);
887-
}
888-
if let ConstValue::Infer(..) = ct.val {
889-
p!(write("_: "), print(ct.ty));
890-
return Ok(self);
891-
}
892-
if let ConstValue::Param(ParamConst { name, .. }) = ct.val {
893-
p!(write("{}", name));
894-
return Ok(self);
895-
}
896-
if let ConstValue::Scalar(Scalar::Raw { data, .. }) = ct.val {
897-
match ct.ty.kind {
898-
ty::Bool => {
899-
p!(write("{}", if data == 0 { "false" } else { "true" }));
900-
return Ok(self);
901-
},
902-
ty::Float(ast::FloatTy::F32) => {
903-
p!(write("{}f32", Single::from_bits(data)));
904-
return Ok(self);
905-
},
906-
ty::Float(ast::FloatTy::F64) => {
907-
p!(write("{}f64", Double::from_bits(data)));
908-
return Ok(self);
909-
},
910-
ty::Uint(ui) => {
911-
let bit_size = Integer::from_attr(&self.tcx(), UnsignedInt(ui)).size();
912-
let max = truncate(u128::max_value(), bit_size);
913866

914-
if data == max {
915-
p!(write("std::{}::MAX", ui))
867+
match (ct.val, &ct.ty.kind) {
868+
(_, ty::FnDef(did, substs)) => p!(print_value_path(*did, substs)),
869+
(ConstValue::Unevaluated(did, substs), _) => {
870+
match self.tcx().def_kind(did) {
871+
| Some(DefKind::Static)
872+
| Some(DefKind::Const)
873+
| Some(DefKind::AssocConst) => p!(print_value_path(did, substs)),
874+
_ => if did.is_local() {
875+
let span = self.tcx().def_span(did);
876+
if let Ok(snip) = self.tcx().sess.source_map().span_to_snippet(span) {
877+
p!(write("{}", snip))
878+
} else {
879+
p!(write("_: "), print(ct.ty))
880+
}
916881
} else {
917-
p!(write("{}{}", data, ui))
918-
};
919-
return Ok(self);
920-
},
921-
ty::Int(i) =>{
922-
let bit_size = Integer::from_attr(&self.tcx(), SignedInt(i))
923-
.size().bits() as u128;
924-
let min = 1u128 << (bit_size - 1);
925-
let max = min - 1;
926-
927-
let ty = self.tcx().lift(&ct.ty).unwrap();
928-
let size = self.tcx().layout_of(ty::ParamEnv::empty().and(ty))
929-
.unwrap()
930-
.size;
931-
match data {
932-
d if d == min => p!(write("std::{}::MIN", i)),
933-
d if d == max => p!(write("std::{}::MAX", i)),
934-
_ => p!(write("{}{}", sign_extend(data, size) as i128, i))
935-
}
936-
return Ok(self);
937-
},
938-
ty::Char => {
939-
p!(write("{:?}", ::std::char::from_u32(data as u32).unwrap()));
940-
return Ok(self);
882+
p!(write("_: "), print(ct.ty))
883+
},
941884
}
942-
_ => {},
943-
}
944-
}
945-
if let ty::Ref(_, ref_ty, _) = ct.ty.kind {
946-
let byte_str = match (ct.val, &ref_ty.kind) {
947-
(ConstValue::Scalar(Scalar::Ptr(ptr)), ty::Array(t, n)) if *t == u8 => {
948-
let n = n.eval_usize(self.tcx(), ty::ParamEnv::empty());
949-
Some(self.tcx()
950-
.alloc_map.lock()
951-
.unwrap_memory(ptr.alloc_id)
952-
.get_bytes(&self.tcx(), ptr, Size::from_bytes(n)).unwrap())
953-
},
954-
(ConstValue::Slice { data, start, end }, ty::Slice(t)) if *t == u8 => {
955-
// The `inspect` here is okay since we checked the bounds, and there are no
956-
// relocations (we have an active slice reference here). We don't use this
957-
// result to affect interpreter execution.
958-
Some(data.inspect_with_undef_and_ptr_outside_interpreter(start..end))
959-
},
960-
(ConstValue::Slice { data, start, end }, ty::Str) => {
961-
// The `inspect` here is okay since we checked the bounds, and there are no
962-
// relocations (we have an active `str` reference here). We don't use this
963-
// result to affect interpreter execution.
964-
let slice = data.inspect_with_undef_and_ptr_outside_interpreter(start..end);
965-
let s = ::std::str::from_utf8(slice)
966-
.expect("non utf8 str from miri");
967-
p!(write("{:?}", s));
968-
return Ok(self);
969-
},
970-
_ => None,
971-
};
972-
if let Some(byte_str) = byte_str {
973-
p!(write("b\""));
974-
for &c in byte_str {
975-
for e in std::ascii::escape_default(c) {
976-
self.write_char(e as char)?;
977-
}
885+
},
886+
(ConstValue::Infer(..), _) => p!(write("_: "), print(ct.ty)),
887+
(ConstValue::Param(ParamConst { name, .. }), _) => p!(write("{}", name)),
888+
(ConstValue::Scalar(Scalar::Raw { data, .. }), ty::Bool) =>
889+
p!(write("{}", if data == 0 { "false" } else { "true" })),
890+
(ConstValue::Scalar(Scalar::Raw { data, .. }), ty::Float(ast::FloatTy::F32)) =>
891+
p!(write("{}f32", Single::from_bits(data))),
892+
(ConstValue::Scalar(Scalar::Raw { data, .. }), ty::Float(ast::FloatTy::F64)) =>
893+
p!(write("{}f64", Double::from_bits(data))),
894+
(ConstValue::Scalar(Scalar::Raw { data, .. }), ty::Uint(ui)) => {
895+
let bit_size = Integer::from_attr(&self.tcx(), UnsignedInt(*ui)).size();
896+
let max = truncate(u128::max_value(), bit_size);
897+
898+
if data == max {
899+
p!(write("std::{}::MAX", ui))
900+
} else {
901+
p!(write("{}{}", data, ui))
902+
};
903+
},
904+
(ConstValue::Scalar(Scalar::Raw { data, .. }), ty::Int(i)) => {
905+
let bit_size = Integer::from_attr(&self.tcx(), SignedInt(*i))
906+
.size().bits() as u128;
907+
let min = 1u128 << (bit_size - 1);
908+
let max = min - 1;
909+
910+
let ty = self.tcx().lift(&ct.ty).unwrap();
911+
let size = self.tcx().layout_of(ty::ParamEnv::empty().and(ty))
912+
.unwrap()
913+
.size;
914+
match data {
915+
d if d == min => p!(write("std::{}::MIN", i)),
916+
d if d == max => p!(write("std::{}::MAX", i)),
917+
_ => p!(write("{}{}", sign_extend(data, size) as i128, i))
978918
}
979-
p!(write("\""));
980-
return Ok(self);
981-
}
982-
}
983-
984-
if let ty::FnPtr(_) = ct.ty.kind {
985-
if let ConstValue::Scalar(Scalar::Ptr(ptr)) = ct.val {
919+
},
920+
(ConstValue::Scalar(Scalar::Raw { data, .. }), ty::Char) =>
921+
p!(write("{:?}", ::std::char::from_u32(data as u32).unwrap())),
922+
(ConstValue::Scalar(Scalar::Ptr(ptr)), ty::FnPtr(_)) => {
986923
let instance = {
987924
let alloc_map = self.tcx().alloc_map.lock();
988925
alloc_map.unwrap_fn(ptr.alloc_id)
989926
};
990927
p!(print_value_path(instance.def_id(), instance.substs));
991-
return Ok(self);
992-
}
993-
}
994-
995-
p!(write("{:?} : ", ct.val), print(ct.ty));
928+
},
929+
_ => {
930+
let printed = if let ty::Ref(_, ref_ty, _) = ct.ty.kind {
931+
let byte_str = match (ct.val, &ref_ty.kind) {
932+
(ConstValue::Scalar(Scalar::Ptr(ptr)), ty::Array(t, n)) if *t == u8 => {
933+
let n = n.eval_usize(self.tcx(), ty::ParamEnv::empty());
934+
Some(self.tcx()
935+
.alloc_map.lock()
936+
.unwrap_memory(ptr.alloc_id)
937+
.get_bytes(&self.tcx(), ptr, Size::from_bytes(n)).unwrap())
938+
},
939+
(ConstValue::Slice { data, start, end }, ty::Slice(t)) if *t == u8 => {
940+
// The `inspect` here is okay since we checked the bounds, and there are
941+
// no relocations (we have an active slice reference here). We don't use
942+
// this result to affect interpreter execution.
943+
Some(data.inspect_with_undef_and_ptr_outside_interpreter(start..end))
944+
},
945+
_ => None,
946+
};
996947

948+
if let Some(byte_str) = byte_str {
949+
p!(write("b\""));
950+
for &c in byte_str {
951+
for e in std::ascii::escape_default(c) {
952+
self.write_char(e as char)?;
953+
}
954+
}
955+
p!(write("\""));
956+
true
957+
} else if let (ConstValue::Slice { data, start, end }, ty::Str) =
958+
(ct.val, &ref_ty.kind)
959+
{
960+
// The `inspect` here is okay since we checked the bounds, and there are no
961+
// relocations (we have an active `str` reference here). We don't use this
962+
// result to affect interpreter execution.
963+
let slice = data.inspect_with_undef_and_ptr_outside_interpreter(start..end);
964+
let s = ::std::str::from_utf8(slice)
965+
.expect("non utf8 str from miri");
966+
p!(write("{:?}", s));
967+
true
968+
} else {
969+
false
970+
}
971+
} else {
972+
false
973+
};
974+
if !printed {
975+
// fallback
976+
p!(write("{:?} : ", ct.val), print(ct.ty))
977+
}
978+
}
979+
};
997980
Ok(self)
998981
}
999982
}

‎src/test/ui/const-generics/raw-ptr-const-param-deref.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -16,4 +16,4 @@ impl<const P: *const u32> Const<{P}> {
1616

1717
fn main() {
1818
assert_eq!(Const::<{&A as *const _}>::get(), 3)
19-
}
19+
}

‎src/test/ui/const-generics/raw-ptr-const-param.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,4 +6,4 @@ struct Const<const P: *const u32>;
66
fn main() {
77
let _: Const<{15 as *const _}> = Const::<{10 as *const _}>; //~ mismatched types
88
let _: Const<{10 as *const _}> = Const::<{10 as *const _}>;
9-
}
9+
}

0 commit comments

Comments
 (0)