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())
     }
 }