rls-span: Use serde exclusively and serde_derive optionally

Author: Xanewok

rls-span/Cargo.toml

@@ -7,12 +7,11 @@ license = "Apache-2.0/MIT"
 repository = "https://github.com/rust-lang/rls"
 categories = ["development-tools"]
 
-[features]
-default = []
-serialize-serde = ["serde", "serde_derive"]
-serialize-rustc = ["rustc-serialize"]
 
 [dependencies]
-rustc-serialize = { version = "0.3", optional = true }
-serde = { version = "1.0", optional = true }
+serde = "1.0"
 serde_derive = { version = "1.0", optional = true }
+
+[features]
+default = []
+derive = ["serde_derive"]

rls-span/src/compiler.rs

@@ -1,19 +1,11 @@
-// Copyright 2016 The RLS Project Developers.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-/// These are the structures emitted by the compiler as part of JSON errors.
-/// The original source can be found at
-/// https://github.com/rust-lang/rust/blob/master/src/libsyntax/json.rs
+///! These are the structures emitted by the compiler as part of JSON errors.
+///! The original source can be found at
+///! https://github.com/rust-lang/rust/blob/master/src/libsyntax/json.rs
 use std::path::PathBuf;
 
 use {Column, OneIndexed, Row, Span};
 
-#[cfg_attr(feature = "serialize-serde", derive(Deserialize))]
+#[cfg_attr(feature = "derive", derive(Deserialize))]
 #[derive(Debug, Clone)]
 pub struct DiagnosticSpan {
     pub file_name: String,
@@ -53,7 +45,7 @@ impl DiagnosticSpan {
     }
 }
 
-#[cfg_attr(feature = "serialize-serde", derive(Deserialize))]
+#[cfg_attr(feature = "derive", derive(Deserialize))]
 #[derive(Debug, Clone)]
 pub struct DiagnosticSpanLine {
     pub text: String,
@@ -64,7 +56,7 @@ pub struct DiagnosticSpanLine {
     pub highlight_end: usize,
 }
 
-#[cfg_attr(feature = "serialize-serde", derive(Deserialize))]
+#[cfg_attr(feature = "derive", derive(Deserialize))]
 #[derive(Debug, Clone)]
 pub struct DiagnosticSpanMacroExpansion {
     /// span where macro was applied to generate this code; note that

rls-span/src/lib.rs

@@ -1,31 +1,15 @@
-// Copyright 2016 The RLS Project Developers.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![cfg_attr(rustbuild, feature(staged_api, rustc_private))]
-#![cfg_attr(rustbuild, unstable(feature = "rustc_private", issue = "27812"))]
-
-#[cfg(feature = "serialize-serde")]
 extern crate serde;
-#[cfg(feature = "serialize-serde")]
+#[cfg(feature = "derive")]
 #[macro_use]
 extern crate serde_derive;
-#[cfg(feature = "serialize-rustc")]
-extern crate rustc_serialize;
 
-#[cfg(feature = "serialize-rustc")]
-use rustc_serialize::{Decodable, Encodable};
-#[cfg(feature = "serialize-serde")]
 use serde::{Deserialize, Serialize};
 
 use std::marker::PhantomData;
 use std::path::PathBuf;
 
 pub mod compiler;
+mod serde_expanded;
 
 #[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Column<I: Indexed>(pub u32, PhantomData<I>);
@@ -44,7 +28,6 @@ impl<I: Indexed> Clone for Column<I> {
 
 impl<I: Indexed> Copy for Column<I> {}
 
-#[cfg(feature = "serialize-serde")]
 impl<I: Indexed> Serialize for Column<I> {
     fn serialize<S: serde::Serializer>(
         &self,
@@ -54,26 +37,11 @@ impl<I: Indexed> Serialize for Column<I> {
     }
 }
 
-#[cfg(feature = "serialize-serde")]
 impl<'dt, I: Indexed> Deserialize<'dt> for Column<I> {
     fn deserialize<D: serde::Deserializer<'dt>>(
         d: D,
     ) -> std::result::Result<Self, <D as serde::Deserializer<'dt>>::Error> {
-        <u32 as Deserialize>::deserialize(d).map(|x| Column::new(x))
-    }
-}
-
-#[cfg(feature = "serialize-rustc")]
-impl<I: Indexed> Decodable for Column<I> {
-    fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<Column<I>, D::Error> {
-        d.read_u32().map(|x| Column::new(x))
-    }
-}
-
-#[cfg(feature = "serialize-rustc")]
-impl<I: Indexed> Encodable for Column<I> {
-    fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_u32(self.0)
+        <u32 as Deserialize>::deserialize(d).map(Column::new)
     }
 }
 
@@ -114,31 +82,15 @@ impl<I: Indexed> Clone for Row<I> {
 
 impl<I: Indexed> Copy for Row<I> {}
 
-#[cfg(feature = "serialize-serde")]
 impl<I: Indexed> serde::Serialize for Row<I> {
     fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
         s.serialize_u32(self.0)
     }
 }
 
-#[cfg(feature = "serialize-serde")]
 impl<'dt, I: Indexed> serde::Deserialize<'dt> for Row<I> {
     fn deserialize<D: serde::Deserializer<'dt>>(d: D) -> std::result::Result<Self, D::Error> {
-        <u32 as Deserialize>::deserialize(d).map(|x| Row::new(x))
-    }
-}
-
-#[cfg(feature = "serialize-rustc")]
-impl<I: Indexed> Decodable for Row<I> {
-    fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<Row<I>, D::Error> {
-        d.read_u32().map(|x| Row::new(x))
-    }
-}
-
-#[cfg(feature = "serialize-rustc")]
-impl<I: Indexed> Encodable for Row<I> {
-    fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_u32(self.0)
+        <u32 as Deserialize>::deserialize(d).map(Row::new)
     }
 }
 
