Migrate from rustc-serialize to Serde

Cargo.toml

@@ -35,11 +35,15 @@ log = "0.3"
 num_cpus = "1.0"
 rustc-serialize = "0.3"
 semver = "0.6.0"
+serde = "0.9"
+serde_derive = "0.9"
+serde_json = "0.9"
+serde_ignored = "0.0.2"
 shell-escape = "0.1"
 tar = { version = "0.4", default-features = false }
 tempdir = "0.3"
 term = "0.4.4"
-toml = "0.2"
+toml = "0.3"
 url = "1.1"
 
 [target.'cfg(unix)'.dependencies]

src/bin/cargo.rs

@@ -6,6 +6,9 @@ extern crate rustc_serialize;
 extern crate toml;
 #[macro_use]
 extern crate log;
+#[macro_use]
+extern crate serde_derive;
+extern crate serde_json;
 
 use std::collections::BTreeSet;
 use std::collections::HashMap;

src/bin/locate_project.rs

@@ -18,7 +18,7 @@ Options:
     -h, --help              Print this message
 ";
 
-#[derive(RustcEncodable)]
+#[derive(Serialize)]
 pub struct ProjectLocation {
     root: String
 }

src/bin/verify_project.rs

@@ -6,7 +6,7 @@ use std::process;
 use cargo;
 use cargo::util::important_paths::{find_root_manifest_for_wd};
 use cargo::util::{CliResult, Config};
-use rustc_serialize::json;
+use serde_json;
 use toml;
 
 #[derive(RustcDecodable)]
@@ -55,10 +55,9 @@ pub fn execute(args: Flags, config: &Config) -> CliResult {
         Ok(_) => {},
         Err(e) => fail("invalid", &format!("error reading file: {}", e))
     };
-    match toml::Parser::new(&contents).parse() {
-        None => fail("invalid", "invalid-format"),
-        Some(..) => {}
-    };
+    if contents.parse::<toml::Value>().is_err() {
+        fail("invalid", "invalid-format");
+    }
 
     let mut h = HashMap::new();
     h.insert("success".to_string(), "true".to_string());
@@ -69,6 +68,6 @@ pub fn execute(args: Flags, config: &Config) -> CliResult {
 fn fail(reason: &str, value: &str) -> ! {
     let mut h = HashMap::new();
     h.insert(reason.to_string(), value.to_string());
-    println!("{}", json::encode(&h).unwrap());
+    println!("{}", serde_json::to_string(&h).unwrap());
     process::exit(1)
 }

src/cargo/core/dependency.rs

@@ -4,7 +4,7 @@ use std::str::FromStr;
 
 use semver::VersionReq;
 use semver::ReqParseError;
-use rustc_serialize::{Encoder, Encodable};
+use serde::ser;
 
 use core::{SourceId, Summary, PackageId};
 use util::{CargoError, CargoResult, Cfg, CfgExpr, ChainError, human, Config};
@@ -41,7 +41,7 @@ pub enum Platform {
     Cfg(CfgExpr),
 }
 
-#[derive(RustcEncodable)]
+#[derive(Serialize)]
 struct SerializedDependency<'a> {
     name: &'a str,
     source: &'a SourceId,
@@ -54,8 +54,10 @@ struct SerializedDependency<'a> {
     target: Option<&'a Platform>,
 }
 
-impl Encodable for Dependency {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+impl ser::Serialize for Dependency {
+    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
+        where S: ser::Serializer,
+    {
         SerializedDependency {
             name: self.name(),
             source: &self.source_id(),
@@ -65,7 +67,7 @@ impl Encodable for Dependency {
             uses_default_features: self.uses_default_features(),
             features: self.features(),
             target: self.platform(),
-        }.encode(s)
+        }.serialize(s)
     }
 }
 
@@ -76,13 +78,15 @@ pub enum Kind {
     Build,
 }
 
-impl Encodable for Kind {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+impl ser::Serialize for Kind {
+    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
+        where S: ser::Serializer,
+    {
         match *self {
             Kind::Normal => None,
             Kind::Development => Some("dev"),
             Kind::Build => Some("build"),
-        }.encode(s)
+        }.serialize(s)
     }
 }
 
@@ -136,7 +140,7 @@ This will soon become a hard error, so it's either recommended to
 update to a fixed version or contact the upstream maintainer about
 this warning.
 ",
-	req, inside.name(), inside.version(), requirement);
+    req, inside.name(), inside.version(), requirement);
                         config.shell().warn(&msg)?;
 
                         Ok(requirement)
@@ -348,9 +352,11 @@ impl Platform {
     }
 }
 
-impl Encodable for Platform {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        self.to_string().encode(s)
+impl ser::Serialize for Platform {
+    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
+        where S: ser::Serializer,
+    {
+        self.to_string().serialize(s)
     }
 }