bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Remove f32 & f64 from MemDecoder/MemEncoder

Browse source
This commit is contained in:
Scott McMurray 2023-04-05 14:46:09 -07:00
parent 540a50df0f
commit 5cb23e4a43
6 changed files with 14 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

36
compiler/rustc_serialize/src/opaque.rs
View file

@ -122,18 +122,6 @@ impl Encoder for MemEncoder {
self.emit_u8(if v { 1 } else { 0 });
}
#[inline]
fn emit_f64(&mut self, v: f64) {
let as_u64: u64 = v.to_bits();
self.emit_u64(as_u64);
}
#[inline]
fn emit_f32(&mut self, v: f32) {
let as_u32: u32 = v.to_bits();
self.emit_u32(as_u32);
}
#[inline]
fn emit_char(&mut self, v: char) {
self.emit_u32(v as u32);
@ -500,18 +488,6 @@ impl Encoder for FileEncoder {
self.emit_u8(if v { 1 } else { 0 });
}
#[inline]
fn emit_f64(&mut self, v: f64) {
let as_u64: u64 = v.to_bits();
self.emit_u64(as_u64);
}
#[inline]
fn emit_f32(&mut self, v: f32) {
let as_u32: u32 = v.to_bits();
self.emit_u32(as_u32);
}
#[inline]
fn emit_char(&mut self, v: char) {
self.emit_u32(v as u32);
@ -642,18 +618,6 @@ impl<'a> Decoder for MemDecoder<'a> {
value != 0
}
#[inline]
fn read_f64(&mut self) -> f64 {
let bits = self.read_u64();
f64::from_bits(bits)
}
#[inline]
fn read_f32(&mut self) -> f32 {
let bits = self.read_u32();
f32::from_bits(bits)
}
#[inline]
fn read_char(&mut self) -> char {
let bits = self.read_u32();

16
compiler/rustc_serialize/src/serialize.rs
View file

@ -22,6 +22,11 @@ use std::sync::Arc;
/// be processed or ignored, whichever is appropriate. Then they should provide
/// a `finish` method that finishes up encoding. If the encoder is fallible,
/// `finish` should return a `Result` that indicates success or failure.
///
/// This current does not support `f32` nor `f64`, as they're not needed in any
/// serialized data structures. That could be changed, but consider whether it
/// really makes sense to store floating-point values at all.
/// (If you need it, revert <https://github.com/rust-lang/rust/pull/109984>.)
pub trait Encoder {
// Primitive types:
fn emit_usize(&mut self, v: usize);
@ -37,8 +42,6 @@ pub trait Encoder {
fn emit_i16(&mut self, v: i16);
fn emit_i8(&mut self, v: i8);
fn emit_bool(&mut self, v: bool);
fn emit_f64(&mut self, v: f64);
fn emit_f32(&mut self, v: f32);
fn emit_char(&mut self, v: char);
fn emit_str(&mut self, v: &str);
fn emit_raw_bytes(&mut self, s: &[u8]);
@ -58,6 +61,11 @@ pub trait Encoder {
// top-level invocation would also just panic on failure. Switching to
// infallibility made things faster and lots of code a little simpler and more
// concise.
///
/// This current does not support `f32` nor `f64`, as they're not needed in any
/// serialized data structures. That could be changed, but consider whether it
/// really makes sense to store floating-point values at all.
/// (If you need it, revert <https://github.com/rust-lang/rust/pull/109984>.)
pub trait Decoder {
// Primitive types:
fn read_usize(&mut self) -> usize;
@ -73,8 +81,6 @@ pub trait Decoder {
fn read_i16(&mut self) -> i16;
fn read_i8(&mut self) -> i8;
fn read_bool(&mut self) -> bool;
fn read_f64(&mut self) -> f64;
fn read_f32(&mut self) -> f32;
fn read_char(&mut self) -> char;
fn read_str(&mut self) -> &str;
fn read_raw_bytes(&mut self, len: usize) -> &[u8];
@ -143,8 +149,6 @@ direct_serialize_impls! {
i64 emit_i64 read_i64,
i128 emit_i128 read_i128,
f32 emit_f32 read_f32,
f64 emit_f64 read_f64,
bool emit_bool read_bool,
char emit_char read_char
}