@@ -162,8 +114,7 @@ impl Row<ZeroIndexed> {
     }
 }
 
-#[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
-#[cfg_attr(feature = "serialize-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "derive", derive(Serialize, Deserialize))]
 #[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Position<I: Indexed> {
     pub row: Row<I>,
@@ -196,8 +147,7 @@ impl Position<ZeroIndexed> {
     }
 }
 
-#[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
-#[cfg_attr(feature = "serialize-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "derive", derive(Serialize, Deserialize))]
 #[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Range<I: Indexed> {
     pub row_start: Row<I>,
@@ -259,8 +209,7 @@ impl Range<ZeroIndexed> {
     }
 }
 
-#[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
-#[cfg_attr(feature = "serialize-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "derive", derive(Serialize, Deserialize))]
 #[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Location<I: Indexed> {
     pub file: PathBuf,
@@ -295,8 +244,7 @@ impl Location<ZeroIndexed> {
     }
 }
 
-#[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
-#[cfg_attr(feature = "serialize-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "derive", derive(Serialize, Deserialize))]
 #[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Span<I: Indexed> {
     pub file: PathBuf,
@@ -345,17 +293,14 @@ impl Span<ZeroIndexed> {
     }
 }
 
-#[cfg(feature = "serialize-serde")]
 pub trait Indexed {}
-#[cfg(not(feature = "serialize-serde"))]
-pub trait Indexed {}
-#[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
-#[cfg_attr(feature = "serialize-serde", derive(Serialize, Deserialize))]
+
+#[cfg_attr(feature = "derive", derive(Serialize, Deserialize))]
 #[derive(Hash, PartialEq, Eq, Debug, PartialOrd, Ord)]
 pub struct ZeroIndexed;
 impl Indexed for ZeroIndexed {}
-#[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
-#[cfg_attr(feature = "serialize-serde", derive(Serialize, Deserialize))]
+
+#[cfg_attr(feature = "derive", derive(Serialize, Deserialize))]
 #[derive(Hash, PartialEq, Eq, Debug, PartialOrd, Ord)]
 pub struct OneIndexed;
 impl Indexed for OneIndexed {}