Auto merge of #56323 - eddyb:que-seri-sera, r=<try>

[WIP] serialize: rename to rustc_serialize.

In preparation for post-#49219 use of custom derives in rustc, we'll want to stop using `Rustc{Encodable,Decodable}` derives, and *at least* adapt the library to suit `rustc` better, before a full implementation of #36588 can be done.

This will break anyone using `extern crate serialize;` (on nightly) so let's do a crater run with a rename, just to see what things are like.

**EDIT**: I was going to test with `rustc_serialize` (which does work in terms of compiling) but I realized that `rustc-serialize` from crates.io might make that tricky if it ends up in our sysroot, so for the crater run let's go with something weirder (`rustc_ezilaires`).

**EDIT2**: had to remove `rustc_save_analysis` and `rls` to get rid of the crates.io `rustc-serialize` from Cargo.lock. Note that this is just for crater, just like the `rustc_ezilaires` rename.

r? @nikomatsakis

Author: bors

Cargo.lock

@@ -19,13 +19,12 @@ members = [
   "src/tools/rust-installer",
   "src/tools/cargo",
   "src/tools/rustdoc",
-  "src/tools/rls",
   "src/tools/rustfmt",
   "src/tools/miri",
   "src/tools/rustdoc-themes",
 ]
 exclude = [
-  "src/tools/rls/test_data",
+  "src/tools/rls",
   "build",
   # HACK(eddyb) This hardcodes the fact that our CI uses `/checkout/obj`.
   "obj",

Cargo.toml

@@ -25,7 +25,7 @@ rustc_apfloat = { path = "../librustc_apfloat" }
 rustc_target = { path = "../librustc_target" }
 rustc_data_structures = { path = "../librustc_data_structures" }
 rustc_errors = { path = "../librustc_errors" }
-serialize = { path = "../libserialize" }
+rustc_ezilaires = { path = "../librustc_ezilaires" }
 syntax = { path = "../libsyntax" }
 syntax_pos = { path = "../libsyntax_pos" }
 backtrace = "0.3.3"

src/librustc/Cargo.toml

@@ -11,7 +11,7 @@
 use ty;
 use hir::map::definitions::FIRST_FREE_HIGH_DEF_INDEX;
 use rustc_data_structures::indexed_vec::Idx;
-use serialize;
+use rustc_ezilaires;
 use std::fmt;
 use std::u32;
 
@@ -107,8 +107,8 @@ impl fmt::Display for CrateNum {
     }
 }
 
-impl serialize::UseSpecializedEncodable for CrateNum {}
-impl serialize::UseSpecializedDecodable for CrateNum {}
+impl rustc_ezilaires::UseSpecializedEncodable for CrateNum {}
+impl rustc_ezilaires::UseSpecializedDecodable for CrateNum {}
 
 /// A DefIndex is an index into the hir-map for a crate, identifying a
 /// particular definition. It should really be considered an interned
@@ -199,8 +199,8 @@ impl DefIndex {
     }
 }
 
-impl serialize::UseSpecializedEncodable for DefIndex {}
-impl serialize::UseSpecializedDecodable for DefIndex {}
+impl rustc_ezilaires::UseSpecializedEncodable for DefIndex {}
+impl rustc_ezilaires::UseSpecializedDecodable for DefIndex {}
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum DefIndexAddressSpace {
@@ -259,8 +259,8 @@ impl DefId {
     }
 }
 
-impl serialize::UseSpecializedEncodable for DefId {}
-impl serialize::UseSpecializedDecodable for DefId {}
+impl rustc_ezilaires::UseSpecializedEncodable for DefId {}
+impl rustc_ezilaires::UseSpecializedDecodable for DefId {}
 
 /// A LocalDefId is equivalent to a DefId with `krate == LOCAL_CRATE`. Since
 /// we encode this information in the type, we can ensure at compile time that
@@ -293,5 +293,5 @@ impl fmt::Debug for LocalDefId {
     }
 }
 
-impl serialize::UseSpecializedEncodable for LocalDefId {}
-impl serialize::UseSpecializedDecodable for LocalDefId {}
+impl rustc_ezilaires::UseSpecializedEncodable for LocalDefId {}
+impl rustc_ezilaires::UseSpecializedDecodable for LocalDefId {}

