Auto merge of #390 - servo:warnings, r=nox

Update to 2018 edition and remove all warnings.

Author: bors-servo

html5ever/Cargo.toml

@@ -9,6 +9,7 @@ description = "High-performance browser-grade HTML5 parser"
 documentation = "https://docs.rs/html5ever"
 build = "build.rs"
 categories = [ "parser-implementations", "web-programming" ]
+edition = "2018"
 
 [lib]
 name = "html5ever"

html5ever/build.rs

@@ -7,12 +7,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#[macro_use]
-extern crate quote;
-#[macro_use]
-extern crate syn;
-extern crate proc_macro2;
-
 use std::env;
 use std::path::Path;
 use std::thread::Builder;

html5ever/examples/print-tree-actions.rs

@@ -106,7 +106,7 @@ impl TreeSink for Sink {
     fn append_based_on_parent_node(
         &mut self,
         element: &Self::Handle,
-        prev_element: &Self::Handle,
+        _prev_element: &Self::Handle,
         child: NodeOrText<Self::Handle>,
     ) {
         self.append_before_sibling(element, child);

html5ever/macros/match_token.rs

@@ -99,6 +99,9 @@ matching, by enforcing the following restrictions on its input:
     is common in the HTML5 syntax.
 */
 
+use quote::quote;
+use syn::{braced, parse_quote, Token};
+
 use proc_macro2::TokenStream;
 use quote::ToTokens;
 use std::collections::HashSet;
@@ -447,8 +450,8 @@ impl Fold for MatchTokenParser {
 
 fn make_tag_pattern(binding: &TokenStream, tag: Tag) -> TokenStream {
     let kind = match tag.kind {
-        TagKind::StartTag => quote!(::tokenizer::StartTag),
-        TagKind::EndTag => quote!(::tokenizer::EndTag),
+        TagKind::StartTag => quote!(crate::tokenizer::StartTag),
+        TagKind::EndTag => quote!(crate::tokenizer::EndTag),
     };
     let name_field = if let Some(name) = tag.name {
         let name = name.to_string();
@@ -457,6 +460,6 @@ fn make_tag_pattern(binding: &TokenStream, tag: Tag) -> TokenStream {
         quote!()
     };
     quote! {
-        ::tree_builder::types::TagToken(#binding ::tokenizer::Tag { kind: #kind, #name_field .. })
+        crate::tree_builder::types::TagToken(#binding crate::tokenizer::Tag { kind: #kind, #name_field .. })
     }
 }

html5ever/src/driver.rs

@@ -9,16 +9,16 @@
 
 //! High-level interface to the parser.
 
-use buffer_queue::BufferQueue;
-use tokenizer::{Tokenizer, TokenizerOpts, TokenizerResult};
-use tree_builder::{create_element, TreeBuilder, TreeBuilderOpts, TreeSink};
-use {Attribute, QualName};
+use crate::buffer_queue::BufferQueue;
+use crate::tokenizer::{Tokenizer, TokenizerOpts, TokenizerResult};
+use crate::tree_builder::{create_element, TreeBuilder, TreeBuilderOpts, TreeSink};
+use crate::{Attribute, QualName};
 
 use std::borrow::Cow;
 
-use tendril;
-use tendril::stream::{TendrilSink, Utf8LossyDecoder};
-use tendril::StrTendril;
+use crate::tendril;
+use crate::tendril::stream::{TendrilSink, Utf8LossyDecoder};
+use crate::tendril::StrTendril;
 
 /// All-encompassing options struct for the parser.
 #[derive(Clone, Default)]
@@ -138,9 +138,9 @@ impl<Sink: TreeSink> Parser<Sink> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use rcdom::RcDom;
-    use serialize::serialize;
-    use tendril::TendrilSink;
+    use crate::rcdom::RcDom;
+    use crate::serialize::serialize;
+    use crate::tendril::TendrilSink;
 
     #[test]
     fn from_utf8() {

html5ever/src/lib.rs

@@ -12,13 +12,6 @@
 #![cfg_attr(test, deny(warnings))]
 #![allow(unused_parens)]
 
-#[macro_use]
-extern crate log;
-#[macro_use]
-extern crate markup5ever;
-#[macro_use]
-extern crate mac;
-
 pub use driver::{parse_document, parse_fragment, ParseOpts, Parser};
 pub use markup5ever::*;
 

html5ever/src/serialize/mod.rs

@@ -7,11 +7,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use log::warn;
 pub use markup5ever::serialize::{AttrRef, Serialize, Serializer, TraversalScope};
+use markup5ever::{local_name, namespace_url, ns};
 use std::default::Default;
 use std::io::{self, Write};
 
-use {LocalName, QualName};
+use crate::{LocalName, QualName};
 
 pub fn serialize<Wr, T>(writer: Wr, node: &T, opts: SerializeOpts) -> io::Result<()>
 where
@@ -104,14 +106,14 @@ impl<Wr: Write> HtmlSerializer<Wr> {
 
     fn write_escaped(&mut self, text: &str, attr_mode: bool) -> io::Result<()> {
         for c in text.chars() {
-            try!(match c {
+            match c {
                 '&' => self.writer.write_all(b"&amp;"),
                 '\u{00A0}' => self.writer.write_all(b"&nbsp;"),
                 '"' if attr_mode => self.writer.write_all(b"&quot;"),
                 '<' if !attr_mode => self.writer.write_all(b"&lt;"),
                 '>' if !attr_mode => self.writer.write_all(b"&gt;"),
                 c => self.writer.write_fmt(format_args!("{}", c)),
-            });
+            }?;
         }
         Ok(())
     }
@@ -136,33 +138,33 @@ impl<Wr: Write> Serializer for HtmlSerializer<Wr> {
             return Ok(());
         }
 
-        try!(self.writer.write_all(b"<"));
-        try!(self.writer.write_all(tagname(&name).as_bytes()));
+        self.writer.write_all(b"<")?;
+        self.writer.write_all(tagname(&name).as_bytes())?;
         for (name, value) in attrs {
-            try!(self.writer.write_all(b" "));
+            self.writer.write_all(b" ")?;
 
             match name.ns {
                 ns!() => (),
-                ns!(xml) => try!(self.writer.write_all(b"xml:")),
+                ns!(xml) => self.writer.write_all(b"xml:")?,
                 ns!(xmlns) => {
                     if name.local != local_name!("xmlns") {
-                        try!(self.writer.write_all(b"xmlns:"));
+                        self.writer.write_all(b"xmlns:")?;
                     }
                 },
-                ns!(xlink) => try!(self.writer.write_all(b"xlink:")),
+                ns!(xlink) => self.writer.write_all(b"xlink:")?,
                 ref ns => {
                     // FIXME(#122)
                     warn!("attr with weird namespace {:?}", ns);
-                    try!(self.writer.write_all(b"unknown_namespace:"));
+                    self.writer.write_all(b"unknown_namespace:")?;
                 },
             }
 
-            try!(self.writer.write_all(name.local.as_bytes()));
-            try!(self.writer.write_all(b"=\""));
-            try!(self.write_escaped(value, true));
-            try!(self.writer.write_all(b"\""));
+            self.writer.write_all(name.local.as_bytes())?;
+            self.writer.write_all(b"=\"")?;
+            self.write_escaped(value, true)?;
+            self.writer.write_all(b"\"")?;
         }
-        try!(self.writer.write_all(b">"));
+        self.writer.write_all(b">")?;
 
         let ignore_children = name.ns == ns!(html) &&
             match name.local {
@@ -211,8 +213,8 @@ impl<Wr: Write> Serializer for HtmlSerializer<Wr> {
             return Ok(());
         }
 
-        try!(self.writer.write_all(b"</"));
-        try!(self.writer.write_all(tagname(&name).as_bytes()));
+        self.writer.write_all(b"</")?;
+        self.writer.write_all(tagname(&name).as_bytes())?;
         self.writer.write_all(b">")
     }
 
@@ -239,22 +241,22 @@ impl<Wr: Write> Serializer for HtmlSerializer<Wr> {
     }
 
     fn write_comment(&mut self, text: &str) -> io::Result<()> {
-        try!(self.writer.write_all(b"<!--"));
-        try!(self.writer.write_all(text.as_bytes()));
+        self.writer.write_all(b"<!--")?;
+        self.writer.write_all(text.as_bytes())?;
         self.writer.write_all(b"-->")
     }
 
     fn write_doctype(&mut self, name: &str) -> io::Result<()> {
-        try!(self.writer.write_all(b"<!DOCTYPE "));
-        try!(self.writer.write_all(name.as_bytes()));
+        self.writer.write_all(b"<!DOCTYPE ")?;
+        self.writer.write_all(name.as_bytes())?;
         self.writer.write_all(b">")
     }
 
     fn write_processing_instruction(&mut self, target: &str, data: &str) -> io::Result<()> {
-        try!(self.writer.write_all(b"<?"));
-        try!(self.writer.write_all(target.as_bytes()));
-        try!(self.writer.write_all(b" "));
-        try!(self.writer.write_all(data.as_bytes()));
+        self.writer.write_all(b"<?")?;
+        self.writer.write_all(target.as_bytes())?;
+        self.writer.write_all(b" ")?;
+        self.writer.write_all(data.as_bytes())?;
         self.writer.write_all(b">")
     }
 }

html5ever/src/tokenizer/char_ref/mod.rs

@@ -8,11 +8,13 @@
 // except according to those terms.
 
 use super::{TokenSink, Tokenizer};
-use buffer_queue::BufferQueue;
-use data;
-use tendril::StrTendril;
-use util::str::is_ascii_alnum;
+use crate::buffer_queue::BufferQueue;
+use crate::data;
+use crate::tendril::StrTendril;
+use crate::util::str::is_ascii_alnum;
 
+use log::debug;
+use mac::format_if;
 use std::borrow::Cow::Borrowed;
 use std::char::from_u32;
 

html5ever/src/tokenizer/interface.rs

@@ -7,11 +7,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use interface::Attribute;
+use crate::interface::Attribute;
 use std::borrow::Cow;
-use tendril::StrTendril;
-use tokenizer::states;
-use LocalName;
+use crate::tendril::StrTendril;
+use crate::tokenizer::states;
+use crate::LocalName;
 
 pub use self::TagKind::{EndTag, StartTag};
 pub use self::Token::{CharacterTokens, CommentToken, DoctypeToken, TagToken};

html5ever/src/tokenizer/mod.rs

@@ -21,16 +21,19 @@ use self::states::{Rawtext, Rcdata, ScriptData, ScriptDataEscaped};
 
 use self::char_ref::{CharRef, CharRefTokenizer};
 
-use util::str::lower_ascii_letter;
+use crate::util::str::lower_ascii_letter;
 
+use log::debug;
+use mac::{format_if, matches, _tt_as_expr_hack};
+use markup5ever::{namespace_url, ns, small_char_set};
 use std::borrow::Cow::{self, Borrowed};
 use std::collections::BTreeMap;
 use std::default::Default;
 use std::mem::replace;
 
-pub use buffer_queue::{BufferQueue, FromSet, NotFromSet, SetResult};
-use tendril::StrTendril;
-use {Attribute, LocalName, QualName, SmallCharSet};
+pub use crate::buffer_queue::{BufferQueue, FromSet, NotFromSet, SetResult};
+use crate::tendril::StrTendril;
+use crate::{Attribute, LocalName, QualName, SmallCharSet};
 
 mod char_ref;
 mod interface;
@@ -1523,7 +1526,7 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
 #[allow(non_snake_case)]
 mod test {
     use super::option_push; // private items
-    use tendril::{SliceExt, StrTendril};
+    use crate::tendril::{SliceExt, StrTendril};
 
     use super::{TokenSink, TokenSinkResult, Tokenizer, TokenizerOpts};
 
@@ -1534,7 +1537,7 @@ mod test {
     use markup5ever::buffer_queue::BufferQueue;
     use std::mem::replace;
 
-    use LocalName;
+    use crate::LocalName;
 
     // LinesMatch implements the TokenSink trait. It is used for testing to see
     // if current_line is being updated when process_token is called. The lines