Use slicing syntax instead of .as_slice()

src/de.rs

@@ -295,8 +295,8 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
             Token::Str(value) if value.chars().count() == 1 => {
                 Ok(value.char_at(0))
             }
-            Token::String(ref value) if value.as_slice().chars().count() == 1 => {
-                Ok(value.as_slice().char_at(0))
+            Token::String(ref value) if value[].chars().count() == 1 => {
+                Ok(value[].char_at(0))
             }
             token => {
                 static EXPECTED_TOKENS: &'static [TokenKind] = &[
@@ -410,7 +410,7 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
                 Ok(Some(fields.iter().position(|field| *field == n)))
             }
             Token::String(n) => {
-                Ok(Some(fields.iter().position(|field| *field == n.as_slice())))
+                Ok(Some(fields.iter().position(|field| *field == &n[])))
             }
             token => {
                 Err(self.syntax_error(token, STR_TOKEN_KINDS))

src/json/de.rs

@@ -399,7 +399,7 @@ impl<Iter: Iterator<Item=u8>> Parser<Iter> {
 
                         let buf = &mut [0u8; 4];
                         let len = c.encode_utf8(buf).unwrap_or(0);
-                        self.buf.extend(buf.slice_to(len).iter().map(|b| *b));
+                        self.buf.extend(buf[..len].iter().map(|b| *b));
                     }
                     _ => {
                         return Err(self.error(ErrorCode::InvalidEscape));
@@ -580,7 +580,7 @@ impl<Iter: Iterator<Item=u8>> de::Deserializer<Error> for Parser<Iter> {
             _ => { return Err(self.error(ErrorCode::ExpectedEnumToken)); }
         }
 
-        match variants.iter().position(|v| *v == variant.as_slice()) {
+        match variants.iter().position(|v| *v == &variant[]) {
             Some(idx) => Ok(idx),
             None => Err(self.error(ErrorCode::UnknownVariant)),
         }
@@ -631,7 +631,7 @@ impl<Iter: Iterator<Item=u8>> de::Deserializer<Error> for Parser<Iter> {
             None => { return Ok(None); }
         };
 
-        Ok(Some(fields.iter().position(|field| *field == s.as_slice())))
+        Ok(Some(fields.iter().position(|field| *field == &s[])))
     }
 }
 

src/json/ser.rs

@@ -25,7 +25,7 @@ fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> IoResult<()> {
         };
 
         if start < i {
-            try!(wr.write(bytes.slice(start, i)));
+            try!(wr.write(&bytes[start..i]));
         }
 
         try!(wr.write_str(escaped));
@@ -34,7 +34,7 @@ fn escape_bytes<W: Writer>(wr: &mut W, bytes: &[u8]) -> IoResult<()> {
     }
 
     if start != bytes.len() {
-        try!(wr.write(bytes.slice_from(start)));
+        try!(wr.write(&bytes[start..]));
     }
 
     wr.write_str("\"")
@@ -74,7 +74,7 @@ fn spaces<W: Writer>(wr: &mut W, mut n: usize) -> IoResult<()> {
     }
 
     if n > 0 {
-        wr.write(BUF.slice_to(n))
+        wr.write(&BUF[..n])
     } else {
         Ok(())
     }

src/json/value.rs

@@ -498,7 +498,7 @@ impl de::Deserializer<Error> for Deserializer {
             }
         };
 
-        match variants.iter().position(|v| *v == variant.as_slice()) {
+        match variants.iter().position(|v| *v == &variant[]) {
             Some(idx) => Ok(idx),
             None => Err(Error::UnknownVariantError(variant)),
         }

src/ser.rs

@@ -158,7 +158,7 @@ impl<'a, S: Serializer<E>, E> Serialize<S, E> for &'a str {
 impl<S: Serializer<E>, E> Serialize<S, E> for String {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
-        self.as_slice().serialize(s)
+        (&self[]).serialize(s)
     }
 }