src/librustc/hir/def_id.rs

@@ -21,7 +21,7 @@ use ich::Fingerprint;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::indexed_vec::{IndexVec};
 use rustc_data_structures::stable_hasher::StableHasher;
-use serialize::{Encodable, Decodable, Encoder, Decoder};
+use rustc_ezilaires::{Encodable, Decodable, Encoder, Decoder};
 use session::CrateDisambiguator;
 use std::borrow::Borrow;
 use std::fmt::Write;

src/librustc/hir/map/definitions.rs

@@ -40,7 +40,7 @@ use ty::query::Providers;
 use rustc_data_structures::sync::{ParallelIterator, par_iter, Send, Sync, scope};
 use rustc_data_structures::thin_vec::ThinVec;
 
-use serialize::{self, Encoder, Encodable, Decoder, Decodable};
+use rustc_ezilaires::{self, Encoder, Encodable, Decoder, Decodable};
 use std::collections::BTreeMap;
 use std::fmt;
 
@@ -95,7 +95,7 @@ impl HirId {
     }
 }
 
-impl serialize::UseSpecializedEncodable for HirId {
+impl rustc_ezilaires::UseSpecializedEncodable for HirId {
     fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         let HirId {
             owner,
@@ -107,7 +107,7 @@ impl serialize::UseSpecializedEncodable for HirId {
     }
 }
 
-impl serialize::UseSpecializedDecodable for HirId {
+impl rustc_ezilaires::UseSpecializedDecodable for HirId {
     fn default_decode<D: Decoder>(d: &mut D) -> Result<HirId, D::Error> {
         let owner = DefIndex::decode(d)?;
         let local_id = ItemLocalId::decode(d)?;

src/librustc/hir/mod.rs

@@ -34,7 +34,7 @@
 use infer::{InferCtxt, RegionVariableOrigin, TypeVariableOrigin};
 use rustc_data_structures::indexed_vec::IndexVec;
 use rustc_data_structures::sync::Lrc;
-use serialize::UseSpecializedDecodable;
+use rustc_ezilaires::UseSpecializedDecodable;
 use smallvec::SmallVec;
 use std::ops::Index;
 use syntax::source_map::Span;

src/librustc/infer/canonical/mod.rs

@@ -88,7 +88,6 @@ extern crate libc;
 extern crate polonius_engine;
 extern crate rustc_target;
 #[macro_use] extern crate rustc_data_structures;
-extern crate serialize;
 extern crate parking_lot;
 extern crate rustc_errors as errors;
 extern crate rustc_rayon as rayon;
@@ -101,7 +100,7 @@ extern crate proc_macro;
 extern crate chalk_engine;
 extern crate rustc_fs_util;
 
-extern crate serialize as rustc_serialize; // used by deriving
+extern crate rustc_ezilaires; use rustc_ezilaires as rustc_serialize; // used by deriving
 
 extern crate rustc_apfloat;
 extern crate byteorder;

src/librustc/lib.rs

@@ -33,7 +33,7 @@ use lint::{Level, Lint, LintId, LintPass, LintBuffer};
 use lint::builtin::BuiltinLintDiagnostics;
 use lint::levels::{LintLevelSets, LintLevelsBuilder};
 use middle::privacy::AccessLevels;
-use rustc_serialize::{Decoder, Decodable, Encoder, Encodable};
+use rustc_ezilaires::{Decoder, Decodable, Encoder, Encodable};
 use session::{config, early_error, Session};
 use ty::{self, TyCtxt, Ty};
 use ty::layout::{LayoutError, LayoutOf, TyLayout};

src/librustc/lint/context.rs

@@ -15,23 +15,23 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher,
 use ich::StableHashingContext;
 use mir::{Mir, BasicBlock};
 
-use rustc_serialize as serialize;
+use rustc_ezilaires;
 
 #[derive(Clone, Debug)]
 pub struct Cache {
     predecessors: RwLock<Option<IndexVec<BasicBlock, Vec<BasicBlock>>>>
 }
 
 
-impl serialize::Encodable for Cache {
-    fn encode<S: serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        serialize::Encodable::encode(&(), s)
+impl rustc_ezilaires::Encodable for Cache {
+    fn encode<S: rustc_ezilaires::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+        rustc_ezilaires::Encodable::encode(&(), s)
     }
 }
 
-impl serialize::Decodable for Cache {
-    fn decode<D: serialize::Decoder>(d: &mut D) -> Result<Self, D::Error> {
-        serialize::Decodable::decode(d).map(|_v: ()| Self::new())
+impl rustc_ezilaires::Decodable for Cache {
+    fn decode<D: rustc_ezilaires::Decoder>(d: &mut D) -> Result<Self, D::Error> {
+        rustc_ezilaires::Decodable::decode(d).map(|_v: ()| Self::new())
     }
 }
 

src/librustc/mir/cache.rs

@@ -139,7 +139,7 @@ impl<Tag, Extra> Allocation<Tag, Extra> {
     }
 }
 
-impl<'tcx> ::serialize::UseSpecializedDecodable for &'tcx Allocation {}
+impl<'tcx> ::rustc_ezilaires::UseSpecializedDecodable for &'tcx Allocation {}
 
 /// Alignment and bounds checks
 impl<'tcx, Tag, Extra> Allocation<Tag, Extra> {

src/librustc/mir/interpret/allocation.rs

@@ -42,7 +42,7 @@ use ty::layout::{self, Size};
 use middle::region;
 use std::io;
 use std::hash::Hash;
-use rustc_serialize::{Encoder, Decodable, Encodable};
+use rustc_ezilaires::{Encoder, Decodable, Encodable};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::{Lock as Mutex, HashMapExt};
 use rustc_data_structures::tiny_list::TinyList;
@@ -86,8 +86,8 @@ pub struct GlobalId<'tcx> {
 #[derive(Copy, Clone, Eq, Hash, Ord, PartialEq, PartialOrd, Debug)]
 pub struct AllocId(pub u64);
 
-impl ::rustc_serialize::UseSpecializedEncodable for AllocId {}
-impl ::rustc_serialize::UseSpecializedDecodable for AllocId {}
+impl ::rustc_ezilaires::UseSpecializedEncodable for AllocId {}
+impl ::rustc_ezilaires::UseSpecializedDecodable for AllocId {}
 
 #[derive(RustcDecodable, RustcEncodable)]
 enum AllocKind {

src/librustc/mir/interpret/mod.rs

@@ -25,7 +25,7 @@ use rustc_data_structures::graph::{self, GraphPredecessors, GraphSuccessors};
 use rustc_data_structures::indexed_vec::{Idx, IndexVec};
 use rustc_data_structures::sync::Lrc;
 use rustc_data_structures::sync::MappedReadGuard;
-use rustc_serialize as serialize;
+use rustc_ezilaires;
 use smallvec::SmallVec;
 use std::borrow::Cow;
 use std::fmt::{self, Debug, Formatter, Write};
@@ -456,8 +456,10 @@ impl<T> ClearCrossCrate<T> {
     }
 }
 
-impl<T: serialize::Encodable> serialize::UseSpecializedEncodable for ClearCrossCrate<T> {}
-impl<T: serialize::Decodable> serialize::UseSpecializedDecodable for ClearCrossCrate<T> {}
+impl<T: rustc_ezilaires::Encodable> rustc_ezilaires::UseSpecializedEncodable
+    for ClearCrossCrate<T> {}
+impl<T: rustc_ezilaires::Decodable> rustc_ezilaires::UseSpecializedDecodable
+    for ClearCrossCrate<T> {}
 
 /// Grouped information about the source code origin of a MIR entity.
 /// Intended to be inspected by diagnostics and debuginfo.

src/librustc/mir/mod.rs

@@ -19,7 +19,7 @@
 use hir::def_id::{DefId, CrateNum};
 use infer::canonical::{CanonicalVarInfo, CanonicalVarInfos};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_serialize::{Decodable, Decoder, Encoder, Encodable, opaque};
+use rustc_ezilaires::{Decodable, Decoder, Encoder, Encodable, opaque};
 use std::hash::Hash;
 use std::intrinsics;
 use ty::{self, Ty, TyCtxt};
@@ -293,7 +293,7 @@ macro_rules! implement_ty_decoder {
             use $crate::ty::codec::*;
             use $crate::ty::subst::Substs;
             use $crate::hir::def_id::{CrateNum};
-            use rustc_serialize::{Decoder, SpecializedDecoder};
+            use rustc_ezilaires::{Decoder, SpecializedDecoder};
             use std::borrow::Cow;
 
             impl<$($typaram ),*> Decoder for $DecoderName<$($typaram),*> {

src/librustc/ty/codec.rs

@@ -41,7 +41,7 @@ use util::nodemap::{NodeSet, DefIdMap, FxHashMap};
 use arena::SyncDroplessArena;
 use session::DataTypeKind;
 
-use serialize::{self, Encodable, Encoder};
+use rustc_ezilaires::{self, Encodable, Encoder};
 use std::cell::RefCell;
 use std::cmp::{self, Ordering};
 use std::fmt;
@@ -598,8 +598,8 @@ impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for ty::TyS<'gcx> {
 
 pub type Ty<'tcx> = &'tcx TyS<'tcx>;
 
-impl<'tcx> serialize::UseSpecializedEncodable for Ty<'tcx> {}
-impl<'tcx> serialize::UseSpecializedDecodable for Ty<'tcx> {}
+impl<'tcx> rustc_ezilaires::UseSpecializedEncodable for Ty<'tcx> {}
+impl<'tcx> rustc_ezilaires::UseSpecializedDecodable for Ty<'tcx> {}
 
 pub type CanonicalTy<'gcx> = Canonical<'gcx, Ty<'gcx>>;
 
@@ -718,7 +718,7 @@ impl<'a, T> IntoIterator for &'a List<T> {
     }
 }
 
-impl<'tcx> serialize::UseSpecializedDecodable for &'tcx List<Ty<'tcx>> {}
+impl<'tcx> rustc_ezilaires::UseSpecializedDecodable for &'tcx List<Ty<'tcx>> {}
 
 impl<T> List<T> {
     #[inline(always)]
@@ -995,8 +995,8 @@ pub struct GenericPredicates<'tcx> {
     pub predicates: Vec<(Predicate<'tcx>, Span)>,
 }
 
-impl<'tcx> serialize::UseSpecializedEncodable for GenericPredicates<'tcx> {}
-impl<'tcx> serialize::UseSpecializedDecodable for GenericPredicates<'tcx> {}
+impl<'tcx> rustc_ezilaires::UseSpecializedEncodable for GenericPredicates<'tcx> {}
+impl<'tcx> rustc_ezilaires::UseSpecializedDecodable for GenericPredicates<'tcx> {}
 
 impl<'a, 'gcx, 'tcx> GenericPredicates<'tcx> {
     pub fn instantiate(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>, substs: &Substs<'tcx>)
@@ -1901,13 +1901,13 @@ impl Hash for AdtDef {
     }
 }
 
-impl<'tcx> serialize::UseSpecializedEncodable for &'tcx AdtDef {
+impl<'tcx> rustc_ezilaires::UseSpecializedEncodable for &'tcx AdtDef {
     fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         self.did.encode(s)
     }
 }
 
-impl<'tcx> serialize::UseSpecializedDecodable for &'tcx AdtDef {}
+impl<'tcx> rustc_ezilaires::UseSpecializedDecodable for &'tcx AdtDef {}
 
 
 impl<'a> HashStable<StableHashingContext<'a>> for AdtDef {

src/librustc/ty/mod.rs

@@ -19,7 +19,7 @@ use mir::interpret::{AllocDecodingSession, AllocDecodingState};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::{Lrc, Lock, HashMapExt, Once};
 use rustc_data_structures::indexed_vec::{IndexVec, Idx};
-use rustc_serialize::{Decodable, Decoder, Encodable, Encoder, opaque,
+use rustc_ezilaires::{Decodable, Decoder, Encodable, Encoder, opaque,
                       SpecializedDecoder, SpecializedEncoder,
                       UseSpecializedDecodable, UseSpecializedEncodable};
 use session::{CrateDisambiguator, Session};

src/librustc/ty/query/on_disk_cache.rs

@@ -29,7 +29,7 @@ use rustc_target::spec::abi;
 use syntax::ast::{self, Ident};
 use syntax::symbol::{keywords, InternedString};
 
-use serialize;
+use rustc_ezilaires;
 
 use hir;
 
@@ -578,7 +578,7 @@ impl<'a, 'gcx, 'tcx> Binder<ExistentialPredicate<'tcx>> {
     }
 }
 
-impl<'tcx> serialize::UseSpecializedDecodable for &'tcx List<ExistentialPredicate<'tcx>> {}
+impl<'tcx> rustc_ezilaires::UseSpecializedDecodable for &'tcx List<ExistentialPredicate<'tcx>> {}
 
 impl<'tcx> List<ExistentialPredicate<'tcx>> {
     pub fn principal(&self) -> ExistentialTraitRef<'tcx> {
@@ -1189,7 +1189,7 @@ pub enum RegionKind {
     ReClosureBound(RegionVid),
 }
 
-impl<'tcx> serialize::UseSpecializedDecodable for Region<'tcx> {}
+impl<'tcx> rustc_ezilaires::UseSpecializedDecodable for Region<'tcx> {}
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug, PartialOrd, Ord)]
 pub struct EarlyBoundRegion {
@@ -2100,4 +2100,4 @@ impl<'tcx> Const<'tcx> {
     }
 }
 
-impl<'tcx> serialize::UseSpecializedDecodable for &'tcx Const<'tcx> {}
+impl<'tcx> rustc_ezilaires::UseSpecializedDecodable for &'tcx Const<'tcx> {}

src/librustc/ty/sty.rs

@@ -15,7 +15,7 @@ use infer::canonical::Canonical;
 use ty::{self, BoundVar, Lift, List, Ty, TyCtxt};
 use ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
 
-use serialize::{self, Encodable, Encoder, Decodable, Decoder};
+use rustc_ezilaires::{self, Encodable, Encoder, Decodable, Decoder};
 use syntax_pos::{Span, DUMMY_SP};
 use rustc_data_structures::indexed_vec::Idx;
 use smallvec::SmallVec;
@@ -352,7 +352,7 @@ impl<'tcx> TypeFoldable<'tcx> for &'tcx Substs<'tcx> {
     }
 }
 
-impl<'tcx> serialize::UseSpecializedDecodable for &'tcx Substs<'tcx> {}
+impl<'tcx> rustc_ezilaires::UseSpecializedDecodable for &'tcx Substs<'tcx> {}
 
 ///////////////////////////////////////////////////////////////////////////
 // Public trait `Subst`

src/librustc/ty/subst.rs

@@ -13,7 +13,7 @@ use std::path::Path;
 use std::str;
 
 use rustc_data_structures::fx::FxHashMap;
-use serialize::leb128;
+use rustc_ezilaires::leb128;
 
 // https://webassembly.github.io/spec/core/binary/modules.html#binary-importsec
 const WASM_IMPORT_SECTION_ID: u8 = 2;

src/librustc_codegen_llvm/back/wasm.rs

@@ -62,7 +62,7 @@ extern crate rustc_fs_util;
 #[macro_use] extern crate syntax;
 extern crate syntax_pos;
 extern crate rustc_errors as errors;
-extern crate serialize;
+extern crate rustc_ezilaires;
 extern crate cc; // Used to locate MSVC
 extern crate tempfile;
 extern crate memmap;

src/librustc_codegen_llvm/lib.rs

@@ -19,7 +19,7 @@ log = "0.4.5"
 libc = "0.2.43"
 jobserver = "0.1.11"
 
-serialize = { path = "../libserialize" }
+rustc_ezilaires = { path = "../librustc_ezilaires" }
 syntax = { path = "../libsyntax" }
 syntax_pos = { path = "../libsyntax_pos" }
 rustc = { path = "../librustc" }

src/librustc_codegen_ssa/Cargo.toml

@@ -26,7 +26,7 @@ use rustc::session::config::{self, CrateType, OptLevel, DebugInfo,
                              CrossLangLto};
 use rustc::ty::TyCtxt;
 use rustc_target::spec::{LinkerFlavor, LldFlavor};
-use serialize::{json, Encoder};
+use rustc_ezilaires::{json, Encoder};
 
 /// For all the linkers we support, and information they might
 /// need out of the shared crate context before we get rid of it.