use rustc_data_structures::sync::Lrc;
use rustc_data_structures::thin_vec::ThinVec;
use rustc_macros::HashStable_Generic;
-use rustc_serialize::{self, Decoder, Encoder};
+use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
use rustc_span::source_map::{respan, Spanned};
use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{Span, DUMMY_SP};
}
}
-impl<S: Encoder> rustc_serialize::Encodable<S> for AttrId {
+impl<S: Encoder> Encodable<S> for AttrId {
fn encode(&self, _s: &mut S) {}
}
-impl<D: Decoder> rustc_serialize::Decodable<D> for AttrId {
+impl<D: Decoder> Decodable<D> for AttrId {
fn decode(_: &mut D) -> AttrId {
crate::attr::mk_attr_id()
}
use rustc_middle::middle::dependency_format::Dependencies;
use rustc_middle::middle::exported_symbols::SymbolExportKind;
use rustc_middle::ty::query::{ExternProviders, Providers};
-use rustc_serialize::{opaque, Decodable, Decoder, Encodable, Encoder};
+use rustc_serialize::opaque::{MemDecoder, MemEncoder};
+use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
use rustc_session::config::{CrateType, OutputFilenames, OutputType, RUST_CGU_EXT};
use rustc_session::cstore::{self, CrateSource};
use rustc_session::utils::NativeLibKind;
impl CodegenResults {
pub fn serialize_rlink(codegen_results: &CodegenResults) -> Vec<u8> {
- let mut encoder = opaque::Encoder::new();
+ let mut encoder = MemEncoder::new();
encoder.emit_raw_bytes(RLINK_MAGIC);
// `emit_raw_bytes` is used to make sure that the version representation does not depend on
// Encoder's inner representation of `u32`.
return Err(".rlink file was produced with encoding version {version_array}, but the current version is {RLINK_VERSION}".to_string());
}
- let mut decoder = opaque::Decoder::new(&data[4..], 0);
+ let mut decoder = MemDecoder::new(&data[4..], 0);
let rustc_version = decoder.read_str();
let current_version = RUSTC_VERSION.unwrap();
if rustc_version != current_version {
use crate::stable_hasher;
-use rustc_serialize::{Decodable, Encodable};
+use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
use std::convert::TryInto;
use std::hash::{Hash, Hasher};
impl_stable_hash_via_hash!(Fingerprint);
-impl<E: rustc_serialize::Encoder> Encodable<E> for Fingerprint {
+impl<E: Encoder> Encodable<E> for Fingerprint {
#[inline]
fn encode(&self, s: &mut E) {
s.emit_raw_bytes(&self.to_le_bytes());
}
}
-impl<D: rustc_serialize::Decoder> Decodable<D> for Fingerprint {
+impl<D: Decoder> Decodable<D> for Fingerprint {
#[inline]
fn decode(d: &mut D) -> Self {
Fingerprint::from_le_bytes(d.read_raw_bytes(16).try_into().unwrap())
}
}
-impl<E: rustc_serialize::Encoder> Encodable<E> for PackedFingerprint {
+impl<E: Encoder> Encodable<E> for PackedFingerprint {
#[inline]
fn encode(&self, s: &mut E) {
// Copy to avoid taking reference to packed field.
}
}
-impl<D: rustc_serialize::Decoder> Decodable<D> for PackedFingerprint {
+impl<D: Decoder> Decodable<D> for PackedFingerprint {
#[inline]
fn decode(d: &mut D) -> Self {
Self(Fingerprint::decode(d))
use rustc_data_structures::memmap::Mmap;
use rustc_middle::dep_graph::{SerializedDepGraph, WorkProduct, WorkProductId};
use rustc_middle::ty::OnDiskCache;
-use rustc_serialize::opaque::Decoder;
+use rustc_serialize::opaque::MemDecoder;
use rustc_serialize::Decodable;
use rustc_session::config::IncrementalStateAssertion;
use rustc_session::Session;
if let LoadResult::Ok { data: (work_products_data, start_pos) } = load_result {
// Decode the list of work_products
- let mut work_product_decoder = Decoder::new(&work_products_data[..], start_pos);
+ let mut work_product_decoder = MemDecoder::new(&work_products_data[..], start_pos);
let work_products: Vec<SerializedWorkProduct> =
Decodable::decode(&mut work_product_decoder);
LoadResult::DataOutOfDate => LoadResult::DataOutOfDate,
LoadResult::Error { message } => LoadResult::Error { message },
LoadResult::Ok { data: (bytes, start_pos) } => {
- let mut decoder = Decoder::new(&bytes, start_pos);
+ let mut decoder = MemDecoder::new(&bytes, start_pos);
let prev_commandline_args_hash = u64::decode(&mut decoder);
if prev_commandline_args_hash != expected_hash {
use rustc_middle::ty::fast_reject::SimplifiedType;
use rustc_middle::ty::GeneratorDiagnosticData;
use rustc_middle::ty::{self, ParameterizedOverTcx, Ty, TyCtxt, Visibility};
-use rustc_serialize::{opaque, Decodable, Decoder};
+use rustc_serialize::opaque::MemDecoder;
+use rustc_serialize::{Decodable, Decoder};
use rustc_session::cstore::{
CrateSource, ExternCrate, ForeignModule, LinkagePreference, NativeLib,
};
}
pub(super) struct DecodeContext<'a, 'tcx> {
- opaque: opaque::Decoder<'a>,
+ opaque: MemDecoder<'a>,
cdata: Option<CrateMetadataRef<'a>>,
blob: &'a MetadataBlob,
sess: Option<&'tcx Session>,
fn decoder(self, pos: usize) -> DecodeContext<'a, 'tcx> {
let tcx = self.tcx();
DecodeContext {
- opaque: opaque::Decoder::new(self.blob(), pos),
+ opaque: MemDecoder::new(self.blob(), pos),
cdata: self.cdata(),
blob: self.blob(),
sess: self.sess().or(tcx.map(|tcx| tcx.sess)),
where
F: FnOnce(&mut Self) -> R,
{
- let new_opaque = opaque::Decoder::new(self.opaque.data, pos);
+ let new_opaque = MemDecoder::new(self.opaque.data, pos);
let old_opaque = mem::replace(&mut self.opaque, new_opaque);
let old_state = mem::replace(&mut self.lazy_state, LazyState::NoNode);
let r = f(self);
use rustc_middle::ty::fast_reject::{self, SimplifiedType, TreatParams};
use rustc_middle::ty::query::Providers;
use rustc_middle::ty::{self, SymbolName, Ty, TyCtxt};
-use rustc_serialize::{opaque, Encodable, Encoder};
+use rustc_serialize::opaque::MemEncoder;
+use rustc_serialize::{Encodable, Encoder};
use rustc_session::config::CrateType;
use rustc_session::cstore::{ForeignModule, LinkagePreference, NativeLib};
use rustc_span::hygiene::{ExpnIndex, HygieneEncodeContext, MacroKind};
use tracing::{debug, trace};
pub(super) struct EncodeContext<'a, 'tcx> {
- opaque: opaque::Encoder,
+ opaque: MemEncoder,
tcx: TyCtxt<'tcx>,
feat: &'tcx rustc_feature::Features,
}
impl<'a, 'tcx> Encoder for EncodeContext<'a, 'tcx> {
- type Ok = <opaque::Encoder as Encoder>::Ok;
- type Err = <opaque::Encoder as Encoder>::Err;
+ type Ok = <MemEncoder as Encoder>::Ok;
+ type Err = <MemEncoder as Encoder>::Err;
encoder_methods! {
emit_usize(usize);
}
fn encode_metadata_impl(tcx: TyCtxt<'_>) -> EncodedMetadata {
- let mut encoder = opaque::Encoder::new();
+ let mut encoder = MemEncoder::new();
encoder.emit_raw_bytes(METADATA_HEADER);
// Will be filled with the root position after encoding everything.
use rustc_middle::ty::query::Providers;
use rustc_middle::ty::{self, ReprOptions, Ty};
use rustc_middle::ty::{GeneratorDiagnosticData, ParameterizedOverTcx, TyCtxt};
-use rustc_serialize::opaque::Encoder;
+use rustc_serialize::opaque::MemEncoder;
use rustc_session::config::SymbolManglingVersion;
use rustc_session::cstore::{CrateDepKind, ForeignModule, LinkagePreference, NativeLib};
use rustc_span::edition::Edition;
}
impl TableBuilders {
- fn encode(&self, buf: &mut Encoder) -> LazyTables {
+ fn encode(&self, buf: &mut MemEncoder) -> LazyTables {
LazyTables {
$($name: self.$name.encode(buf)),+
}
use rustc_hir::def::{CtorKind, CtorOf};
use rustc_index::vec::Idx;
use rustc_middle::ty::ParameterizedOverTcx;
-use rustc_serialize::opaque::Encoder;
-use rustc_serialize::Encoder as _;
+use rustc_serialize::opaque::MemEncoder;
+use rustc_serialize::Encoder;
use rustc_span::hygiene::MacroKind;
use std::convert::TryInto;
use std::marker::PhantomData;
Some(value).write_to_bytes(&mut self.blocks[i]);
}
- pub(crate) fn encode<const N: usize>(&self, buf: &mut Encoder) -> LazyTable<I, T>
+ pub(crate) fn encode<const N: usize>(&self, buf: &mut MemEncoder) -> LazyTable<I, T>
where
Option<T>: FixedSizeEncoding<ByteArray = [u8; N]>,
{
};
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_data_structures::sync::OnceCell;
-use rustc_serialize as serialize;
+use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
/// Helper type to cache the result of `graph::is_cyclic`.
#[derive(Clone, Debug)]
}
}
-impl<S: serialize::Encoder> serialize::Encodable<S> for GraphIsCyclicCache {
+impl<S: Encoder> Encodable<S> for GraphIsCyclicCache {
#[inline]
fn encode(&self, s: &mut S) {
- serialize::Encodable::encode(&(), s);
+ Encodable::encode(&(), s);
}
}
-impl<D: serialize::Decoder> serialize::Decodable<D> for GraphIsCyclicCache {
+impl<D: Decoder> Decodable<D> for GraphIsCyclicCache {
#[inline]
fn decode(d: &mut D) -> Self {
- let () = serialize::Decodable::decode(d);
+ let () = Decodable::decode(d);
Self::new()
}
}
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_data_structures::sync::OnceCell;
use rustc_index::vec::IndexVec;
-use rustc_serialize as serialize;
+use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
use smallvec::SmallVec;
use crate::mir::{BasicBlock, BasicBlockData};
}
}
-impl<S: serialize::Encoder> serialize::Encodable<S> for PredecessorCache {
+impl<S: Encoder> Encodable<S> for PredecessorCache {
#[inline]
fn encode(&self, _s: &mut S) {}
}
-impl<D: serialize::Decoder> serialize::Decodable<D> for PredecessorCache {
+impl<D: Decoder> Decodable<D> for PredecessorCache {
#[inline]
fn decode(_: &mut D) -> Self {
Self::new()
use rustc_data_structures::stable_map::FxHashMap;
use rustc_data_structures::sync::OnceCell;
use rustc_index::vec::IndexVec;
-use rustc_serialize as serialize;
+use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
use smallvec::SmallVec;
use crate::mir::{BasicBlock, BasicBlockData, Terminator, TerminatorKind};
}
}
-impl<S: serialize::Encoder> serialize::Encodable<S> for SwitchSourceCache {
+impl<S: Encoder> Encodable<S> for SwitchSourceCache {
#[inline]
fn encode(&self, _s: &mut S) {}
}
-impl<D: serialize::Decoder> serialize::Decodable<D> for SwitchSourceCache {
+impl<D: Decoder> Decodable<D> for SwitchSourceCache {
#[inline]
fn decode(_: &mut D) -> Self {
Self::new()
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_data_structures::sync::OnceCell;
use rustc_index::bit_set::BitSet;
-use rustc_serialize as serialize;
+use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
use super::*;
}
}
-impl<S: serialize::Encoder> serialize::Encodable<S> for PostorderCache {
+impl<S: Encoder> Encodable<S> for PostorderCache {
#[inline]
fn encode(&self, _s: &mut S) {}
}
-impl<D: serialize::Decoder> serialize::Decodable<D> for PostorderCache {
+impl<D: Decoder> Decodable<D> for PostorderCache {
#[inline]
fn decode(_: &mut D) -> Self {
Self::new()
use rustc_query_system::dep_graph::DepContext;
use rustc_query_system::query::{QueryCache, QueryContext, QuerySideEffects};
use rustc_serialize::{
- opaque::{self, FileEncodeResult, FileEncoder, IntEncodedWithFixedSize},
+ opaque::{FileEncodeResult, FileEncoder, IntEncodedWithFixedSize, MemDecoder},
Decodable, Decoder, Encodable, Encoder,
};
use rustc_session::Session;
// Wrap in a scope so we can borrow `data`.
let footer: Footer = {
- let mut decoder = opaque::Decoder::new(&data, start_pos);
+ let mut decoder = MemDecoder::new(&data, start_pos);
// Decode the *position* of the footer, which can be found in the
// last 8 bytes of the file.
let serialized_data = self.serialized_data.read();
let mut decoder = CacheDecoder {
tcx,
- opaque: opaque::Decoder::new(serialized_data.as_deref().unwrap_or(&[]), pos.to_usize()),
+ opaque: MemDecoder::new(serialized_data.as_deref().unwrap_or(&[]), pos.to_usize()),
source_map: self.source_map,
file_index_to_file: &self.file_index_to_file,
file_index_to_stable_id: &self.file_index_to_stable_id,
/// will also handle things that contain `Ty` instances.
pub struct CacheDecoder<'a, 'tcx> {
tcx: TyCtxt<'tcx>,
- opaque: opaque::Decoder<'a>,
+ opaque: MemDecoder<'a>,
source_map: &'a SourceMap,
file_index_to_file: &'a Lock<FxHashMap<SourceFileIndex, Lrc<SourceFile>>>,
file_index_to_stable_id: &'a FxHashMap<SourceFileIndex, EncodedSourceFileId>,
fn position(&self) -> usize;
}
-impl<'a> DecoderWithPosition for opaque::Decoder<'a> {
+impl<'a> DecoderWithPosition for MemDecoder<'a> {
fn position(&self) -> usize {
self.position()
}
{
debug_assert!(pos < self.opaque.data.len());
- let new_opaque = opaque::Decoder::new(self.opaque.data, pos);
+ let new_opaque = MemDecoder::new(self.opaque.data, pos);
let old_opaque = mem::replace(&mut self.opaque, new_opaque);
let r = f(self);
self.opaque = old_opaque;
use rustc_data_structures::profiling::SelfProfilerRef;
use rustc_data_structures::sync::Lock;
use rustc_index::vec::{Idx, IndexVec};
-use rustc_serialize::opaque::{self, FileEncodeResult, FileEncoder, IntEncodedWithFixedSize};
+use rustc_serialize::opaque::{FileEncodeResult, FileEncoder, IntEncodedWithFixedSize, MemDecoder};
use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
use smallvec::SmallVec;
use std::convert::TryInto;
}
}
-impl<'a, K: DepKind + Decodable<opaque::Decoder<'a>>> Decodable<opaque::Decoder<'a>>
+impl<'a, K: DepKind + Decodable<MemDecoder<'a>>> Decodable<MemDecoder<'a>>
for SerializedDepGraph<K>
{
#[instrument(level = "debug", skip(d))]
- fn decode(d: &mut opaque::Decoder<'a>) -> SerializedDepGraph<K> {
+ fn decode(d: &mut MemDecoder<'a>) -> SerializedDepGraph<K> {
let start_position = d.position();
// The last 16 bytes are the node count and edge count.
use crate::leb128::{self, max_leb128_len};
-use crate::serialize::{self, Decoder as _, Encoder as _};
+use crate::serialize::{Decodable, Decoder, Encodable, Encoder};
use std::convert::TryInto;
use std::fs::File;
use std::io::{self, Write};
// Encoder
// -----------------------------------------------------------------------------
-pub struct Encoder {
+pub struct MemEncoder {
pub data: Vec<u8>,
}
-impl Encoder {
- pub fn new() -> Encoder {
- Encoder { data: vec![] }
+impl MemEncoder {
+ pub fn new() -> MemEncoder {
+ MemEncoder { data: vec![] }
}
#[inline]
/// [utf8]: https://en.wikipedia.org/w/index.php?title=UTF-8&oldid=1058865525#Codepage_layout
const STR_SENTINEL: u8 = 0xC1;
-impl serialize::Encoder for Encoder {
+impl Encoder for MemEncoder {
type Ok = Vec<u8>;
type Err = !;
// `FileEncoder` encodes data to file via fixed-size buffer.
//
// When encoding large amounts of data to a file, using `FileEncoder` may be
-// preferred over using `Encoder` to encode to a `Vec`, and then writing the
+// preferred over using `MemEncoder` to encode to a `Vec`, and then writing the
// `Vec` to file, as the latter uses as much memory as there is encoded data,
// while the former uses the fixed amount of memory allocated to the buffer.
// `FileEncoder` also has the advantage of not needing to reallocate as data
}};
}
-impl serialize::Encoder for FileEncoder {
+impl Encoder for FileEncoder {
type Ok = usize;
type Err = io::Error;
// Decoder
// -----------------------------------------------------------------------------
-pub struct Decoder<'a> {
+pub struct MemDecoder<'a> {
pub data: &'a [u8],
position: usize,
}
-impl<'a> Decoder<'a> {
+impl<'a> MemDecoder<'a> {
#[inline]
- pub fn new(data: &'a [u8], position: usize) -> Decoder<'a> {
- Decoder { data, position }
+ pub fn new(data: &'a [u8], position: usize) -> MemDecoder<'a> {
+ MemDecoder { data, position }
}
#[inline]
($dec:expr, $fun:ident) => {{ leb128::$fun($dec.data, &mut $dec.position) }};
}
-impl<'a> serialize::Decoder for Decoder<'a> {
+impl<'a> Decoder for MemDecoder<'a> {
#[inline]
fn read_u128(&mut self) -> u128 {
read_leb128!(self, read_u128_leb128)
// Specialize encoding byte slices. This specialization also applies to encoding `Vec<u8>`s, etc.,
// since the default implementations call `encode` on their slices internally.
-impl serialize::Encodable<Encoder> for [u8] {
- fn encode(&self, e: &mut Encoder) {
- serialize::Encoder::emit_usize(e, self.len());
+impl Encodable<MemEncoder> for [u8] {
+ fn encode(&self, e: &mut MemEncoder) {
+ Encoder::emit_usize(e, self.len());
e.emit_raw_bytes(self);
}
}
-impl serialize::Encodable<FileEncoder> for [u8] {
+impl Encodable<FileEncoder> for [u8] {
fn encode(&self, e: &mut FileEncoder) {
- serialize::Encoder::emit_usize(e, self.len());
+ Encoder::emit_usize(e, self.len());
e.emit_raw_bytes(self);
}
}
// Specialize decoding `Vec<u8>`. This specialization also applies to decoding `Box<[u8]>`s, etc.,
// since the default implementations call `decode` to produce a `Vec<u8>` internally.
-impl<'a> serialize::Decodable<Decoder<'a>> for Vec<u8> {
- fn decode(d: &mut Decoder<'a>) -> Self {
- let len = serialize::Decoder::read_usize(d);
+impl<'a> Decodable<MemDecoder<'a>> for Vec<u8> {
+ fn decode(d: &mut MemDecoder<'a>) -> Self {
+ let len = Decoder::read_usize(d);
d.read_raw_bytes(len).to_owned()
}
}
pub const ENCODED_SIZE: usize = 8;
}
-impl serialize::Encodable<Encoder> for IntEncodedWithFixedSize {
+impl Encodable<MemEncoder> for IntEncodedWithFixedSize {
#[inline]
- fn encode(&self, e: &mut Encoder) {
+ fn encode(&self, e: &mut MemEncoder) {
let _start_pos = e.position();
e.emit_raw_bytes(&self.0.to_le_bytes());
let _end_pos = e.position();
}
}
-impl serialize::Encodable<FileEncoder> for IntEncodedWithFixedSize {
+impl Encodable<FileEncoder> for IntEncodedWithFixedSize {
#[inline]
fn encode(&self, e: &mut FileEncoder) {
let _start_pos = e.position();
}
}
-impl<'a> serialize::Decodable<Decoder<'a>> for IntEncodedWithFixedSize {
+impl<'a> Decodable<MemDecoder<'a>> for IntEncodedWithFixedSize {
#[inline]
- fn decode(decoder: &mut Decoder<'a>) -> IntEncodedWithFixedSize {
+ fn decode(decoder: &mut MemDecoder<'a>) -> IntEncodedWithFixedSize {
let _start_pos = decoder.position();
let bytes = decoder.read_raw_bytes(IntEncodedWithFixedSize::ENCODED_SIZE);
let value = u64::from_le_bytes(bytes.try_into().unwrap());
#![allow(rustc::internal)]
use rustc_macros::{Decodable, Encodable};
-use rustc_serialize::opaque::{Decoder, Encoder};
+use rustc_serialize::opaque::{MemDecoder, MemEncoder};
use rustc_serialize::{Decodable, Encodable, Encoder as EncoderTrait};
use std::fmt::Debug;
q: Option<u32>,
}
-fn check_round_trip<T: Encodable<Encoder> + for<'a> Decodable<Decoder<'a>> + PartialEq + Debug>(
+fn check_round_trip<
+ T: Encodable<MemEncoder> + for<'a> Decodable<MemDecoder<'a>> + PartialEq + Debug,
+>(
values: Vec<T>,
) {
- let mut encoder = Encoder::new();
+ let mut encoder = MemEncoder::new();
for value in &values {
Encodable::encode(value, &mut encoder);
}
let data = encoder.finish().unwrap();
- let mut decoder = Decoder::new(&data[..], 0);
+ let mut decoder = MemDecoder::new(&data[..], 0);
for value in values {
let decoded = Decodable::decode(&mut decoder);
pub struct CharPos(pub usize);
}
-impl<S: rustc_serialize::Encoder> Encodable<S> for BytePos {
+impl<S: Encoder> Encodable<S> for BytePos {
fn encode(&self, s: &mut S) {
s.emit_u32(self.0);
}
}
-impl<D: rustc_serialize::Decoder> Decodable<D> for BytePos {
+impl<D: Decoder> Decodable<D> for BytePos {
fn decode(d: &mut D) -> BytePos {
BytePos(d.read_u32())
}
use self::TyKind::*;
use rustc_data_structures::stable_hasher::HashStable;
-use rustc_serialize::{Decodable, Encodable};
+use rustc_serialize::{Decodable, Decoder, Encodable};
/// Defines the kinds of types used by the type system.
///
I::AllocId: Decodable<D>,
{
fn decode(d: &mut D) -> Self {
- match rustc_serialize::Decoder::read_usize(d) {
+ match Decoder::read_usize(d) {
0 => Bool,
1 => Char,
- 2 => Int(rustc_serialize::Decodable::decode(d)),
- 3 => Uint(rustc_serialize::Decodable::decode(d)),
- 4 => Float(rustc_serialize::Decodable::decode(d)),
- 5 => Adt(rustc_serialize::Decodable::decode(d), rustc_serialize::Decodable::decode(d)),
- 6 => Foreign(rustc_serialize::Decodable::decode(d)),
+ 2 => Int(Decodable::decode(d)),
+ 3 => Uint(Decodable::decode(d)),
+ 4 => Float(Decodable::decode(d)),
+ 5 => Adt(Decodable::decode(d), Decodable::decode(d)),
+ 6 => Foreign(Decodable::decode(d)),
7 => Str,
- 8 => {
- Array(rustc_serialize::Decodable::decode(d), rustc_serialize::Decodable::decode(d))
- }
- 9 => Slice(rustc_serialize::Decodable::decode(d)),
- 10 => RawPtr(rustc_serialize::Decodable::decode(d)),
- 11 => Ref(
- rustc_serialize::Decodable::decode(d),
- rustc_serialize::Decodable::decode(d),
- rustc_serialize::Decodable::decode(d),
- ),
- 12 => {
- FnDef(rustc_serialize::Decodable::decode(d), rustc_serialize::Decodable::decode(d))
- }
- 13 => FnPtr(rustc_serialize::Decodable::decode(d)),
- 14 => Dynamic(
- rustc_serialize::Decodable::decode(d),
- rustc_serialize::Decodable::decode(d),
- ),
- 15 => Closure(
- rustc_serialize::Decodable::decode(d),
- rustc_serialize::Decodable::decode(d),
- ),
- 16 => Generator(
- rustc_serialize::Decodable::decode(d),
- rustc_serialize::Decodable::decode(d),
- rustc_serialize::Decodable::decode(d),
- ),
- 17 => GeneratorWitness(rustc_serialize::Decodable::decode(d)),
+ 8 => Array(Decodable::decode(d), Decodable::decode(d)),
+ 9 => Slice(Decodable::decode(d)),
+ 10 => RawPtr(Decodable::decode(d)),
+ 11 => Ref(Decodable::decode(d), Decodable::decode(d), Decodable::decode(d)),
+ 12 => FnDef(Decodable::decode(d), Decodable::decode(d)),
+ 13 => FnPtr(Decodable::decode(d)),
+ 14 => Dynamic(Decodable::decode(d), Decodable::decode(d)),
+ 15 => Closure(Decodable::decode(d), Decodable::decode(d)),
+ 16 => Generator(Decodable::decode(d), Decodable::decode(d), Decodable::decode(d)),
+ 17 => GeneratorWitness(Decodable::decode(d)),
18 => Never,
- 19 => Tuple(rustc_serialize::Decodable::decode(d)),
- 20 => Projection(rustc_serialize::Decodable::decode(d)),
- 21 => {
- Opaque(rustc_serialize::Decodable::decode(d), rustc_serialize::Decodable::decode(d))
- }
- 22 => Param(rustc_serialize::Decodable::decode(d)),
- 23 => {
- Bound(rustc_serialize::Decodable::decode(d), rustc_serialize::Decodable::decode(d))
- }
- 24 => Placeholder(rustc_serialize::Decodable::decode(d)),
- 25 => Infer(rustc_serialize::Decodable::decode(d)),
- 26 => Error(rustc_serialize::Decodable::decode(d)),
+ 19 => Tuple(Decodable::decode(d)),
+ 20 => Projection(Decodable::decode(d)),
+ 21 => Opaque(Decodable::decode(d), Decodable::decode(d)),
+ 22 => Param(Decodable::decode(d)),
+ 23 => Bound(Decodable::decode(d), Decodable::decode(d)),
+ 24 => Placeholder(Decodable::decode(d)),
+ 25 => Infer(Decodable::decode(d)),
+ 26 => Error(Decodable::decode(d)),
_ => panic!(
"{}",
format!(
use rustc_middle::hir::nested_filter;
use rustc_middle::ty::{self, TyCtxt};
use rustc_serialize::{
- opaque::{Decoder, FileEncoder},
+ opaque::{FileEncoder, MemDecoder},
Decodable, Encodable, Encoder,
};
use rustc_session::getopts;
let mut all_calls: AllCallLocations = FxHashMap::default();
for path in with_examples {
let bytes = fs::read(&path).map_err(|e| format!("{} (for path {})", e, path))?;
- let mut decoder = Decoder::new(&bytes, 0);
+ let mut decoder = MemDecoder::new(&bytes, 0);
let calls = AllCallLocations::decode(&mut decoder);
for (function, fn_calls) in calls.into_iter() {
extern crate rustc_serialize;
use rustc_macros::{Decodable, Encodable};
-use rustc_serialize::opaque;
+use rustc_serialize::opaque::{MemDecoder, MemEncoder};
use rustc_serialize::{Decodable, Encodable, Encoder};
#[derive(Encodable, Decodable)]
fn main() {
let obj = A { foo: Box::new([true, false]) };
- let mut encoder = opaque::Encoder::new();
+ let mut encoder = MemEncoder::new();
obj.encode(&mut encoder);
let data = encoder.finish().unwrap();
- let mut decoder = opaque::Decoder::new(&data, 0);
+ let mut decoder = MemDecoder::new(&data, 0);
let obj2 = A::decode(&mut decoder);
assert_eq!(obj.foo, obj2.foo);
extern crate rustc_serialize;
use rustc_macros::{Decodable, Encodable};
-use rustc_serialize::opaque;
+use rustc_serialize::opaque::{MemDecoder, MemEncoder};
use rustc_serialize::{Decodable, Encodable, Encoder};
use std::cell::{Cell, RefCell};
fn main() {
let obj = B { foo: Cell::new(true), bar: RefCell::new(A { baz: 2 }) };
- let mut encoder = opaque::Encoder::new();
+ let mut encoder = MemEncoder::new();
obj.encode(&mut encoder);
let data = encoder.finish().unwrap();
- let mut decoder = opaque::Decoder::new(&data, 0);
+ let mut decoder = MemDecoder::new(&data, 0);
let obj2 = B::decode(&mut decoder);
assert_eq!(obj.foo.get(), obj2.foo.get());
extern crate rustc_serialize;
use rustc_macros::{Decodable, Encodable};
-use rustc_serialize::opaque;
+use rustc_serialize::opaque::{MemDecoder, MemEncoder};
use rustc_serialize::{Decodable, Encodable, Encoder};
#[derive(Encodable, Decodable, PartialEq, Debug)]
pub fn main() {
let obj = UnitLikeStruct;
- let mut encoder = opaque::Encoder::new();
+ let mut encoder = MemEncoder::new();
obj.encode(&mut encoder);
let data = encoder.finish().unwrap();
- let mut decoder = opaque::Decoder::new(&data, 0);
+ let mut decoder = MemDecoder::new(&data, 0);
let obj2 = UnitLikeStruct::decode(&mut decoder);
assert_eq!(obj, obj2);
projects / rust.git / commitdiff