Remove usage of some unstable features.

Author: SimonSapin

macros/src/named_entities.rs

@@ -33,7 +33,7 @@ struct CharRef {
 }
 
 // Build the map from entity names (and their prefixes) to characters.
-fn build_map(js: Json) -> Option<HashMap<String, [u32; 2]>> {
+fn build_map(js: Json) -> Option<HashMap<String, (u32, u32)>> {
     let mut map = HashMap::new();
     let json_map = match js {
         Json::Object(m) => m,
@@ -47,24 +47,23 @@ fn build_map(js: Json) -> Option<HashMap<String, [u32; 2]>> {
             = Decodable::decode(&mut decoder).ok().expect("bad CharRef");
 
         assert!((codepoints.len() >= 1) && (codepoints.len() <= 2));
-        let mut codepoint_pair = [0, 0];
-        for (i,n) in codepoints.into_iter().enumerate() {
-            codepoint_pair[i] = n;
-        }
+        let mut codepoints = codepoints.into_iter();
+        let codepoint_pair = (codepoints.next().unwrap(), codepoints.next().unwrap_or(0));
+        assert!(codepoints.next().is_none());
 
         // Slice off the initial '&'
         assert!(k.chars().next() == Some('&'));
         map.insert(k[1..].to_string(), codepoint_pair);
     }
 
     // Add every missing prefix of those keys, mapping to NULL characters.
-    map.insert("".to_string(), [0, 0]);
+    map.insert("".to_string(), (0, 0));
     let keys: Vec<String> = map.keys().map(|k| k.to_string()).collect();
     for k in keys.into_iter() {
         for n in 1 .. k.len() {
             let pfx = k[..n].to_string();
             if !map.contains_key(&pfx) {
-                map.insert(pfx, [0, 0]);
+                map.insert(pfx, (0, 0));
             }
         }
     }
@@ -111,9 +110,9 @@ pub fn expand(cx: &mut ExtCtxt, sp: Span, tt: &[TokenTree]) -> Box<MacResult+'st
     // Emit a macro invocation of the form
     //
     //     phf_map!(k => v, k => v, ...)
-    let toks: Vec<_> = map.into_iter().flat_map(|(k, [c0, c1])| {
+    let toks: Vec<_> = map.into_iter().flat_map(|(k, (c0, c1))| {
         let k = &k[..];
-        (quote_tokens!(&mut *cx, $k => [$c0, $c1],)).into_iter()
+        (quote_tokens!(&mut *cx, $k => ($c0, $c1),)).into_iter()
     }).collect();
     MacEager::expr(quote_expr!(&mut *cx, phf_map!($toks)))
 }

src/lib.rs

@@ -10,7 +10,7 @@
 #![crate_name="html5ever"]
 #![crate_type="dylib"]
 
-#![feature(plugin, box_syntax, str_char, slice_patterns, iter_arith, str_escape)]
+#![feature(plugin)]
 #![cfg_attr(test, deny(warnings))]
 #![allow(unused_parens)]
 

src/tokenizer/buffer_queue.rs

@@ -57,7 +57,7 @@ impl BufferQueue {
     /// Look at the next available character, if any.
     pub fn peek(&mut self) -> Option<char> {
         // Invariant: all buffers in the queue are non-empty.
-        self.buffers.front().map(|b| b.char_at(0))
+        self.buffers.front().map(|b| b.chars().next().unwrap())
     }
 
     /// Get the next character, if one is available.

src/tokenizer/char_ref/data.rs

@@ -24,5 +24,5 @@ pub static C1_REPLACEMENTS: [Option<char>; 32] = [
 ];
 
 // The named_entities! macro is defined in html5/macros/named_entities.rs.
-pub static NAMED_ENTITIES: Map<&'static str, [u32; 2]>
+pub static NAMED_ENTITIES: Map<&'static str, (u32, u32)>
     = named_entities!("../../../data/entities.json");

src/tokenizer/char_ref/mod.rs

@@ -57,7 +57,7 @@ pub struct CharRefTokenizer {
     hex_marker: Option<char>,
 
     name_buf_opt: Option<StrTendril>,
-    name_match: Option<&'static [u32; 2]>,
+    name_match: Option<(u32, u32)>,
     name_len: usize,
 }
 
@@ -250,8 +250,8 @@ impl CharRefTokenizer {
         self.name_buf_mut().push_char(c);
         match data::NAMED_ENTITIES.get(&self.name_buf()[..]) {
             // We have either a full match or a prefix of one.
-            Some(m) => {
-                if m[0] != 0 {
+            Some(&m) => {
+                if m.0 != 0 {
                     // We have a full match, but there might be a longer one to come.
                     self.name_match = Some(m);
                     self.name_len = self.name_buf().len();
@@ -299,7 +299,7 @@ impl CharRefTokenizer {
                 self.finish_none()
             }
 
-            Some(&[c1, c2]) => {
+            Some((c1, c2)) => {
                 // We have a complete match, but we may have consumed
                 // additional characters into self.name_buf.  Usually
                 // at least one, but several in cases like
@@ -310,14 +310,14 @@ impl CharRefTokenizer {
 
                 let name_len = self.name_len;
                 assert!(name_len > 0);
-                let last_matched = self.name_buf().char_at(name_len-1);
+                let last_matched = self.name_buf()[name_len-1..].chars().next().unwrap();
 
                 // There might not be a next character after the match, if
                 // we had a full match and then hit EOF.
                 let next_after = if name_len == self.name_buf().len() {
                     None
                 } else {
-                    Some(self.name_buf().char_at(name_len))
+                    Some(self.name_buf()[name_len..].chars().next().unwrap())
                 };
 
                 // "If the character reference is being consumed as part of an

src/tokenizer/mod.rs

@@ -213,7 +213,7 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
             return;
         }
 
-        if self.discard_bom && input.char_at(0) == '\u{feff}' {
+        if self.discard_bom && input.starts_with("\u{feff}") {
             input.pop_front(3);
         };
 
@@ -488,7 +488,7 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
     fn consume_char_ref(&mut self, addnl_allowed: Option<char>) {
         // NB: The char ref tokenizer assumes we have an additional allowed
         // character iff we're tokenizing in an attribute value.
-        self.char_ref_tokenizer = Some(box CharRefTokenizer::new(addnl_allowed));
+        self.char_ref_tokenizer = Some(Box::new(CharRefTokenizer::new(addnl_allowed)));
     }
 
     fn emit_eof(&mut self) {
@@ -1235,7 +1235,7 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
             = self.state_profile.iter().map(|(s, t)| (*s, *t)).collect();
         results.sort_by(|&(_, x), &(_, y)| y.cmp(&x));
 
-        let total: u64 = results.iter().map(|&(_, t)| t).sum();
+        let total: u64 = results.iter().map(|&(_, t)| t).fold(0, ::std::ops::Add::add);
         println!("\nTokenizer profile, in nanoseconds");
         println!("\n{:12}         total in token sink", self.time_in_sink);
         println!("\n{:12}         total in tokenizer", total);

src/tree_builder/mod.rs

@@ -415,7 +415,7 @@ impl<Handle, Sink> TokenSink
             tokenizer::EOFToken => EOFToken,
 
             tokenizer::CharacterTokens(mut x) => {
-                if !x.is_empty() && ignore_lf && x.char_at(0) == '\n' {
+                if ignore_lf && x.starts_with("\n") {
                     x.pop_front(1);
                 }
                 if x.is_empty() {

src/util/str.rs

@@ -16,7 +16,7 @@ pub fn to_escaped_string<T: fmt::Debug>(x: &T) -> String {
     let mut buf = String::new();
     let _ = buf.write_fmt(format_args!("{:?}", x));
     buf.shrink_to_fit();
-    buf.escape_default()
+    buf.chars().flat_map(|c| c.escape_default()).collect()
 }
 
 /// If `c` is an ASCII letter, return the corresponding lowercase