Use the 2018 edition

Author: SimonSapin

Cargo.toml

@@ -10,6 +10,7 @@ readme = "README.md"
 keywords = ["css", "syntax", "parser"]
 license = "MPL-2.0"
 build = "build.rs"
+edition = "2018"
 
 exclude = ["src/css-parsing-tests/**", "src/big-data-url.css"]
 

build.rs

@@ -2,12 +2,6 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#[macro_use]
-extern crate quote;
-#[macro_use]
-extern crate syn;
-extern crate proc_macro2;
-
 #[cfg(feature = "dummy_match_byte")]
 mod codegen {
     pub fn main() {}
@@ -19,7 +13,6 @@ mod match_byte;
 
 #[cfg(not(feature = "dummy_match_byte"))]
 mod codegen {
-    use match_byte;
     use std::env;
     use std::path::Path;
     use std::thread::Builder;
@@ -35,7 +28,7 @@ mod codegen {
         let handle = Builder::new()
             .stack_size(128 * 1024 * 1024)
             .spawn(move || {
-                match_byte::expand(&input, &output);
+                crate::match_byte::expand(&input, &output);
             })
             .unwrap();
 

build/match_byte.rs

@@ -2,13 +2,14 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use quote::ToTokens;
+use quote::{quote, ToTokens};
 use std::fs::File;
 use std::io::{Read, Write};
 use std::path::Path;
 use syn;
 use syn::fold::Fold;
 use syn::parse::{Parse, ParseStream, Result};
+use syn::{parse_quote, Token};
 
 use proc_macro2::{Span, TokenStream};
 

src/lib.rs

@@ -67,56 +67,27 @@ fn parse_border_spacing(_context: &ParserContext, input: &mut Parser)
 
 #![recursion_limit = "200"] // For color::parse_color_keyword
 
-extern crate dtoa_short;
-extern crate itoa;
-#[macro_use]
-extern crate cssparser_macros;
-#[macro_use]
-extern crate matches;
-#[cfg(test)]
-extern crate difference;
-#[cfg(test)]
-extern crate encoding_rs;
-#[doc(hidden)]
-pub extern crate phf as _internal__phf;
-#[cfg(feature = "serde")]
-extern crate serde;
-#[cfg(test)]
-extern crate serde_json;
-#[cfg(feature = "heapsize")]
-#[macro_use]
-extern crate heapsize;
-extern crate smallvec;
-
-pub use cssparser_macros::*;
-
-pub use color::{
+pub use crate::color::{
     parse_color_keyword, AngleOrNumber, Color, ColorComponentParser, NumberOrPercentage, RGBA,
 };
-pub use cow_rc_str::CowRcStr;
-pub use from_bytes::{stylesheet_encoding, EncodingSupport};
-pub use nth::parse_nth;
-pub use parser::{BasicParseError, BasicParseErrorKind, ParseError, ParseErrorKind};
-pub use parser::{Delimiter, Delimiters, Parser, ParserInput, ParserState};
-pub use rules_and_declarations::parse_important;
-pub use rules_and_declarations::{parse_one_declaration, DeclarationListParser, DeclarationParser};
-pub use rules_and_declarations::{parse_one_rule, RuleListParser};
-pub use rules_and_declarations::{AtRuleParser, AtRuleType, QualifiedRuleParser};
-pub use serializer::{
-    serialize_identifier, serialize_name, serialize_string, CssStringWriter, ToCss,
-    TokenSerializationType,
-};
-pub use tokenizer::{SourceLocation, SourcePosition, Token};
-pub use unicode_range::UnicodeRange;
-
-// For macros
+pub use crate::cow_rc_str::CowRcStr;
+pub use crate::from_bytes::{stylesheet_encoding, EncodingSupport};
 #[doc(hidden)]
-pub use macros::_internal__to_lowercase;
-
-// For macros when used in this crate. Unsure how $crate works with procedural-masquerade.
-mod cssparser {
-    pub use _internal__phf;
-}
+pub use crate::macros::_internal__to_lowercase;
+pub use crate::nth::parse_nth;
+pub use crate::parser::{BasicParseError, BasicParseErrorKind, ParseError, ParseErrorKind};
+pub use crate::parser::{Delimiter, Delimiters, Parser, ParserInput, ParserState};
+pub use crate::rules_and_declarations::{parse_important, parse_one_declaration};
+pub use crate::rules_and_declarations::{parse_one_rule, RuleListParser};
+pub use crate::rules_and_declarations::{AtRuleParser, AtRuleType, QualifiedRuleParser};
+pub use crate::rules_and_declarations::{DeclarationListParser, DeclarationParser};
+pub use crate::serializer::{serialize_identifier, serialize_name, serialize_string};
+pub use crate::serializer::{CssStringWriter, ToCss, TokenSerializationType};
+pub use crate::tokenizer::{SourceLocation, SourcePosition, Token};
+pub use crate::unicode_range::UnicodeRange;
+pub use cssparser_macros::*;
+#[doc(hidden)]
+pub use phf as _internal__phf;
 
 #[macro_use]
 mod macros;

src/macros.rs

@@ -2,6 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use matches::matches;
 use std::mem::MaybeUninit;
 
 /// Expands to a `match` expression with string patterns,
@@ -40,7 +41,7 @@ macro_rules! match_ignore_ascii_case {
             // rather than expression/statement context,
             // even though the macro only expands to items.
             mod cssparser_internal {
-                cssparser_internal__assert_ascii_lowercase__max_len! {
+                $crate::cssparser_internal__assert_ascii_lowercase__max_len! {
                     match x { $( $match_body )* }
                 }
             }
@@ -90,8 +91,8 @@ macro_rules! ascii_case_insensitive_phf_map {
             mod cssparser_internal {
                 use $crate::_internal__phf::{Map, phf_map};
                 #[allow(unused)] use super::*;
-                cssparser_internal__max_len!( $( $key )+ );
-                cssparser_internal__phf_map!( $ValueType $( $key $value )+ );
+                $crate::cssparser_internal__max_len!( $( $key )+ );
+                $crate::cssparser_internal__phf_map!( $ValueType $( $key $value )+ );
             }
             cssparser_internal__to_lowercase!(input, cssparser_internal::MAX_LENGTH => lowercase);
             lowercase.and_then(|s| cssparser_internal::MAP.get(s))

src/nth.rs

@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use super::{BasicParseError, Parser, ParserInput, Token};
+use matches::matches;
 
 /// Parse the *An+B* notation, as found in the `:nth-child()` selector.
 /// The input is typically the arguments of a function,

src/parser.rs

@@ -2,11 +2,11 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use cow_rc_str::CowRcStr;
+use crate::cow_rc_str::CowRcStr;
+use crate::tokenizer::{SourceLocation, SourcePosition, Token, Tokenizer};
 use smallvec::SmallVec;
 use std::ops::BitOr;
 use std::ops::Range;
-use tokenizer::{SourceLocation, SourcePosition, Token, Tokenizer};
 
 /// A capture of the internal state of a `Parser` (including the position within the input),
 /// obtained from the `Parser::position` method.
@@ -125,7 +125,7 @@ impl<'i, T> ParseErrorKind<'i, T> {
 
 /// Extensible parse errors that can be encountered by client parsing implementations.
 #[derive(Clone, Debug, PartialEq)]
-pub struct ParseError<'i, E: 'i> {
+pub struct ParseError<'i, E> {
     /// Details of this error
     pub kind: ParseErrorKind<'i, E>,
     /// Location where this error occurred
@@ -195,7 +195,7 @@ impl<'i> ParserInput<'i> {
 /// A CSS parser that borrows its `&str` input,
 /// yields `Token`s,
 /// and keeps track of nested blocks and functions.
-pub struct Parser<'i: 't, 't> {
+pub struct Parser<'i, 't> {
     input: &'t mut ParserInput<'i>,
     /// If `Some(_)`, .parse_nested_block() can be called.
     at_start_of: Option<BlockType>,
@@ -504,7 +504,7 @@ impl<'i: 't, 't> Parser<'i, 't> {
 
     /// The old name of `try_parse`, which requires raw identifiers in the Rust 2018 edition.
     #[inline]
-    pub fn try<F, T, E>(&mut self, thing: F) -> Result<T, E>
+    pub fn r#try<F, T, E>(&mut self, thing: F) -> Result<T, E>
     where
         F: FnOnce(&mut Parser<'i, 't>) -> Result<T, E>,
     {

src/rules_and_declarations.rs

@@ -6,8 +6,8 @@
 
 use super::{BasicParseError, BasicParseErrorKind, Delimiter};
 use super::{ParseError, Parser, SourceLocation, Token};
-use cow_rc_str::CowRcStr;
-use parser::{parse_nested_block, parse_until_after, parse_until_before, ParserState};
+use crate::cow_rc_str::CowRcStr;
+use crate::parser::{parse_nested_block, parse_until_after, parse_until_before, ParserState};
 
 /// Parse `!important`.
 ///
@@ -221,15 +221,15 @@ pub trait QualifiedRuleParser<'i> {
 }
 
 /// Provides an iterator for declaration list parsing.
-pub struct DeclarationListParser<'i: 't, 't: 'a, 'a, P> {
+pub struct DeclarationListParser<'i, 't, 'a, P> {
     /// The input given to `DeclarationListParser::new`
     pub input: &'a mut Parser<'i, 't>,
 
     /// The parser given to `DeclarationListParser::new`
     pub parser: P,
 }
 
-impl<'i: 't, 't: 'a, 'a, I, P, E: 'i> DeclarationListParser<'i, 't, 'a, P>
+impl<'i, 't, 'a, I, P, E: 'i> DeclarationListParser<'i, 't, 'a, P>
 where
     P: DeclarationParser<'i, Declaration = I, Error = E> + AtRuleParser<'i, AtRule = I, Error = E>,
 {
@@ -257,7 +257,7 @@ where
 
 /// `DeclarationListParser` is an iterator that yields `Ok(_)` for a valid declaration or at-rule
 /// or `Err(())` for an invalid one.
-impl<'i: 't, 't: 'a, 'a, I, P, E: 'i> Iterator for DeclarationListParser<'i, 't, 'a, P>
+impl<'i, 't, 'a, I, P, E: 'i> Iterator for DeclarationListParser<'i, 't, 'a, P>
 where
     P: DeclarationParser<'i, Declaration = I, Error = E> + AtRuleParser<'i, AtRule = I, Error = E>,
 {
@@ -306,7 +306,7 @@ where
 }
 
 /// Provides an iterator for rule list parsing.
-pub struct RuleListParser<'i: 't, 't: 'a, 'a, P> {
+pub struct RuleListParser<'i, 't, 'a, P> {
     /// The input given to `RuleListParser::new`
     pub input: &'a mut Parser<'i, 't>,
 
@@ -317,7 +317,7 @@ pub struct RuleListParser<'i: 't, 't: 'a, 'a, P> {
     any_rule_so_far: bool,
 }
 
-impl<'i: 't, 't: 'a, 'a, R, P, E: 'i> RuleListParser<'i, 't, 'a, P>
+impl<'i, 't, 'a, R, P, E: 'i> RuleListParser<'i, 't, 'a, P>
 where
     P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E>
         + AtRuleParser<'i, AtRule = R, Error = E>,
@@ -358,7 +358,7 @@ where
 }
 
 /// `RuleListParser` is an iterator that yields `Ok(_)` for a rule or `Err(())` for an invalid one.
-impl<'i: 't, 't: 'a, 'a, R, P, E: 'i> Iterator for RuleListParser<'i, 't, 'a, P>
+impl<'i, 't, 'a, R, P, E: 'i> Iterator for RuleListParser<'i, 't, 'a, P>
 where
     P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E>
         + AtRuleParser<'i, AtRule = R, Error = E>,
@@ -467,7 +467,7 @@ where
     })
 }
 
-fn parse_at_rule<'i: 't, 't, P, E>(
+fn parse_at_rule<'i, 't, P, E>(
     start: &ParserState,
     name: CowRcStr<'i>,
     input: &mut Parser<'i, 't>,

src/serializer.rs

@@ -4,6 +4,7 @@
 
 use dtoa_short::{self, Notation};
 use itoa;
+use matches::matches;
 use std::fmt::{self, Write};
 use std::io;
 use std::str;
@@ -293,7 +294,7 @@ where
 ///     Ok(())
 /// }
 /// ```
-pub struct CssStringWriter<'a, W: 'a> {
+pub struct CssStringWriter<'a, W> {
     inner: &'a mut W,
 }
 

src/size_of_tests.rs

@@ -2,9 +2,9 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use cow_rc_str::CowRcStr;
+use crate::cow_rc_str::CowRcStr;
+use crate::tokenizer::Token;
 use std::borrow::Cow;
-use tokenizer::Token;
 
 macro_rules! size_of_test {
     ($testname: ident, $t: ty, $expected_size: expr) => {
@@ -41,19 +41,19 @@ size_of_test!(token, Token, 32);
 size_of_test!(std_cow_str, Cow<'static, str>, 32);
 size_of_test!(cow_rc_str, CowRcStr, 16);
 
-size_of_test!(tokenizer, ::tokenizer::Tokenizer, 72);
+size_of_test!(tokenizer, crate::tokenizer::Tokenizer, 72);
 size_of_test!(
     parser_input,
-    ::parser::ParserInput,
+    crate::parser::ParserInput,
     if cfg!(rustc_has_pr45225) { 136 } else { 144 }
 );
-size_of_test!(parser, ::parser::Parser, 16);
-size_of_test!(source_position, ::SourcePosition, 8);
-size_of_test!(parser_state, ::ParserState, 24);
+size_of_test!(parser, crate::parser::Parser, 16);
+size_of_test!(source_position, crate::SourcePosition, 8);
+size_of_test!(parser_state, crate::ParserState, 24);
 
-size_of_test!(basic_parse_error, ::BasicParseError, 48);
+size_of_test!(basic_parse_error, crate::BasicParseError, 48);
 size_of_test!(
     parse_error_lower_bound,
-    ::ParseError<()>,
+    crate::ParseError<()>,
     if cfg!(rustc_has_pr45225) { 48 } else { 56 }
 );

src/tests.rs

@@ -6,6 +6,7 @@
 extern crate test;
 
 use encoding_rs;
+use matches::matches;
 use serde_json::{self, json, Map, Value};
 
 #[cfg(feature = "bench")]
@@ -468,10 +469,11 @@ fn serializer(preserve_comments: bool) {
                         _ => None,
                     };
                     if let Some(closing_token) = closing_token {
-                        let result: Result<_, ParseError<()>> = input.parse_nested_block(|input| {
-                            write_to(previous_token, input, string, preserve_comments);
-                            Ok(())
-                        });
+                        let result: Result<_, ParseError<()>> =
+                            input.parse_nested_block(|input| {
+                                write_to(previous_token, input, string, preserve_comments);
+                                Ok(())
+                            });
                         result.unwrap();
                         closing_token.to_css(string).unwrap();
                     }

src/tokenizer.rs

@@ -4,14 +4,14 @@
 
 // https://drafts.csswg.org/css-syntax/#tokenization
 
+use self::Token::*;
+use crate::cow_rc_str::CowRcStr;
+use crate::parser::ParserState;
+use matches::matches;
 use std::char;
 use std::i32;
 use std::ops::Range;
 
-use self::Token::*;
-use cow_rc_str::CowRcStr;
-use parser::ParserState;
-
 /// One of the pieces the CSS input is broken into.
 ///
 /// Some components use `Cow` in order to borrow from the original input string

src/unicode_range.rs

@@ -4,10 +4,10 @@
 
 //! https://drafts.csswg.org/css-syntax/#urange
 
+use crate::tokenizer::Token;
+use crate::{BasicParseError, Parser, ToCss};
 use std::char;
 use std::fmt;
-use tokenizer::Token;
-use {BasicParseError, Parser, ToCss};
 
 /// One contiguous range of code points.
 ///