nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-16 17:03:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Inline many methods of Encoder

Browse Source 
They aren't overridden anyway
This commit is contained in:
bjorn3 2021-06-04 18:23:50 +02:00
parent 5cd29225a5
commit 22e8d5f80e
6 changed files with 250 additions and 384 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
compiler/rustc_macros/src/serialize.rs
View File

@ -146,10 +146,9 @@ fn encodable_body(
.map(|binding| { .map(|binding| {
let bind_ident = &binding.binding; let bind_ident = &binding.binding;
let result = quote! { let result = quote! {
match ::rustc_serialize::Encoder::emit_struct_field( match ::rustc_serialize::Encodable::<#encoder_ty>::encode(
#bind_ident,
__encoder, __encoder,
|__encoder|
::rustc_serialize::Encodable::<#encoder_ty>::encode(#bind_ident, __encoder),
) { ) {
::std::result::Result::Ok(()) => (), ::std::result::Result::Ok(()) => (),
::std::result::Result::Err(__err) ::std::result::Result::Err(__err)
@ -161,9 +160,7 @@ fn encodable_body(
.collect::<TokenStream>() .collect::<TokenStream>()
}); });
quote! { quote! {
::rustc_serialize::Encoder::emit_struct(__encoder, |__encoder| { ::std::result::Result::Ok(match *self { #encode_inner })
::std::result::Result::Ok(match *self { #encode_inner })
})
} }
} }
_ => { _ => {
@ -175,10 +172,9 @@ fn encodable_body(
.map(|binding| { .map(|binding| {
let bind_ident = &binding.binding; let bind_ident = &binding.binding;
let result = quote! { let result = quote! {
match ::rustc_serialize::Encoder::emit_enum_variant_arg( match ::rustc_serialize::Encodable::<#encoder_ty>::encode(
#bind_ident,
__encoder, __encoder,
|__encoder|
::rustc_serialize::Encodable::<#encoder_ty>::encode(#bind_ident, __encoder),
) { ) {
::std::result::Result::Ok(()) => (), ::std::result::Result::Ok(()) => (),
::std::result::Result::Err(__err) ::std::result::Result::Err(__err)
@ -208,11 +204,9 @@ fn encodable_body(
result result
}); });
quote! { quote! {
::rustc_serialize::Encoder::emit_enum(__encoder, |__encoder| { match *self {
match *self { #encode_inner
#encode_inner }
}
})
} }
} }
}; };

94
compiler/rustc_serialize/src/collection_impls.rs
View File

@ -25,12 +25,11 @@ impl<D: Decoder, A: Array<Item: Decodable<D>>> Decodable<D> for SmallVec<A> {
impl<S: Encoder, T: Encodable<S>> Encodable<S> for LinkedList<T> { impl<S: Encoder, T: Encodable<S>> Encodable<S> for LinkedList<T> {
fn encode(&self, s: &mut S) -> Result<(), S::Error> { fn encode(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_seq(self.len(), |s| { s.emit_usize(self.len())?;
for e in self.iter() { for e in self.iter() {
s.emit_seq_elt(|s| e.encode(s))?; e.encode(s)?;
} }
Ok(()) Ok(())
})
} }
} }
@ -43,12 +42,11 @@ impl<D: Decoder, T: Decodable<D>> Decodable<D> for LinkedList<T> {
impl<S: Encoder, T: Encodable<S>> Encodable<S> for VecDeque<T> { impl<S: Encoder, T: Encodable<S>> Encodable<S> for VecDeque<T> {
fn encode(&self, s: &mut S) -> Result<(), S::Error> { fn encode(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_seq(self.len(), |s| { s.emit_usize(self.len())?;
for e in self.iter() { for e in self.iter() {
s.emit_seq_elt(|s| e.encode(s))?; e.encode(s)?;
} }
Ok(()) Ok(())
})
} }
} }
@ -65,13 +63,12 @@ where
V: Encodable<S>, V: Encodable<S>,
{ {
fn encode(&self, e: &mut S) -> Result<(), S::Error> { fn encode(&self, e: &mut S) -> Result<(), S::Error> {
e.emit_map(self.len(), |e| { e.emit_usize(self.len())?;
for (key, val) in self.iter() { for (key, val) in self.iter() {
e.emit_map_elt_key(|e| key.encode(e))?; key.encode(e)?;
e.emit_map_elt_val(|e| val.encode(e))?; val.encode(e)?;
} }
Ok(()) Ok(())
})
} }
} }
@ -97,12 +94,11 @@ where
T: Encodable<S> + PartialEq + Ord, T: Encodable<S> + PartialEq + Ord,
{ {
fn encode(&self, s: &mut S) -> Result<(), S::Error> { fn encode(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_seq(self.len(), |s| { s.emit_usize(self.len())?;
for e in self.iter() { for e in self.iter() {
s.emit_seq_elt(|s| e.encode(s))?; e.encode(s)?;
} }
Ok(()) Ok(())
})
} }
} }
@ -127,13 +123,12 @@ where
S: BuildHasher, S: BuildHasher,
{ {
fn encode(&self, e: &mut E) -> Result<(), E::Error> { fn encode(&self, e: &mut E) -> Result<(), E::Error> {
e.emit_map(self.len(), |e| { e.emit_usize(self.len())?;
for (key, val) in self.iter() { for (key, val) in self.iter() {
e.emit_map_elt_key(|e| key.encode(e))?; key.encode(e)?;
e.emit_map_elt_val(|e| val.encode(e))?; val.encode(e)?;
} }
Ok(()) Ok(())
})
} }
} }
@ -162,12 +157,11 @@ where
S: BuildHasher, S: BuildHasher,
{ {
fn encode(&self, s: &mut E) -> Result<(), E::Error> { fn encode(&self, s: &mut E) -> Result<(), E::Error> {
s.emit_seq(self.len(), |s| { s.emit_usize(self.len())?;
for e in self.iter() { for e in self.iter() {
s.emit_seq_elt(|s| e.encode(s))?; e.encode(s)?;
} }
Ok(()) Ok(())
})
} }
} }
@ -194,13 +188,12 @@ where
S: BuildHasher, S: BuildHasher,
{ {
fn encode(&self, e: &mut E) -> Result<(), E::Error> { fn encode(&self, e: &mut E) -> Result<(), E::Error> {
e.emit_map(self.len(), |e| { e.emit_usize(self.len())?;
for (key, val) in self.iter() { for (key, val) in self.iter() {
e.emit_map_elt_key(|e| key.encode(e))?; key.encode(e)?;
e.emit_map_elt_val(|e| val.encode(e))?; val.encode(e)?;
} }
Ok(()) Ok(())
})
} }
} }
@ -229,12 +222,11 @@ where
S: BuildHasher, S: BuildHasher,
{ {
fn encode(&self, s: &mut E) -> Result<(), E::Error> { fn encode(&self, s: &mut E) -> Result<(), E::Error> {
s.emit_seq(self.len(), |s| { s.emit_usize(self.len())?;
for e in self.iter() { for e in self.iter() {
s.emit_seq_elt(|s| e.encode(s))?; e.encode(s)?;
} }
Ok(()) Ok(())
})
} }
} }

143
compiler/rustc_serialize/src/serialize.rs
View File

@ -35,15 +35,7 @@ pub trait Encoder {
fn emit_str(&mut self, v: &str) -> Result<(), Self::Error>; fn emit_str(&mut self, v: &str) -> Result<(), Self::Error>;
fn emit_raw_bytes(&mut self, s: &[u8]) -> Result<(), Self::Error>; fn emit_raw_bytes(&mut self, s: &[u8]) -> Result<(), Self::Error>;
// Compound types: // Convenience for the derive macro:
#[inline]
fn emit_enum<F>(&mut self, f: F) -> Result<(), Self::Error>
where
F: FnOnce(&mut Self) -> Result<(), Self::Error>,
{
f(self)
}
fn emit_enum_variant<F>(&mut self, v_id: usize, f: F) -> Result<(), Self::Error> fn emit_enum_variant<F>(&mut self, v_id: usize, f: F) -> Result<(), Self::Error>
where where
F: FnOnce(&mut Self) -> Result<(), Self::Error>, F: FnOnce(&mut Self) -> Result<(), Self::Error>,
@ -62,106 +54,6 @@ pub trait Encoder {
fn emit_fieldless_enum_variant<const ID: usize>(&mut self) -> Result<(), Self::Error> { fn emit_fieldless_enum_variant<const ID: usize>(&mut self) -> Result<(), Self::Error> {
self.emit_usize(ID) self.emit_usize(ID)
} }
#[inline]
fn emit_enum_variant_arg<F>(&mut self, f: F) -> Result<(), Self::Error>
where
F: FnOnce(&mut Self) -> Result<(), Self::Error>,
{
f(self)
}
#[inline]
fn emit_struct<F>(&mut self, f: F) -> Result<(), Self::Error>
where
F: FnOnce(&mut Self) -> Result<(), Self::Error>,
{
f(self)
}
#[inline]
fn emit_struct_field<F>(&mut self, f: F) -> Result<(), Self::Error>
where
F: FnOnce(&mut Self) -> Result<(), Self::Error>,
{
f(self)
}
#[inline]
fn emit_tuple<F>(&mut self, f: F) -> Result<(), Self::Error>
where
F: FnOnce(&mut Self) -> Result<(), Self::Error>,
{
f(self)
}
#[inline]
fn emit_tuple_arg<F>(&mut self, f: F) -> Result<(), Self::Error>
where
F: FnOnce(&mut Self) -> Result<(), Self::Error>,
{
f(self)
}
// Specialized types:
fn emit_option<F>(&mut self, f: F) -> Result<(), Self::Error>
where
F: FnOnce(&mut Self) -> Result<(), Self::Error>,
{
self.emit_enum(f)
}
#[inline]
fn emit_option_none(&mut self) -> Result<(), Self::Error> {
self.emit_enum_variant(0, |_| Ok(()))
}
fn emit_option_some<F>(&mut self, f: F) -> Result<(), Self::Error>
where
F: FnOnce(&mut Self) -> Result<(), Self::Error>,
{
self.emit_enum_variant(1, f)
}
fn emit_seq<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
where
F: FnOnce(&mut Self) -> Result<(), Self::Error>,
{
self.emit_usize(len)?;
f(self)
}
#[inline]
fn emit_seq_elt<F>(&mut self, f: F) -> Result<(), Self::Error>
where
F: FnOnce(&mut Self) -> Result<(), Self::Error>,
{
f(self)
}
fn emit_map<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
where
F: FnOnce(&mut Self) -> Result<(), Self::Error>,
{
self.emit_usize(len)?;
f(self)
}
#[inline]
fn emit_map_elt_key<F>(&mut self, f: F) -> Result<(), Self::Error>
where
F: FnOnce(&mut Self) -> Result<(), Self::Error>,
{
f(self)
}
#[inline]
fn emit_map_elt_val<F>(&mut self, f: F) -> Result<(), Self::Error>
where
F: FnOnce(&mut Self) -> Result<(), Self::Error>,
{
f(self)
}
} }
// Note: all the methods in this trait are infallible, which may be surprising. // Note: all the methods in this trait are infallible, which may be surprising.
@ -353,12 +245,11 @@ impl<D: Decoder, T: Decodable<D>> Decodable<D> for Rc<T> {
impl<S: Encoder, T: Encodable<S>> Encodable<S> for [T] { impl<S: Encoder, T: Encodable<S>> Encodable<S> for [T] {
default fn encode(&self, s: &mut S) -> Result<(), S::Error> { default fn encode(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_seq(self.len(), |s| { s.emit_usize(self.len())?;
for e in self.iter() { for e in self.iter() {
s.emit_seq_elt(|s| e.encode(s))? e.encode(s)?
} }
Ok(()) Ok(())
})
} }
} }
@ -441,10 +332,10 @@ impl<'a, D: Decoder> Decodable<D> for Cow<'a, str> {
impl<S: Encoder, T: Encodable<S>> Encodable<S> for Option<T> { impl<S: Encoder, T: Encodable<S>> Encodable<S> for Option<T> {
fn encode(&self, s: &mut S) -> Result<(), S::Error> { fn encode(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_option(|s| match *self { match *self {
None => s.emit_option_none(), None => s.emit_enum_variant(0, |_| Ok(())),
Some(ref v) => s.emit_option_some(|s| v.encode(s)), Some(ref v) => s.emit_enum_variant(1, |s| v.encode(s)),
}) }
} }
} }
@ -460,10 +351,10 @@ impl<D: Decoder, T: Decodable<D>> Decodable<D> for Option<T> {
impl<S: Encoder, T1: Encodable<S>, T2: Encodable<S>> Encodable<S> for Result<T1, T2> { impl<S: Encoder, T1: Encodable<S>, T2: Encodable<S>> Encodable<S> for Result<T1, T2> {
fn encode(&self, s: &mut S) -> Result<(), S::Error> { fn encode(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_enum(|s| match *self { match *self {
Ok(ref v) => s.emit_enum_variant(0, |s| s.emit_enum_variant_arg(|s| v.encode(s))), Ok(ref v) => s.emit_enum_variant(0, |s| v.encode(s)),
Err(ref v) => s.emit_enum_variant(1, |s| s.emit_enum_variant_arg(|s| v.encode(s))), Err(ref v) => s.emit_enum_variant(1, |s| v.encode(s)),
}) }
} }
} }
@ -493,10 +384,8 @@ macro_rules! tuple {
#[allow(non_snake_case)] #[allow(non_snake_case)]
fn encode(&self, s: &mut S) -> Result<(), S::Error> { fn encode(&self, s: &mut S) -> Result<(), S::Error> {
let ($(ref $name,)+) = *self; let ($(ref $name,)+) = *self;
s.emit_tuple(|s| { $($name.encode(s)?;)+
$(s.emit_tuple_arg(|s| $name.encode(s))?;)+ Ok(())
Ok(())
})
} }
} }
peel! { $($name,)+ } peel! { $($name,)+ }

7
compiler/rustc_span/src/def_id.rs
View File

@ -307,11 +307,8 @@ impl DefId {
impl<E: Encoder> Encodable<E> for DefId { impl<E: Encoder> Encodable<E> for DefId {
default fn encode(&self, s: &mut E) -> Result<(), E::Error> { default fn encode(&self, s: &mut E) -> Result<(), E::Error> {
s.emit_struct(|s| { self.krate.encode(s)?;
s.emit_struct_field(|s| self.krate.encode(s))?; self.index.encode(s)
s.emit_struct_field(|s| self.index.encode(s))
})
} }
} }

146
compiler/rustc_span/src/lib.rs
View File

@ -196,10 +196,10 @@ impl Hash for RealFileName {
// an added assert statement // an added assert statement
impl<S: Encoder> Encodable<S> for RealFileName { impl<S: Encoder> Encodable<S> for RealFileName {
fn encode(&self, encoder: &mut S) -> Result<(), S::Error> { fn encode(&self, encoder: &mut S) -> Result<(), S::Error> {
encoder.emit_enum(|encoder| match *self { match *self {
RealFileName::LocalPath(ref local_path) => encoder.emit_enum_variant(0, |encoder| { RealFileName::LocalPath(ref local_path) => encoder.emit_enum_variant(0, |encoder| {
Ok({ Ok({
encoder.emit_enum_variant_arg(|encoder| local_path.encode(encoder))?; local_path.encode(encoder)?;
}) })
}), }),
@ -208,11 +208,11 @@ impl<S: Encoder> Encodable<S> for RealFileName {
// For privacy and build reproducibility, we must not embed host-dependant path in artifacts // For privacy and build reproducibility, we must not embed host-dependant path in artifacts
// if they have been remapped by --remap-path-prefix // if they have been remapped by --remap-path-prefix
assert!(local_path.is_none()); assert!(local_path.is_none());
encoder.emit_enum_variant_arg(|encoder| local_path.encode(encoder))?; local_path.encode(encoder)?;
encoder.emit_enum_variant_arg(|encoder| virtual_name.encode(encoder))?; virtual_name.encode(encoder)?;
Ok(()) Ok(())
}), }),
}) }
} }
} }
@ -949,10 +949,8 @@ impl Default for Span {
impl<E: Encoder> Encodable<E> for Span { impl<E: Encoder> Encodable<E> for Span {
default fn encode(&self, s: &mut E) -> Result<(), E::Error> { default fn encode(&self, s: &mut E) -> Result<(), E::Error> {
let span = self.data(); let span = self.data();
s.emit_struct(|s| { span.lo.encode(s)?;
s.emit_struct_field(|s| span.lo.encode(s))?; span.hi.encode(s)
s.emit_struct_field(|s| span.hi.encode(s))
})
} }
} }
impl<D: Decoder> Decodable<D> for Span { impl<D: Decoder> Decodable<D> for Span {
@ -1301,79 +1299,77 @@ pub struct SourceFile {
impl<S: Encoder> Encodable<S> for SourceFile { impl<S: Encoder> Encodable<S> for SourceFile {
fn encode(&self, s: &mut S) -> Result<(), S::Error> { fn encode(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_struct(|s| { self.name.encode(s)?;
s.emit_struct_field(|s| self.name.encode(s))?; self.src_hash.encode(s)?;
s.emit_struct_field(|s| self.src_hash.encode(s))?; self.start_pos.encode(s)?;
s.emit_struct_field(|s| self.start_pos.encode(s))?; self.end_pos.encode(s)?;
s.emit_struct_field(|s| self.end_pos.encode(s))?;
s.emit_struct_field(|s| {
// We are always in `Lines` form by the time we reach here.
assert!(self.lines.borrow().is_lines());
self.lines(|lines| {
// Store the length.
s.emit_u32(lines.len() as u32)?;
// Compute and store the difference list. // We are always in `Lines` form by the time we reach here.
if lines.len() != 0 { assert!(self.lines.borrow().is_lines());
let max_line_length = if lines.len() == 1 { self.lines(|lines| {
0 // Store the length.
} else { s.emit_u32(lines.len() as u32)?;
lines
.array_windows()
.map(|&[fst, snd]| snd - fst)
.map(|bp| bp.to_usize())
.max()
.unwrap()
};
let bytes_per_diff: usize = match max_line_length { // Compute and store the difference list.
0..=0xFF => 1, if lines.len() != 0 {
0x100..=0xFFFF => 2, let max_line_length = if lines.len() == 1 {
_ => 4, 0
}; } else {
lines
.array_windows()
.map(|&[fst, snd]| snd - fst)
.map(|bp| bp.to_usize())
.max()
.unwrap()
};
// Encode the number of bytes used per diff. let bytes_per_diff: usize = match max_line_length {
s.emit_u8(bytes_per_diff as u8)?; 0..=0xFF => 1,
0x100..=0xFFFF => 2,
_ => 4,
};
// Encode the first element. // Encode the number of bytes used per diff.
lines[0].encode(s)?; s.emit_u8(bytes_per_diff as u8)?;
// Encode the difference list. // Encode the first element.
let diff_iter = lines.array_windows().map(|&[fst, snd]| snd - fst); lines[0].encode(s)?;
let num_diffs = lines.len() - 1;
let mut raw_diffs; // Encode the difference list.
match bytes_per_diff { let diff_iter = lines.array_windows().map(|&[fst, snd]| snd - fst);
1 => { let num_diffs = lines.len() - 1;
raw_diffs = Vec::with_capacity(num_diffs); let mut raw_diffs;
for diff in diff_iter { match bytes_per_diff {
raw_diffs.push(diff.0 as u8); 1 => {
} raw_diffs = Vec::with_capacity(num_diffs);
} for diff in diff_iter {
2 => { raw_diffs.push(diff.0 as u8);
raw_diffs = Vec::with_capacity(bytes_per_diff * num_diffs);
for diff in diff_iter {
raw_diffs.extend_from_slice(&(diff.0 as u16).to_le_bytes());
}
}
4 => {
raw_diffs = Vec::with_capacity(bytes_per_diff * num_diffs);
for diff in diff_iter {
raw_diffs.extend_from_slice(&(diff.0 as u32).to_le_bytes());
}
}
_ => unreachable!(),
} }
s.emit_raw_bytes(&raw_diffs)?;
} }
Ok(()) 2 => {
}) raw_diffs = Vec::with_capacity(bytes_per_diff * num_diffs);
})?; for diff in diff_iter {
s.emit_struct_field(|s| self.multibyte_chars.encode(s))?; raw_diffs.extend_from_slice(&(diff.0 as u16).to_le_bytes());
s.emit_struct_field(|s| self.non_narrow_chars.encode(s))?; }
s.emit_struct_field(|s| self.name_hash.encode(s))?; }
s.emit_struct_field(|s| self.normalized_pos.encode(s))?; 4 => {
s.emit_struct_field(|s| self.cnum.encode(s)) raw_diffs = Vec::with_capacity(bytes_per_diff * num_diffs);
}) for diff in diff_iter {
raw_diffs.extend_from_slice(&(diff.0 as u32).to_le_bytes());
}
}
_ => unreachable!(),
}
s.emit_raw_bytes(&raw_diffs)?;
}
Ok(())
})?;
self.multibyte_chars.encode(s)?;
self.non_narrow_chars.encode(s)?;
self.name_hash.encode(s)?;
self.normalized_pos.encode(s)?;
self.cnum.encode(s)
} }
} }

222
compiler/rustc_type_ir/src/sty.rs
View File

@ -716,118 +716,116 @@ where
I::AllocId: Encodable<E>, I::AllocId: Encodable<E>,
{ {
fn encode(&self, e: &mut E) -> Result<(), <E as rustc_serialize::Encoder>::Error> { fn encode(&self, e: &mut E) -> Result<(), <E as rustc_serialize::Encoder>::Error> {
rustc_serialize::Encoder::emit_enum(e, |e| { let disc = discriminant(self);
let disc = discriminant(self); match self {
match self { Bool => e.emit_enum_variant(disc, |_| Ok(())),
Bool => e.emit_enum_variant(disc, |_| Ok(())), Char => e.emit_enum_variant(disc, |_| Ok(())),
Char => e.emit_enum_variant(disc, |_| Ok(())), Int(i) => e.emit_enum_variant(disc, |e| {
Int(i) => e.emit_enum_variant(disc, |e| { i.encode(e)?;
e.emit_enum_variant_arg(|e| i.encode(e))?; Ok(())
Ok(()) }),
}), Uint(u) => e.emit_enum_variant(disc, |e| {
Uint(u) => e.emit_enum_variant(disc, |e| { u.encode(e)?;
e.emit_enum_variant_arg(|e| u.encode(e))?; Ok(())
Ok(()) }),
}), Float(f) => e.emit_enum_variant(disc, |e| {
Float(f) => e.emit_enum_variant(disc, |e| { f.encode(e)?;
e.emit_enum_variant_arg(|e| f.encode(e))?; Ok(())
Ok(()) }),
}), Adt(adt, substs) => e.emit_enum_variant(disc, |e| {
Adt(adt, substs) => e.emit_enum_variant(disc, |e| { adt.encode(e)?;
e.emit_enum_variant_arg(|e| adt.encode(e))?; substs.encode(e)?;
e.emit_enum_variant_arg(|e| substs.encode(e))?; Ok(())
Ok(()) }),
}), Foreign(def_id) => e.emit_enum_variant(disc, |e| {
Foreign(def_id) => e.emit_enum_variant(disc, |e| { def_id.encode(e)?;
e.emit_enum_variant_arg(|e| def_id.encode(e))?; Ok(())
Ok(()) }),
}), Str => e.emit_enum_variant(disc, |_| Ok(())),
Str => e.emit_enum_variant(disc, |_| Ok(())), Array(t, c) => e.emit_enum_variant(disc, |e| {
Array(t, c) => e.emit_enum_variant(disc, |e| { t.encode(e)?;
e.emit_enum_variant_arg(|e| t.encode(e))?; c.encode(e)?;
e.emit_enum_variant_arg(|e| c.encode(e))?; Ok(())
Ok(()) }),
}), Slice(t) => e.emit_enum_variant(disc, |e| {
Slice(t) => e.emit_enum_variant(disc, |e| { t.encode(e)?;
e.emit_enum_variant_arg(|e| t.encode(e))?; Ok(())
Ok(()) }),
}), RawPtr(tam) => e.emit_enum_variant(disc, |e| {
RawPtr(tam) => e.emit_enum_variant(disc, |e| { tam.encode(e)?;
e.emit_enum_variant_arg(|e| tam.encode(e))?; Ok(())
Ok(()) }),
}), Ref(r, t, m) => e.emit_enum_variant(disc, |e| {
Ref(r, t, m) => e.emit_enum_variant(disc, |e| { r.encode(e)?;
e.emit_enum_variant_arg(|e| r.encode(e))?; t.encode(e)?;
e.emit_enum_variant_arg(|e| t.encode(e))?; m.encode(e)?;
e.emit_enum_variant_arg(|e| m.encode(e))?; Ok(())
Ok(()) }),
}), FnDef(def_id, substs) => e.emit_enum_variant(disc, |e| {
FnDef(def_id, substs) => e.emit_enum_variant(disc, |e| { def_id.encode(e)?;
e.emit_enum_variant_arg(|e| def_id.encode(e))?; substs.encode(e)?;
e.emit_enum_variant_arg(|e| substs.encode(e))?; Ok(())
Ok(()) }),
}), FnPtr(polyfnsig) => e.emit_enum_variant(disc, |e| {
FnPtr(polyfnsig) => e.emit_enum_variant(disc, |e| { polyfnsig.encode(e)?;
e.emit_enum_variant_arg(|e| polyfnsig.encode(e))?; Ok(())
Ok(()) }),
}), Dynamic(l, r) => e.emit_enum_variant(disc, |e| {
Dynamic(l, r) => e.emit_enum_variant(disc, |e| { l.encode(e)?;
e.emit_enum_variant_arg(|e| l.encode(e))?; r.encode(e)?;
e.emit_enum_variant_arg(|e| r.encode(e))?; Ok(())
Ok(()) }),
}), Closure(def_id, substs) => e.emit_enum_variant(disc, |e| {
Closure(def_id, substs) => e.emit_enum_variant(disc, |e| { def_id.encode(e)?;
e.emit_enum_variant_arg(|e| def_id.encode(e))?; substs.encode(e)?;
e.emit_enum_variant_arg(|e| substs.encode(e))?; Ok(())
Ok(()) }),
}), Generator(def_id, substs, m) => e.emit_enum_variant(disc, |e| {
Generator(def_id, substs, m) => e.emit_enum_variant(disc, |e| { def_id.encode(e)?;
e.emit_enum_variant_arg(|e| def_id.encode(e))?; substs.encode(e)?;
e.emit_enum_variant_arg(|e| substs.encode(e))?; m.encode(e)?;
e.emit_enum_variant_arg(|e| m.encode(e))?; Ok(())
Ok(()) }),
}), GeneratorWitness(b) => e.emit_enum_variant(disc, |e| {
GeneratorWitness(b) => e.emit_enum_variant(disc, |e| { b.encode(e)?;
e.emit_enum_variant_arg(|e| b.encode(e))?; Ok(())
Ok(()) }),
}), Never => e.emit_enum_variant(disc, |_| Ok(())),
Never => e.emit_enum_variant(disc, |_| Ok(())), Tuple(substs) => e.emit_enum_variant(disc, |e| {
Tuple(substs) => e.emit_enum_variant(disc, |e| { substs.encode(e)?;
e.emit_enum_variant_arg(|e| substs.encode(e))?; Ok(())
Ok(()) }),
}), Projection(p) => e.emit_enum_variant(disc, |e| {
Projection(p) => e.emit_enum_variant(disc, |e| { p.encode(e)?;
e.emit_enum_variant_arg(|e| p.encode(e))?; Ok(())
Ok(()) }),
}), Opaque(def_id, substs) => e.emit_enum_variant(disc, |e| {
Opaque(def_id, substs) => e.emit_enum_variant(disc, |e| { def_id.encode(e)?;
e.emit_enum_variant_arg(|e| def_id.encode(e))?; substs.encode(e)?;
e.emit_enum_variant_arg(|e| substs.encode(e))?; Ok(())
Ok(()) }),
}), Param(p) => e.emit_enum_variant(disc, |e| {
Param(p) => e.emit_enum_variant(disc, |e| { p.encode(e)?;
e.emit_enum_variant_arg(|e| p.encode(e))?; Ok(())
Ok(()) }),
}), Bound(d, b) => e.emit_enum_variant(disc, |e| {
Bound(d, b) => e.emit_enum_variant(disc, |e| { d.encode(e)?;
e.emit_enum_variant_arg(|e| d.encode(e))?; b.encode(e)?;
e.emit_enum_variant_arg(|e| b.encode(e))?; Ok(())
Ok(()) }),
}), Placeholder(p) => e.emit_enum_variant(disc, |e| {
Placeholder(p) => e.emit_enum_variant(disc, |e| { p.encode(e)?;
e.emit_enum_variant_arg(|e| p.encode(e))?; Ok(())
Ok(()) }),
}), Infer(i) => e.emit_enum_variant(disc, |e| {
Infer(i) => e.emit_enum_variant(disc, |e| { i.encode(e)?;
e.emit_enum_variant_arg(|e| i.encode(e))?; Ok(())
Ok(()) }),
}), Error(d) => e.emit_enum_variant(disc, |e| {
Error(d) => e.emit_enum_variant(disc, |e| { d.encode(e)?;
e.emit_enum_variant_arg(|e| d.encode(e))?; Ok(())
Ok(()) }),
}), }
}
})
} }
} }