Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
SUSE:SLE-12-SP2:GA
MozillaFirefox.12890
mozilla-bmo1585099.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File mozilla-bmo1585099.patch of Package MozillaFirefox.12890
diff --git a/Cargo.lock b/Cargo.lock --- a/Cargo.lock +++ b/Cargo.lock @@ -736,7 +736,7 @@ [[package]] name = "cssparser" -version = "0.25.3" +version = "0.25.5" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cssparser-macros 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1204,7 +1204,7 @@ version = "0.0.1" dependencies = [ "atomic_refcell 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", - "cssparser 0.25.3 (registry+https://github.com/rust-lang/crates.io-index)", + "cssparser 0.25.5 (registry+https://github.com/rust-lang/crates.io-index)", "cstr 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)", "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1681,7 +1681,7 @@ version = "0.0.1" dependencies = [ "app_units 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)", - "cssparser 0.25.3 (registry+https://github.com/rust-lang/crates.io-index)", + "cssparser 0.25.5 (registry+https://github.com/rust-lang/crates.io-index)", "euclid 0.19.5 (registry+https://github.com/rust-lang/crates.io-index)", "hashglobe 0.1.0", "selectors 0.21.0", @@ -2667,7 +2667,7 @@ version = "0.21.0" dependencies = [ "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", - "cssparser 0.25.3 (registry+https://github.com/rust-lang/crates.io-index)", + "cssparser 0.25.5 (registry+https://github.com/rust-lang/crates.io-index)", "derive_more 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)", "fxhash 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)", "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)", @@ -2884,7 +2884,7 @@ "bindgen 0.49.1 (registry+https://github.com/rust-lang/crates.io-index)", "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)", - "cssparser 0.25.3 (registry+https://github.com/rust-lang/crates.io-index)", + "cssparser 0.25.5 (registry+https://github.com/rust-lang/crates.io-index)", "derive_more 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)", "euclid 0.19.5 (registry+https://github.com/rust-lang/crates.io-index)", "fallible 0.0.1", @@ -2946,7 +2946,7 @@ dependencies = [ "app_units 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)", "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", - "cssparser 0.25.3 (registry+https://github.com/rust-lang/crates.io-index)", + "cssparser 0.25.5 (registry+https://github.com/rust-lang/crates.io-index)", "euclid 0.19.5 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)", "malloc_size_of 0.0.1", @@ -2962,7 +2962,7 @@ version = "0.0.1" dependencies = [ "atomic_refcell 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", - "cssparser 0.25.3 (registry+https://github.com/rust-lang/crates.io-index)", + "cssparser 0.25.5 (registry+https://github.com/rust-lang/crates.io-index)", "cstr 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", "env_logger 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)", "geckoservo 0.0.1", @@ -3137,7 +3137,7 @@ name = "to_shmem" version = "0.0.1" dependencies = [ - "cssparser 0.25.3 (registry+https://github.com/rust-lang/crates.io-index)", + "cssparser 0.25.5 (registry+https://github.com/rust-lang/crates.io-index)", "servo_arc 0.1.1", "smallbitvec 2.3.0 (registry+https://github.com/rust-lang/crates.io-index)", "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)", @@ -3807,7 +3807,7 @@ "checksum crossbeam-utils 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "2760899e32a1d58d5abb31129f8fae5de75220bc2176e77ff7c627ae45c918d9" "checksum crossbeam-utils 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d636a8b3bcc1b409d7ffd3facef8f21dcb4009626adbd0c5e6c4305c07253c7b" "checksum crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "41ee4864f4797060e52044376f7d107429ce1fb43460021b126424b7180ee21a" -"checksum cssparser 0.25.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ba1ab4e1814be64bf6b6064ff532db0e34087f11b37706d6c96a21d32478761d" +"checksum cssparser 0.25.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e06795910fc2f585a75bdc9690fbcc51e83519f07b6eb981db43944643c04933" "checksum cssparser-macros 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f3a5383ae18dbfdeb569ed62019f5bddb2a95cd2d3833313c475a0d014777805" "checksum cstr 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b6557bdb1dc9647eae1cf7f5601b14cd45fc3c7ccf2df618387416fe542da6ea" "checksum cstr-macros 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0472c17c83d3ec1af32fb6ee2b3ad56ae0b6e69355d63d1d30602055c34324a8" diff --git a/third_party/rust/cssparser/.cargo-checksum.json b/third_party/rust/cssparser/.cargo-checksum.json --- a/third_party/rust/cssparser/.cargo-checksum.json +++ b/third_party/rust/cssparser/.cargo-checksum.json @@ -1 +1 @@ -{"files":{"Cargo.toml":"150d450e43bcb9e523941408be883997ecffce7ff5f224329372edfe56334a55","LICENSE":"fab3dd6bdab226f1c08630b1dd917e11fcb4ec5e1e020e2c16f83a0a13863e85","README.md":"b9d6c5dc56ccc267db9e0e2389061dc2524daefa4baed88b36c98efc7a51c2a9","build.rs":"310d6d7b1931ff783a8aa1a4c6baee87b4c9130c858e4694ef69cc96df5e38dc","build/match_byte.rs":"6f7ec4235c9f2da403ea0be9339661ecd8e1f5e1c788cf88a41448b1080c59b8","docs/404.html":"025861f76f8d1f6d67c20ab624c6e418f4f824385e2dd8ad8732c4ea563c6a2e","docs/index.html":"025861f76f8d1f6d67c20ab624c6e418f4f824385e2dd8ad8732c4ea563c6a2e","src/color.rs":"43f996fbd8da54bd8ffa870f5e3610e5ba6e61543f92a129fa6c850e9b10db7e","src/cow_rc_str.rs":"541216f8ef74ee3cc5cbbc1347e5f32ed66588c401851c9a7d68b867aede1de0","src/from_bytes.rs":"331fe63af2123ae3675b61928a69461b5ac77799fff3ce9978c55cf2c558f4ff","src/lib.rs":"a474ee88ef8f73fcb7b7272d426e5eafb4ad10d104797a5a188d1676c8180972","src/macros.rs":"adb9773c157890381556ea83d7942dcc676f99eea71abbb6afeffee1e3f28960","src/nth.rs":"5c70fb542d1376cddab69922eeb4c05e4fcf8f413f27563a2af50f72a47c8f8c","src/parser.rs":"22067562160a1294fa92779b66c25cbccf259a2ef7dcf687c791fecdd020ce7f","src/rules_and_declarations.rs":"622ce07c117a511d40ce595602d4f4730659a59273388f28553d1a2b0fac92ce","src/serializer.rs":"3e2dfc60613f885cb6f99abfc854fde2a1e00de507431bd2e51178b61abfd69b","src/size_of_tests.rs":"385a0d77fbd6f86cb8013fd8d7541886980876a9da1da714bf175954c0e726cf","src/tests.rs":"9d08b3943d453664e01d58e307f79345e240f9f9ce6f8d36a842eff37155563e","src/tokenizer.rs":"adcf5811955e8df57a519e3d1e44fe3afeb5afeb1076daeb8d36fed1abcf1327","src/unicode_range.rs":"ae159d2ebe4123a6666e18dc0362f89b475240a6b7ed5fb6fe21b9e7a4139da8"},"package":"ba1ab4e1814be64bf6b6064ff532db0e34087f11b37706d6c96a21d32478761d"} \ No newline at end of file +{"files":{"Cargo.toml":"26e11f3e55baf0de8784dc3ec88771411ceae587c64e162fed3939b87c3cc591","LICENSE":"fab3dd6bdab226f1c08630b1dd917e11fcb4ec5e1e020e2c16f83a0a13863e85","README.md":"b9d6c5dc56ccc267db9e0e2389061dc2524daefa4baed88b36c98efc7a51c2a9","build.rs":"08e4a99d5184b2f22ab93bc0a024fec18dbd8fd38b9db638f19d4defede858ee","build/match_byte.rs":"e8537833ff1599a1bdbd0167f6295af7bd21e42024f32b982af32d58c156685c","docs/404.html":"025861f76f8d1f6d67c20ab624c6e418f4f824385e2dd8ad8732c4ea563c6a2e","docs/index.html":"025861f76f8d1f6d67c20ab624c6e418f4f824385e2dd8ad8732c4ea563c6a2e","src/color.rs":"8d3017ba8d644172908bd80d35e9be1081db477d2e0b0ea13971e29a466d451f","src/cow_rc_str.rs":"89b5dff5cf80eef3fcff0c11799e54a978d02d8b8963a621fbb999d35e7c03a3","src/from_bytes.rs":"b1cf15c4e975523fef46b575598737a39f3c63e5ce0b2bfd6ec627c69c6ea54a","src/lib.rs":"98b28ca7c72b8d20b3d76ae5b841be87bcadfc89e433ecc95fcf37aa15731442","src/macros.rs":"a50a0a7afa43e099dc008e54956e4c1fdfba2e9795d006b22e9eb45065fed61e","src/nth.rs":"a9d5fa0bd2c3ae7c48c851b9f5508ebdb07affdf5d0737bb8d85a7befab2ef9c","src/parser.rs":"fe2eb2be084923bf362de4b95c029beb21f172ad972a6452c400f640b43a583e","src/rules_and_declarations.rs":"712a5e893169e715bbcd18aac87a18ae728dc6bb922e79b237d34ce7a4548fcf","src/serializer.rs":"151305364cb1f20ea2dc0b3ebfbb77937e616ef4441d5dd3c9abda232f79a7af","src/size_of_tests.rs":"a628cacc876f240ac1bb9e287cdae293bffc4b86d45d9307e4fc2f822e8f3e84","src/tests.rs":"bf97071b691c0b0c932af5813e876142ce707ba57774742dbe60889b1dc54069","src/tokenizer.rs":"0450c38d140382161408a8fca5aac343f5a9405603234095dccd93f680831cb7","src/unicode_range.rs":"c4655c817db0dabb1d55669ac61a56ecf7f6a6c4353cf5b539b13bea6511c3dd"},"package":"e06795910fc2f585a75bdc9690fbcc51e83519f07b6eb981db43944643c04933"} \ No newline at end of file diff --git a/third_party/rust/cssparser/Cargo.toml b/third_party/rust/cssparser/Cargo.toml --- a/third_party/rust/cssparser/Cargo.toml +++ b/third_party/rust/cssparser/Cargo.toml @@ -12,7 +12,7 @@ [package] name = "cssparser" -version = "0.25.3" +version = "0.25.5" authors = ["Simon Sapin <simon.sapin@exyr.org>"] build = "build.rs" exclude = ["src/css-parsing-tests/**", "src/big-data-url.css"] diff --git a/third_party/rust/cssparser/build.rs b/third_party/rust/cssparser/build.rs --- a/third_party/rust/cssparser/build.rs +++ b/third_party/rust/cssparser/build.rs @@ -33,9 +33,12 @@ println!("cargo:rerun-if-changed={}", input.display()); // We have stack overflows on Servo's CI. - let handle = Builder::new().stack_size(128 * 1024 * 1024).spawn(move || { - match_byte::expand(&input, &output); - }).unwrap(); + let handle = Builder::new() + .stack_size(128 * 1024 * 1024) + .spawn(move || { + match_byte::expand(&input, &output); + }) + .unwrap(); handle.join().unwrap(); } diff --git a/third_party/rust/cssparser/build/match_byte.rs b/third_party/rust/cssparser/build/match_byte.rs --- a/third_party/rust/cssparser/build/match_byte.rs +++ b/third_party/rust/cssparser/build/match_byte.rs @@ -12,18 +12,27 @@ use proc_macro2::{Span, TokenStream}; -struct MatchByteParser { -} +struct MatchByteParser {} pub fn expand(from: &Path, to: &Path) { let mut source = String::new(); - File::open(from).unwrap().read_to_string(&mut source).unwrap(); + File::open(from) + .unwrap() + .read_to_string(&mut source) + .unwrap(); let ast = syn::parse_file(&source).expect("Parsing rules.rs module"); let mut m = MatchByteParser {}; let ast = m.fold_file(ast); - let code = ast.into_token_stream().to_string().replace("{ ", "{\n").replace(" }", "\n}"); - File::create(to).unwrap().write_all(code.as_bytes()).unwrap(); + let code = ast + .into_token_stream() + .to_string() + .replace("{ ", "{\n") + .replace(" }", "\n}"); + File::create(to) + .unwrap() + .write_all(code.as_bytes()) + .unwrap(); } struct MatchByte { @@ -45,7 +54,7 @@ arms.push(input.call(syn::Arm::parse)?); } arms - } + }, }) } } @@ -55,15 +64,13 @@ syn::Expr::Lit(syn::ExprLit { ref lit, .. }) => { if let syn::Lit::Byte(ref byte) = *lit { byte.value() - } - else { + } else { panic!("Found a pattern that wasn't a byte") } - }, + } _ => unreachable!(), } } - /// Expand a TokenStream corresponding to the `match_byte` macro. /// @@ -93,12 +100,12 @@ for pat in &arm.pats { match pat { - &syn::Pat::Lit(syn::PatLit{ref expr}) => { + &syn::Pat::Lit(syn::PatLit { ref expr }) => { let value = get_byte_from_expr_lit(expr); if table[value as usize] == 0 { table[value as usize] = case_id as u8; } - }, + } &syn::Pat::Range(syn::PatRange { ref lo, ref hi, .. }) => { let lo = get_byte_from_expr_lit(lo); let hi = get_byte_from_expr_lit(hi); @@ -110,14 +117,14 @@ if table[hi as usize] == 0 { table[hi as usize] = case_id as u8; } - }, + } &syn::Pat::Wild(_) => { for byte in table.iter_mut() { if *byte == 0 { *byte = case_id as u8; } } - }, + } &syn::Pat::Ident(syn::PatIdent { ref ident, .. }) => { assert_eq!(wildcard, None); wildcard = Some(ident); @@ -126,7 +133,7 @@ *byte = case_id as u8; } } - }, + } _ => { panic!("Unexpected pattern: {:?}. Buggy code ?", pat); } @@ -159,11 +166,14 @@ impl Fold for MatchByteParser { fn fold_stmt(&mut self, stmt: syn::Stmt) -> syn::Stmt { match stmt { - syn::Stmt::Item(syn::Item::Macro(syn::ItemMacro{ ref mac, .. })) => { + syn::Stmt::Item(syn::Item::Macro(syn::ItemMacro { ref mac, .. })) => { if mac.path == parse_quote!(match_byte) { - return syn::fold::fold_stmt(self, syn::Stmt::Expr(expand_match_byte(&mac.tts))) + return syn::fold::fold_stmt( + self, + syn::Stmt::Expr(expand_match_byte(&mac.tts)), + ); } - }, + } _ => {} } @@ -172,11 +182,11 @@ fn fold_expr(&mut self, expr: syn::Expr) -> syn::Expr { match expr { - syn::Expr::Macro(syn::ExprMacro{ ref mac, .. }) => { + syn::Expr::Macro(syn::ExprMacro { ref mac, .. }) => { if mac.path == parse_quote!(match_byte) { - return syn::fold::fold_expr(self, expand_match_byte(&mac.tts)) + return syn::fold::fold_expr(self, expand_match_byte(&mac.tts)); } - }, + } _ => {} } diff --git a/third_party/rust/cssparser/src/color.rs b/third_party/rust/cssparser/src/color.rs --- a/third_party/rust/cssparser/src/color.rs +++ b/third_party/rust/cssparser/src/color.rs @@ -2,10 +2,10 @@ * 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 std::f32::consts::PI; use std::fmt; -use std::f32::consts::PI; - -use super::{Token, Parser, ToCss, ParseError, BasicParseError}; + +use super::{BasicParseError, ParseError, Parser, ToCss, Token}; #[cfg(feature = "serde")] use serde::{Deserialize, Deserializer, Serialize, Serializer}; @@ -47,7 +47,12 @@ /// Same thing, but with `u8` values instead of floats in the 0 to 1 range. #[inline] pub fn new(red: u8, green: u8, blue: u8, alpha: u8) -> Self { - RGBA { red: red, green: green, blue: blue, alpha: alpha } + RGBA { + red: red, + green: green, + blue: blue, + alpha: alpha, + } } /// Returns the red channel in a floating point number form, from 0 to 1. @@ -78,7 +83,8 @@ #[cfg(feature = "serde")] impl Serialize for RGBA { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> - where S: Serializer + where + S: Serializer, { (self.red, self.green, self.blue, self.alpha).serialize(serializer) } @@ -87,7 +93,8 @@ #[cfg(feature = "serde")] impl<'de> Deserialize<'de> for RGBA { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> - where D: Deserializer<'de> + where + D: Deserializer<'de>, { let (r, g, b, a) = Deserialize::deserialize(deserializer)?; Ok(RGBA::new(r, g, b, a)) @@ -99,7 +106,8 @@ impl ToCss for RGBA { fn to_css<W>(&self, dest: &mut W) -> fmt::Result - where W: fmt::Write, + where + W: fmt::Write, { let serialize_alpha = self.alpha != 255; @@ -137,7 +145,10 @@ known_heap_size!(0, Color); impl ToCss for Color { - fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { match *self { Color::CurrentColor => dest.write_str("currentcolor"), Color::RGBA(ref rgba) => rgba.to_css(dest), @@ -210,7 +221,9 @@ let location = input.current_source_location(); Ok(match *input.next()? { Token::Number { value, .. } => AngleOrNumber::Number { value }, - Token::Dimension { value: v, ref unit, .. } => { + Token::Dimension { + value: v, ref unit, .. + } => { let degrees = match_ignore_ascii_case! { &*unit, "deg" => v, "grad" => v * 360. / 400., @@ -221,7 +234,7 @@ AngleOrNumber::Angle { degrees } } - ref t => return Err(location.new_unexpected_token_error(t.clone())) + ref t => return Err(location.new_unexpected_token_error(t.clone())), }) } @@ -252,7 +265,7 @@ Ok(match *input.next()? { Token::Number { value, .. } => NumberOrPercentage::Number { value }, Token::Percentage { unit_value, .. } => NumberOrPercentage::Percentage { unit_value }, - ref t => return Err(location.new_unexpected_token_error(t.clone())) + ref t => return Err(location.new_unexpected_token_error(t.clone())), }) } } @@ -279,21 +292,20 @@ match token { Token::Hash(ref value) | Token::IDHash(ref value) => { Color::parse_hash(value.as_bytes()) - }, + } Token::Ident(ref value) => parse_color_keyword(&*value), Token::Function(ref name) => { return input.parse_nested_block(|arguments| { parse_color_function(component_parser, &*name, arguments) }) } - _ => Err(()) - }.map_err(|()| location.new_unexpected_token_error(token)) + _ => Err(()), + } + .map_err(|()| location.new_unexpected_token_error(token)) } /// Parse a <color> value, per CSS Color Module Level 3. - pub fn parse<'i, 't>( - input: &mut Parser<'i, 't>, - ) -> Result<Color, BasicParseError<'i>> { + pub fn parse<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Color, BasicParseError<'i>> { let component_parser = DefaultComponentParser; Self::parse_with(&component_parser, input).map_err(ParseError::basic) } @@ -306,25 +318,25 @@ from_hex(value[0])? * 16 + from_hex(value[1])?, from_hex(value[2])? * 16 + from_hex(value[3])?, from_hex(value[4])? * 16 + from_hex(value[5])?, - from_hex(value[6])? * 16 + from_hex(value[7])?), - ), + from_hex(value[6])? * 16 + from_hex(value[7])?, + )), 6 => Ok(rgb( from_hex(value[0])? * 16 + from_hex(value[1])?, from_hex(value[2])? * 16 + from_hex(value[3])?, - from_hex(value[4])? * 16 + from_hex(value[5])?), - ), + from_hex(value[4])? * 16 + from_hex(value[5])?, + )), 4 => Ok(rgba( from_hex(value[0])? * 17, from_hex(value[1])? * 17, from_hex(value[2])? * 17, - from_hex(value[3])? * 17), - ), + from_hex(value[3])? * 17, + )), 3 => Ok(rgb( from_hex(value[0])? * 17, from_hex(value[1])? * 17, - from_hex(value[2])? * 17), - ), - _ => Err(()) + from_hex(value[2])? * 17, + )), + _ => Err(()), } } } @@ -338,7 +350,6 @@ fn rgba(red: u8, green: u8, blue: u8, alpha: u8) -> Color { Color::RGBA(RGBA::new(red, green, blue, alpha)) } - /// Return the named color with the given name. /// @@ -355,7 +366,7 @@ blue: $blue, alpha: 255, }) - } + }; } ascii_case_insensitive_phf_map! { keyword -> Color = { @@ -516,14 +527,13 @@ keyword(ident).cloned().ok_or(()) } - #[inline] fn from_hex(c: u8) -> Result<u8, ()> { match c { - b'0' ... b'9' => Ok(c - b'0'), - b'a' ... b'f' => Ok(c - b'a' + 10), - b'A' ... b'F' => Ok(c - b'A' + 10), - _ => Err(()) + b'0'...b'9' => Ok(c - b'0'), + b'a'...b'f' => Ok(c - b'a' + 10), + b'A'...b'F' => Ok(c - b'A' + 10), + _ => Err(()), } } @@ -553,7 +563,7 @@ fn parse_color_function<'i, 't, ComponentParser>( component_parser: &ComponentParser, name: &str, - arguments: &mut Parser<'i, 't> + arguments: &mut Parser<'i, 't>, ) -> Result<Color, ParseError<'i, ComponentParser::Error>> where ComponentParser: ColorComponentParser<'i>, @@ -570,7 +580,11 @@ } else { arguments.expect_delim('/')?; }; - clamp_unit_f32(component_parser.parse_number_or_percentage(arguments)?.unit_value()) + clamp_unit_f32( + component_parser + .parse_number_or_percentage(arguments)? + .unit_value(), + ) } else { 255 }; @@ -579,11 +593,10 @@ Ok(rgba(red, green, blue, alpha)) } - #[inline] fn parse_rgb_components_rgb<'i, 't, ComponentParser>( component_parser: &ComponentParser, - arguments: &mut Parser<'i, 't> + arguments: &mut Parser<'i, 't>, ) -> Result<(u8, u8, u8, bool), ParseError<'i, ComponentParser::Error>> where ComponentParser: ColorComponentParser<'i>, @@ -591,15 +604,11 @@ // Either integers or percentages, but all the same type. // https://drafts.csswg.org/css-color/#rgb-functions let (red, is_number) = match component_parser.parse_number_or_percentage(arguments)? { - NumberOrPercentage::Number { value } => { - (clamp_floor_256_f32(value), true) - } - NumberOrPercentage::Percentage { unit_value } => { - (clamp_unit_f32(unit_value), false) - } + NumberOrPercentage::Number { value } => (clamp_floor_256_f32(value), true), + NumberOrPercentage::Percentage { unit_value } => (clamp_unit_f32(unit_value), false), }; - let uses_commas = arguments.try(|i| i.expect_comma()).is_ok(); + let uses_commas = arguments.try_parse(|i| i.expect_comma()).is_ok(); let green; let blue; @@ -623,7 +632,7 @@ #[inline] fn parse_rgb_components_hsl<'i, 't, ComponentParser>( component_parser: &ComponentParser, - arguments: &mut Parser<'i, 't> + arguments: &mut Parser<'i, 't>, ) -> Result<(u8, u8, u8, bool), ParseError<'i, ComponentParser::Error>> where ComponentParser: ColorComponentParser<'i>, @@ -638,7 +647,7 @@ // Saturation and lightness are clamped to 0% ... 100% // https://drafts.csswg.org/css-color/#the-hsl-notation - let uses_commas = arguments.try(|i| i.expect_comma()).is_ok(); + let uses_commas = arguments.try_parse(|i| i.expect_comma()).is_ok(); let saturation = component_parser.parse_percentage(arguments)?; let saturation = saturation.max(0.).min(1.); @@ -653,16 +662,28 @@ // https://drafts.csswg.org/css-color/#hsl-color // except with h pre-multiplied by 3, to avoid some rounding errors. fn hue_to_rgb(m1: f32, m2: f32, mut h3: f32) -> f32 { - if h3 < 0. { h3 += 3. } - if h3 > 3. { h3 -= 3. } - - if h3 * 2. < 1. { m1 + (m2 - m1) * h3 * 2. } - else if h3 * 2. < 3. { m2 } - else if h3 < 2. { m1 + (m2 - m1) * (2. - h3) * 2. } - else { m1 } - } - let m2 = if lightness <= 0.5 { lightness * (saturation + 1.) } - else { lightness + saturation - lightness * saturation }; + if h3 < 0. { + h3 += 3. + } + if h3 > 3. { + h3 -= 3. + } + + if h3 * 2. < 1. { + m1 + (m2 - m1) * h3 * 2. + } else if h3 * 2. < 3. { + m2 + } else if h3 < 2. { + m1 + (m2 - m1) * (2. - h3) * 2. + } else { + m1 + } + } + let m2 = if lightness <= 0.5 { + lightness * (saturation + 1.) + } else { + lightness + saturation - lightness * saturation + }; let m1 = lightness * 2. - m2; let hue_times_3 = hue * 3.; let red = clamp_unit_f32(hue_to_rgb(m1, m2, hue_times_3 + 1.)); diff --git a/third_party/rust/cssparser/src/cow_rc_str.rs b/third_party/rust/cssparser/src/cow_rc_str.rs --- a/third_party/rust/cssparser/src/cow_rc_str.rs +++ b/third_party/rust/cssparser/src/cow_rc_str.rs @@ -103,16 +103,12 @@ fn clone(&self) -> Self { match self.unpack() { Err(ptr) => { - let rc = unsafe { - Rc::from_raw(ptr) - }; + let rc = unsafe { Rc::from_raw(ptr) }; let new_rc = rc.clone(); - mem::forget(rc); // Don’t actually take ownership of this strong reference + mem::forget(rc); // Don’t actually take ownership of this strong reference CowRcStr::from_rc(new_rc) } - Ok(_) => { - CowRcStr { ..*self } - } + Ok(_) => CowRcStr { ..*self }, } } } @@ -121,9 +117,7 @@ #[inline] fn drop(&mut self) { if let Err(ptr) = self.unpack() { - mem::drop(unsafe { - Rc::from_raw(ptr) - }) + mem::drop(unsafe { Rc::from_raw(ptr) }) } } } @@ -133,9 +127,7 @@ #[inline] fn deref(&self) -> &str { - self.unpack().unwrap_or_else(|ptr| unsafe { - &**ptr - }) + self.unpack().unwrap_or_else(|ptr| unsafe { &**ptr }) } } diff --git a/third_party/rust/cssparser/src/from_bytes.rs b/third_party/rust/cssparser/src/from_bytes.rs --- a/third_party/rust/cssparser/src/from_bytes.rs +++ b/third_party/rust/cssparser/src/from_bytes.rs @@ -17,7 +17,6 @@ fn is_utf16_be_or_le(encoding: &Self::Encoding) -> bool; } - /// Determine the character encoding of a CSS stylesheet. /// /// This is based on the presence of a BOM (Byte Order Mark), an `@charset` rule, and @@ -30,31 +29,32 @@ /// (https://drafts.csswg.org/css-syntax/#environment-encoding), if any. /// /// Returns the encoding to use. -pub fn stylesheet_encoding<E>(css: &[u8], protocol_encoding_label: Option<&[u8]>, - environment_encoding: Option<E::Encoding>) - -> E::Encoding - where E: EncodingSupport { +pub fn stylesheet_encoding<E>( + css: &[u8], + protocol_encoding_label: Option<&[u8]>, + environment_encoding: Option<E::Encoding>, +) -> E::Encoding +where + E: EncodingSupport, +{ // https://drafts.csswg.org/css-syntax/#the-input-byte-stream - match protocol_encoding_label { - None => (), - Some(label) => match E::from_label(label) { - None => (), - Some(protocol_encoding) => return protocol_encoding - } - } + if let Some(label) = protocol_encoding_label { + if let Some(protocol_encoding) = E::from_label(label) { + return protocol_encoding; + }; + }; + let prefix = b"@charset \""; if css.starts_with(prefix) { let rest = &css[prefix.len()..]; - match rest.iter().position(|&b| b == b'"') { - None => (), - Some(label_length) => if rest[label_length..].starts_with(b"\";") { + if let Some(label_length) = rest.iter().position(|&b| b == b'"') { + if rest[label_length..].starts_with(b"\";") { let label = &rest[..label_length]; - match E::from_label(label) { - None => (), - Some(charset_encoding) => if E::is_utf16_be_or_le(&charset_encoding) { - return E::utf8() + if let Some(charset_encoding) = E::from_label(label) { + if E::is_utf16_be_or_le(&charset_encoding) { + return E::utf8(); } else { - return charset_encoding + return charset_encoding; } } } diff --git a/third_party/rust/cssparser/src/lib.rs b/third_party/rust/cssparser/src/lib.rs --- a/third_party/rust/cssparser/src/lib.rs +++ b/third_party/rust/cssparser/src/lib.rs @@ -4,7 +4,6 @@ #![crate_name = "cssparser"] #![crate_type = "rlib"] - #![cfg_attr(feature = "bench", feature(test))] #![deny(missing_docs)] @@ -32,7 +31,7 @@ * Any `Err(())` return value must be propagated. This happens by definition for tail calls, - and can otherwise be done with the `try!` macro. + and can otherwise be done with the `?` operator. * Or the call must be wrapped in a `Parser::try` call. `try` takes a closure that takes a `Parser` and returns a `Result`, calls it once, @@ -46,7 +45,7 @@ // 'none' | <image> fn parse_background_image(context: &ParserContext, input: &mut Parser) -> Result<Option<Image>, ()> { - if input.try(|input| input.expect_ident_matching("none")).is_ok() { + if input.try_parse(|input| input.expect_ident_matching("none")).is_ok() { Ok(None) } else { Image::parse(context, input).map(Some) // tail call @@ -58,50 +57,68 @@ // [ <length> | <percentage> ] [ <length> | <percentage> ]? fn parse_border_spacing(_context: &ParserContext, input: &mut Parser) -> Result<(LengthOrPercentage, LengthOrPercentage), ()> { - let first = try!(LengthOrPercentage::parse); - let second = input.try(LengthOrPercentage::parse).unwrap_or(first); + let first = LengthOrPercentage::parse?; + let second = input.try_parse(LengthOrPercentage::parse).unwrap_or(first); (first, second) } ``` */ -#![recursion_limit="200"] // For color::parse_color_keyword +#![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; -#[macro_use] extern crate procedural_masquerade; -#[doc(hidden)] pub extern crate phf as _internal__phf; -#[cfg(test)] extern crate encoding_rs; -#[cfg(test)] extern crate difference; -#[cfg(test)] extern crate rustc_serialize; -#[cfg(feature = "serde")] extern crate serde; -#[cfg(feature = "heapsize")] #[macro_use] extern crate heapsize; +#[macro_use] +extern crate cssparser_macros; +#[macro_use] +extern crate matches; +#[macro_use] +extern crate procedural_masquerade; +#[cfg(test)] +extern crate difference; +#[cfg(test)] +extern crate encoding_rs; +#[doc(hidden)] +pub extern crate phf as _internal__phf; +#[cfg(test)] +extern crate rustc_serialize; +#[cfg(feature = "serde")] +extern crate serde; +#[cfg(feature = "heapsize")] +#[macro_use] +extern crate heapsize; extern crate smallvec; pub use cssparser_macros::*; -pub use tokenizer::{Token, SourcePosition, SourceLocation}; -pub use rules_and_declarations::{parse_important}; -pub use rules_and_declarations::{DeclarationParser, DeclarationListParser, parse_one_declaration}; -pub use rules_and_declarations::{RuleListParser, parse_one_rule}; -pub use rules_and_declarations::{AtRuleType, QualifiedRuleParser, AtRuleParser}; +pub use color::{ + parse_color_keyword, AngleOrNumber, Color, ColorComponentParser, NumberOrPercentage, RGBA, +}; +pub use cow_rc_str::CowRcStr; pub use from_bytes::{stylesheet_encoding, EncodingSupport}; -pub use color::{RGBA, Color, parse_color_keyword, AngleOrNumber, NumberOrPercentage, ColorComponentParser}; pub use nth::parse_nth; -pub use serializer::{ToCss, CssStringWriter, serialize_identifier, serialize_name, serialize_string, TokenSerializationType}; -pub use parser::{Parser, Delimiter, Delimiters, ParserState, ParserInput}; -pub use parser::{ParseError, ParseErrorKind, BasicParseError, BasicParseErrorKind}; +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; -pub use cow_rc_str::CowRcStr; // For macros -#[doc(hidden)] pub use macros::_internal__to_lowercase; +#[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; } +mod cssparser { + pub use _internal__phf; +} #[macro_use] mod macros; @@ -115,13 +132,15 @@ mod tokenizer { include!(concat!(env!("OUT_DIR"), "/tokenizer.rs")); } +mod color; +mod cow_rc_str; +mod from_bytes; +mod nth; mod parser; -mod from_bytes; -mod color; -mod nth; mod serializer; mod unicode_range; -mod cow_rc_str; -#[cfg(test)] mod tests; -#[cfg(test)] mod size_of_tests; +#[cfg(test)] +mod size_of_tests; +#[cfg(test)] +mod tests; diff --git a/third_party/rust/cssparser/src/macros.rs b/third_party/rust/cssparser/src/macros.rs --- a/third_party/rust/cssparser/src/macros.rs +++ b/third_party/rust/cssparser/src/macros.rs @@ -2,7 +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/. */ -/// See docs of the `procedural-masquerade` crate. +// See docs of the `procedural-masquerade` crate. define_invoke_proc_macro!(cssparser_internal__invoke_proc_macro); /// Expands to a `match` expression with string patterns, @@ -114,12 +114,10 @@ // which initializes with `copy_from_slice` the part of the buffer it uses, // before it uses it. #[allow(unsafe_code)] - let mut buffer: [u8; $BUFFER_SIZE] = unsafe { - ::std::mem::uninitialized() - }; + let mut buffer: [u8; $BUFFER_SIZE] = unsafe { ::std::mem::uninitialized() }; let input: &str = $input; let $output = $crate::_internal__to_lowercase(&mut buffer, input); - } + }; } /// Implementation detail of match_ignore_ascii_case! and ascii_case_insensitive_phf_map! macros. @@ -134,12 +132,10 @@ if let Some(buffer) = buffer.get_mut(..input.len()) { if let Some(first_uppercase) = input.bytes().position(|byte| matches!(byte, b'A'...b'Z')) { buffer.copy_from_slice(input.as_bytes()); - ::std::ascii::AsciiExt::make_ascii_lowercase(&mut buffer[first_uppercase..]); + buffer[first_uppercase..].make_ascii_lowercase(); // `buffer` was initialized to a copy of `input` (which is &str so well-formed UTF-8) // then lowercased (which preserves UTF-8 well-formedness) - unsafe { - Some(::std::str::from_utf8_unchecked(buffer)) - } + unsafe { Some(::std::str::from_utf8_unchecked(buffer)) } } else { // Input is already lower-case Some(input) diff --git a/third_party/rust/cssparser/src/nth.rs b/third_party/rust/cssparser/src/nth.rs --- a/third_party/rust/cssparser/src/nth.rs +++ b/third_party/rust/cssparser/src/nth.rs @@ -2,10 +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/. */ -#[allow(unused_imports)] use std::ascii::AsciiExt; - -use super::{Token, Parser, ParserInput, BasicParseError}; - +use super::{BasicParseError, Parser, ParserInput, Token}; /// Parse the *An+B* notation, as found in the `:nth-child()` selector. /// The input is typically the arguments of a function, @@ -14,14 +11,18 @@ pub fn parse_nth<'i, 't>(input: &mut Parser<'i, 't>) -> Result<(i32, i32), BasicParseError<'i>> { // FIXME: remove .clone() when lifetimes are non-lexical. match input.next()?.clone() { - Token::Number { int_value: Some(b), .. } => { - Ok((0, b)) - } - Token::Dimension { int_value: Some(a), unit, .. } => { + Token::Number { + int_value: Some(b), .. + } => Ok((0, b)), + Token::Dimension { + int_value: Some(a), + unit, + .. + } => { match_ignore_ascii_case! { &unit, - "n" => Ok(try!(parse_b(input, a))), - "n-" => Ok(try!(parse_signless_b(input, a, -1))), + "n" => Ok(parse_b(input, a)?), + "n-" => Ok(parse_signless_b(input, a, -1)?), _ => match parse_n_dash_digits(&*unit) { Ok(b) => Ok((a, b)), Err(()) => Err(input.new_basic_unexpected_token_error(Token::Ident(unit.clone()))) @@ -32,10 +33,10 @@ match_ignore_ascii_case! { &value, "even" => Ok((2, 0)), "odd" => Ok((2, 1)), - "n" => Ok(try!(parse_b(input, 1))), - "-n" => Ok(try!(parse_b(input, -1))), - "n-" => Ok(try!(parse_signless_b(input, 1, -1))), - "-n-" => Ok(try!(parse_signless_b(input, -1, -1))), + "n" => Ok(parse_b(input, 1)?), + "-n" => Ok(parse_b(input, -1)?), + "n-" => Ok(parse_signless_b(input, 1, -1)?), + "-n-" => Ok(parse_signless_b(input, -1, -1)?), _ => { let (slice, a) = if value.starts_with("-") { (&value[1..], -1) @@ -67,13 +68,16 @@ } } - fn parse_b<'i, 't>(input: &mut Parser<'i, 't>, a: i32) -> Result<(i32, i32), BasicParseError<'i>> { let start = input.state(); match input.next() { Ok(&Token::Delim('+')) => parse_signless_b(input, a, 1), Ok(&Token::Delim('-')) => parse_signless_b(input, a, -1), - Ok(&Token::Number { has_sign: true, int_value: Some(b), .. }) => Ok((a, b)), + Ok(&Token::Number { + has_sign: true, + int_value: Some(b), + .. + }) => Ok((a, b)), _ => { input.reset(&start); Ok((a, 0)) @@ -81,21 +85,29 @@ } } -fn parse_signless_b<'i, 't>(input: &mut Parser<'i, 't>, a: i32, b_sign: i32) -> Result<(i32, i32), BasicParseError<'i>> { +fn parse_signless_b<'i, 't>( + input: &mut Parser<'i, 't>, + a: i32, + b_sign: i32, +) -> Result<(i32, i32), BasicParseError<'i>> { // FIXME: remove .clone() when lifetimes are non-lexical. match input.next()?.clone() { - Token::Number { has_sign: false, int_value: Some(b), .. } => Ok((a, b_sign * b)), - token => Err(input.new_basic_unexpected_token_error(token)) + Token::Number { + has_sign: false, + int_value: Some(b), + .. + } => Ok((a, b_sign * b)), + token => Err(input.new_basic_unexpected_token_error(token)), } } fn parse_n_dash_digits(string: &str) -> Result<i32, ()> { let bytes = string.as_bytes(); if bytes.len() >= 3 - && bytes[..2].eq_ignore_ascii_case(b"n-") - && bytes[2..].iter().all(|&c| matches!(c, b'0'...b'9')) + && bytes[..2].eq_ignore_ascii_case(b"n-") + && bytes[2..].iter().all(|&c| matches!(c, b'0'...b'9')) { - Ok(parse_number_saturate(&string[1..]).unwrap()) // Include the minus sign + Ok(parse_number_saturate(&string[1..]).unwrap()) // Include the minus sign } else { Err(()) } @@ -104,14 +116,17 @@ fn parse_number_saturate(string: &str) -> Result<i32, ()> { let mut input = ParserInput::new(string); let mut parser = Parser::new(&mut input); - let int = if let Ok(&Token::Number {int_value: Some(int), ..}) - = parser.next_including_whitespace_and_comments() { + let int = if let Ok(&Token::Number { + int_value: Some(int), + .. + }) = parser.next_including_whitespace_and_comments() + { int } else { - return Err(()) + return Err(()); }; if !parser.is_exhausted() { - return Err(()) + return Err(()); } Ok(int) } diff --git a/third_party/rust/cssparser/src/parser.rs b/third_party/rust/cssparser/src/parser.rs --- a/third_party/rust/cssparser/src/parser.rs +++ b/third_party/rust/cssparser/src/parser.rs @@ -4,11 +4,9 @@ use cow_rc_str::CowRcStr; use smallvec::SmallVec; +use std::ops::BitOr; use std::ops::Range; -#[allow(unused_imports)] use std::ascii::AsciiExt; -use std::ops::BitOr; -use tokenizer::{Token, Tokenizer, SourcePosition, SourceLocation}; - +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. @@ -114,7 +112,10 @@ impl<'i, T> ParseErrorKind<'i, T> { /// Like `std::convert::Into::into` - pub fn into<U>(self) -> ParseErrorKind<'i, U> where T: Into<U> { + pub fn into<U>(self) -> ParseErrorKind<'i, U> + where + T: Into<U>, + { match self { ParseErrorKind::Basic(basic) => ParseErrorKind::Basic(basic), ParseErrorKind::Custom(custom) => ParseErrorKind::Custom(custom.into()), @@ -144,7 +145,10 @@ } /// Like `std::convert::Into::into` - pub fn into<U>(self) -> ParseError<'i, U> where T: Into<U> { + pub fn into<U>(self) -> ParseError<'i, U> + where + T: Into<U>, + { ParseError { kind: self.kind.into(), location: self.location, @@ -199,7 +203,6 @@ stop_before: Delimiters, } - #[derive(Copy, Clone, PartialEq, Eq, Debug)] pub(crate) enum BlockType { Parenthesis, @@ -207,15 +210,13 @@ CurlyBracket, } - impl BlockType { fn opening(token: &Token) -> Option<BlockType> { match *token { - Token::Function(_) | - Token::ParenthesisBlock => Some(BlockType::Parenthesis), + Token::Function(_) | Token::ParenthesisBlock => Some(BlockType::Parenthesis), Token::SquareBracketBlock => Some(BlockType::SquareBracket), Token::CurlyBracketBlock => Some(BlockType::CurlyBracket), - _ => None + _ => None, } } @@ -224,11 +225,10 @@ Token::CloseParenthesis => Some(BlockType::Parenthesis), Token::CloseSquareBracket => Some(BlockType::SquareBracket), Token::CloseCurlyBracket => Some(BlockType::CurlyBracket), - _ => None - } - } -} - + _ => None, + } + } +} /// A set of characters, to be used with the `Parser::parse_until*` methods. /// @@ -273,7 +273,9 @@ #[inline] fn bitor(self, other: Delimiters) -> Delimiters { - Delimiters { bits: self.bits | other.bits } + Delimiters { + bits: self.bits | other.bits, + } } } @@ -338,16 +340,21 @@ } /// Check whether the input is exhausted. That is, if `.next()` would return a token. - /// Return a `Result` so that the `try!` macro can be used: `try!(input.expect_exhausted())` + /// Return a `Result` so that the `?` operator can be used: `input.expect_exhausted()?` /// /// This ignores whitespace and comments. #[inline] pub fn expect_exhausted(&mut self) -> Result<(), BasicParseError<'i>> { let start = self.state(); let result = match self.next() { - Err(BasicParseError { kind: BasicParseErrorKind::EndOfInput, .. }) => Ok(()), + Err(BasicParseError { + kind: BasicParseErrorKind::EndOfInput, + .. + }) => Ok(()), Err(e) => unreachable!("Unexpected error encountered: {:?}", e), - Ok(t) => Err(start.source_location().new_basic_unexpected_token_error(t.clone())), + Ok(t) => Err(start + .source_location() + .new_basic_unexpected_token_error(t.clone())), }; self.reset(&start); result @@ -426,7 +433,7 @@ pub fn new_error_for_next_token<E>(&mut self) -> ParseError<'i, E> { let token = match self.next() { Ok(token) => token.clone(), - Err(e) => return e.into() + Err(e) => return e.into(), }; self.new_error(BasicParseErrorKind::UnexpectedToken(token)) } @@ -438,7 +445,7 @@ pub fn state(&self) -> ParserState { ParserState { at_start_of: self.at_start_of, - .. self.input.tokenizer.state() + ..self.input.tokenizer.state() } } @@ -465,7 +472,7 @@ pub(crate) fn next_byte(&self) -> Option<u8> { let byte = self.input.tokenizer.next_byte(); if self.stop_before.contains(Delimiters::from_byte(byte)) { - return None + return None; } byte } @@ -493,6 +500,15 @@ #[inline] pub fn seen_var_or_env_functions(&mut self) -> bool { self.input.tokenizer.seen_var_or_env_functions() + } + + /// 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> + where + F: FnOnce(&mut Parser<'i, 't>) -> Result<T, E>, + { + self.try_parse(thing) } /// Execute the given closure, passing it the parser. @@ -500,8 +516,10 @@ /// the internal state of the parser (including position within the input) /// is restored to what it was before the call. #[inline] - pub fn try<F, T, E>(&mut self, thing: F) -> Result<T, E> - where F: FnOnce(&mut Parser<'i, 't>) -> Result<T, E> { + pub fn try_parse<F, T, E>(&mut self, thing: F) -> Result<T, E> + where + F: FnOnce(&mut Parser<'i, 't>) -> Result<T, E>, + { let start = self.state(); let result = thing(self); if result.is_err() { @@ -543,8 +561,8 @@ loop { match self.next_including_whitespace_and_comments() { Err(e) => return Err(e), - Ok(&Token::Comment(_)) => {}, - _ => break + Ok(&Token::Comment(_)) => {} + _ => break, } } Ok(self.input.cached_token_ref()) @@ -556,39 +574,47 @@ /// where comments are preserved. /// When parsing higher-level values, per the CSS Syntax specification, /// comments should always be ignored between tokens. - pub fn next_including_whitespace_and_comments(&mut self) -> Result<&Token<'i>, BasicParseError<'i>> { + pub fn next_including_whitespace_and_comments( + &mut self, + ) -> Result<&Token<'i>, BasicParseError<'i>> { if let Some(block_type) = self.at_start_of.take() { consume_until_end_of_block(block_type, &mut self.input.tokenizer); } let byte = self.input.tokenizer.next_byte(); if self.stop_before.contains(Delimiters::from_byte(byte)) { - return Err(self.new_basic_error(BasicParseErrorKind::EndOfInput)) + return Err(self.new_basic_error(BasicParseErrorKind::EndOfInput)); } let token_start_position = self.input.tokenizer.position(); - let token; - match self.input.cached_token { - Some(ref cached_token) - if cached_token.start_position == token_start_position => { - self.input.tokenizer.reset(&cached_token.end_state); - match cached_token.token { - Token::Function(ref name) => self.input.tokenizer.see_function(name), - _ => {} - } - token = &cached_token.token + let using_cached_token = self + .input + .cached_token + .as_ref() + .map_or(false, |cached_token| { + cached_token.start_position == token_start_position + }); + let token = if using_cached_token { + let cached_token = self.input.cached_token.as_ref().unwrap(); + self.input.tokenizer.reset(&cached_token.end_state); + match cached_token.token { + Token::Function(ref name) => self.input.tokenizer.see_function(name), + _ => {} } - _ => { - let new_token = self.input.tokenizer.next() - .map_err(|()| self.new_basic_error(BasicParseErrorKind::EndOfInput))?; - self.input.cached_token = Some(CachedToken { - token: new_token, - start_position: token_start_position, - end_state: self.input.tokenizer.state(), - }); - token = self.input.cached_token_ref() - } - } + &cached_token.token + } else { + let new_token = self + .input + .tokenizer + .next() + .map_err(|()| self.new_basic_error(BasicParseErrorKind::EndOfInput))?; + self.input.cached_token = Some(CachedToken { + token: new_token, + start_position: token_start_position, + end_state: self.input.tokenizer.state(), + }); + self.input.cached_token_ref() + }; if let Some(block_type) = BlockType::opening(token) { self.at_start_of = Some(block_type); @@ -602,7 +628,9 @@ /// This can help tell e.g. `color: green;` from `color: green 4px;` #[inline] pub fn parse_entirely<F, T, E>(&mut self, parse: F) -> Result<T, ParseError<'i, E>> - where F: FnOnce(&mut Parser<'i, 't>) -> Result<T, ParseError<'i, E>> { + where + F: FnOnce(&mut Parser<'i, 't>) -> Result<T, ParseError<'i, E>>, + { let result = parse(self)?; self.expect_exhausted()?; Ok(result) @@ -619,15 +647,20 @@ /// This method retuns `Err(())` the first time that a closure call does, /// or if a closure call leaves some input before the next comma or the end of the input. #[inline] - pub fn parse_comma_separated<F, T, E>(&mut self, mut parse_one: F) -> Result<Vec<T>, ParseError<'i, E>> - where F: for<'tt> FnMut(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>> { + pub fn parse_comma_separated<F, T, E>( + &mut self, + mut parse_one: F, + ) -> Result<Vec<T>, ParseError<'i, E>> + where + F: for<'tt> FnMut(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, + { // Vec grows from 0 to 4 by default on first push(). So allocate with // capacity 1, so in the somewhat common case of only one item we don't // way overallocate. Note that we always push at least one item if // parsing succeeds. let mut values = Vec::with_capacity(1); loop { - self.skip_whitespace(); // Unnecessary for correctness, but may help try() in parse_one rewind less. + self.skip_whitespace(); // Unnecessary for correctness, but may help try() in parse_one rewind less. values.push(self.parse_until_before(Delimiter::Comma, &mut parse_one)?); match self.next() { Err(_) => return Ok(values), @@ -649,8 +682,10 @@ /// /// The result is overridden to `Err(())` if the closure leaves some input before that point. #[inline] - pub fn parse_nested_block<F, T, E>(&mut self, parse: F) -> Result <T, ParseError<'i, E>> - where F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>> { + pub fn parse_nested_block<F, T, E>(&mut self, parse: F) -> Result<T, ParseError<'i, E>> + where + F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, + { parse_nested_block(self, parse) } @@ -663,9 +698,14 @@ /// /// The result is overridden to `Err(())` if the closure leaves some input before that point. #[inline] - pub fn parse_until_before<F, T, E>(&mut self, delimiters: Delimiters, parse: F) - -> Result <T, ParseError<'i, E>> - where F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>> { + pub fn parse_until_before<F, T, E>( + &mut self, + delimiters: Delimiters, + parse: F, + ) -> Result<T, ParseError<'i, E>> + where + F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, + { parse_until_before(self, delimiters, parse) } @@ -675,9 +715,14 @@ /// (e.g. if these is only one in the given set) /// or if it was there at all (as opposed to reaching the end of the input). #[inline] - pub fn parse_until_after<F, T, E>(&mut self, delimiters: Delimiters, parse: F) - -> Result <T, ParseError<'i, E>> - where F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>> { + pub fn parse_until_after<F, T, E>( + &mut self, + delimiters: Delimiters, + parse: F, + ) -> Result<T, ParseError<'i, E>> + where + F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, + { parse_until_after(self, delimiters, parse) } @@ -687,7 +732,7 @@ let start_location = self.current_source_location(); match *self.next_including_whitespace()? { Token::WhiteSpace(value) => Ok(value), - ref t => Err(start_location.new_basic_unexpected_token_error(t.clone())) + ref t => Err(start_location.new_basic_unexpected_token_error(t.clone())), } } @@ -707,7 +752,10 @@ /// Parse a <ident-token> whose unescaped value is an ASCII-insensitive match for the given value. #[inline] - pub fn expect_ident_matching(&mut self, expected_value: &str) -> Result<(), BasicParseError<'i>> { + pub fn expect_ident_matching( + &mut self, + expected_value: &str, + ) -> Result<(), BasicParseError<'i>> { expect! {self, Token::Ident(ref value) if value.eq_ignore_ascii_case(expected_value) => Ok(()), } @@ -744,8 +792,10 @@ Token::UnquotedUrl(ref value) => return Ok(value.clone()), Token::Function(ref name) if name.eq_ignore_ascii_case("url") => {} } - self.parse_nested_block(|input| input.expect_string().map_err(Into::into).map(|s| s.clone())) - .map_err(ParseError::<()>::basic) + self.parse_nested_block(|input| { + input.expect_string().map_err(Into::into).map(|s| s.clone()) + }) + .map_err(ParseError::<()>::basic) } /// Parse either a <url-token> or a <string-token>, and return the unescaped value. @@ -757,8 +807,10 @@ Token::QuotedString(ref value) => return Ok(value.clone()), Token::Function(ref name) if name.eq_ignore_ascii_case("url") => {} } - self.parse_nested_block(|input| input.expect_string().map_err(Into::into).map(|s| s.clone())) - .map_err(ParseError::<()>::basic) + self.parse_nested_block(|input| { + input.expect_string().map_err(Into::into).map(|s| s.clone()) + }) + .map_err(ParseError::<()>::basic) } /// Parse a <number-token> and return the integer value. @@ -862,7 +914,10 @@ /// /// If the result is `Ok`, you can then call the `Parser::parse_nested_block` method. #[inline] - pub fn expect_function_matching(&mut self, expected_name: &str) -> Result<(), BasicParseError<'i>> { + pub fn expect_function_matching( + &mut self, + expected_name: &str, + ) -> Result<(), BasicParseError<'i>> { expect! {self, Token::Function(ref name) if name.eq_ignore_ascii_case(expected_name) => Ok(()), } @@ -877,21 +932,22 @@ let token; loop { match self.next_including_whitespace_and_comments() { - Ok(&Token::Function(_)) | - Ok(&Token::ParenthesisBlock) | - Ok(&Token::SquareBracketBlock) | - Ok(&Token::CurlyBracketBlock) => {} + Ok(&Token::Function(_)) + | Ok(&Token::ParenthesisBlock) + | Ok(&Token::SquareBracketBlock) + | Ok(&Token::CurlyBracketBlock) => {} Ok(t) => { if t.is_parse_error() { token = t.clone(); - break + break; } - continue + continue; } - Err(_) => return Ok(()) + Err(_) => return Ok(()), } - let result = self.parse_nested_block(|input| input.expect_no_error_token() - .map_err(|e| Into::into(e))); + let result = self.parse_nested_block(|input| { + input.expect_no_error_token().map_err(|e| Into::into(e)) + }); result.map_err(ParseError::<()>::basic)? } // FIXME: maybe these should be separate variants of BasicParseError instead? @@ -899,11 +955,14 @@ } } -pub fn parse_until_before<'i: 't, 't, F, T, E>(parser: &mut Parser<'i, 't>, - delimiters: Delimiters, - parse: F) - -> Result <T, ParseError<'i, E>> - where F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>> { +pub fn parse_until_before<'i: 't, 't, F, T, E>( + parser: &mut Parser<'i, 't>, + delimiters: Delimiters, + parse: F, +) -> Result<T, ParseError<'i, E>> +where + F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, +{ let delimiters = parser.stop_before | delimiters; let result; // Introduce a new scope to limit duration of nested_parser’s borrow @@ -921,27 +980,34 @@ // FIXME: have a special-purpose tokenizer method for this that does less work. loop { if delimiters.contains(Delimiters::from_byte(parser.input.tokenizer.next_byte())) { - break + break; } if let Ok(token) = parser.input.tokenizer.next() { if let Some(block_type) = BlockType::opening(&token) { consume_until_end_of_block(block_type, &mut parser.input.tokenizer); } } else { - break + break; } } result } -pub fn parse_until_after<'i: 't, 't, F, T, E>(parser: &mut Parser<'i, 't>, - delimiters: Delimiters, - parse: F) - -> Result <T, ParseError<'i, E>> - where F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>> { +pub fn parse_until_after<'i: 't, 't, F, T, E>( + parser: &mut Parser<'i, 't>, + delimiters: Delimiters, + parse: F, +) -> Result<T, ParseError<'i, E>> +where + F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, +{ let result = parser.parse_until_before(delimiters, parse); let next_byte = parser.input.tokenizer.next_byte(); - if next_byte.is_some() && !parser.stop_before.contains(Delimiters::from_byte(next_byte)) { + if next_byte.is_some() + && !parser + .stop_before + .contains(Delimiters::from_byte(next_byte)) + { debug_assert!(delimiters.contains(Delimiters::from_byte(next_byte))); // We know this byte is ASCII. parser.input.tokenizer.advance(1); @@ -952,14 +1018,20 @@ result } -pub fn parse_nested_block<'i: 't, 't, F, T, E>(parser: &mut Parser<'i, 't>, parse: F) - -> Result <T, ParseError<'i, E>> - where F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>> { - let block_type = parser.at_start_of.take().expect("\ - A nested parser can only be created when a Function, \ - ParenthesisBlock, SquareBracketBlock, or CurlyBracketBlock \ - token was just consumed.\ - "); +pub fn parse_nested_block<'i: 't, 't, F, T, E>( + parser: &mut Parser<'i, 't>, + parse: F, +) -> Result<T, ParseError<'i, E>> +where + F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, +{ + let block_type = parser.at_start_of.take().expect( + "\ + A nested parser can only be created when a Function, \ + ParenthesisBlock, SquareBracketBlock, or CurlyBracketBlock \ + token was just consumed.\ + ", + ); let closing_delimiter = match block_type { BlockType::CurlyBracket => ClosingDelimiter::CloseCurlyBracket, BlockType::SquareBracket => ClosingDelimiter::CloseSquareBracket, diff --git a/third_party/rust/cssparser/src/rules_and_declarations.rs b/third_party/rust/cssparser/src/rules_and_declarations.rs --- a/third_party/rust/cssparser/src/rules_and_declarations.rs +++ b/third_party/rust/cssparser/src/rules_and_declarations.rs @@ -4,15 +4,14 @@ // https://drafts.csswg.org/css-syntax/#parsing -use cow_rc_str::CowRcStr; -use parser::{parse_until_before, parse_until_after, parse_nested_block, ParserState}; -#[allow(unused_imports)] use std::ascii::AsciiExt; 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}; /// Parse `!important`. /// -/// Typical usage is `input.try(parse_important).is_ok()` +/// Typical usage is `input.try_parse(parse_important).is_ok()` /// at the end of a `DeclarationParser::parse_value` implementation. pub fn parse_important<'i, 't>(input: &mut Parser<'i, 't>) -> Result<(), BasicParseError<'i>> { input.expect_delim('!')?; @@ -61,10 +60,13 @@ /// (In declaration lists, before the next semicolon or end of the current block.) /// /// If `!important` can be used in a given context, - /// `input.try(parse_important).is_ok()` should be used at the end + /// `input.try_parse(parse_important).is_ok()` should be used at the end /// of the implementation of this method and the result should be part of the return value. - fn parse_value<'t>(&mut self, name: CowRcStr<'i>, input: &mut Parser<'i, 't>) - -> Result<Self::Declaration, ParseError<'i, Self::Error>>; + fn parse_value<'t>( + &mut self, + name: CowRcStr<'i>, + input: &mut Parser<'i, 't>, + ) -> Result<Self::Declaration, ParseError<'i, Self::Error>>; } /// A trait to provide various parsing of at-rules. @@ -106,9 +108,12 @@ /// The given `input` is a "delimited" parser /// that ends wherever the prelude should end. /// (Before the next semicolon, the next `{`, or the end of the current block.) - fn parse_prelude<'t>(&mut self, name: CowRcStr<'i>, input: &mut Parser<'i, 't>) - -> Result<AtRuleType<Self::PreludeNoBlock, Self::PreludeBlock>, - ParseError<'i, Self::Error>> { + fn parse_prelude<'t>( + &mut self, + name: CowRcStr<'i>, + input: &mut Parser<'i, 't>, + ) -> Result<AtRuleType<Self::PreludeNoBlock, Self::PreludeBlock>, ParseError<'i, Self::Error>> + { let _ = name; let _ = input; Err(input.new_error(BasicParseErrorKind::AtRuleInvalid(name))) @@ -129,8 +134,10 @@ ) -> Self::AtRule { let _ = prelude; let _ = location; - panic!("The `AtRuleParser::rule_without_block` method must be overriden \ - if `AtRuleParser::parse_prelude` ever returns `AtRuleType::WithoutBlock`.") + panic!( + "The `AtRuleParser::rule_without_block` method must be overriden \ + if `AtRuleParser::parse_prelude` ever returns `AtRuleType::WithoutBlock`." + ) } /// Parse the content of a `{ /* ... */ }` block for the body of the at-rule. @@ -185,8 +192,10 @@ /// /// The given `input` is a "delimited" parser /// that ends where the prelude should end (before the next `{`). - fn parse_prelude<'t>(&mut self, input: &mut Parser<'i, 't>) - -> Result<Self::Prelude, ParseError<'i, Self::Error>> { + fn parse_prelude<'t>( + &mut self, + input: &mut Parser<'i, 't>, + ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> { let _ = input; Err(input.new_error(BasicParseErrorKind::QualifiedRuleInvalid)) } @@ -211,7 +220,6 @@ } } - /// Provides an iterator for declaration list parsing. pub struct DeclarationListParser<'i: 't, 't: 'a, 'a, P> { /// The input given to `DeclarationListParser::new` @@ -221,10 +229,10 @@ pub parser: P, } - impl<'i: 't, 't: 'a, 'a, I, P, E: 'i> DeclarationListParser<'i, 't, 'a, P> -where P: DeclarationParser<'i, Declaration = I, Error = E> + - AtRuleParser<'i, AtRule = I, Error = E> { +where + P: DeclarationParser<'i, Declaration = I, Error = E> + AtRuleParser<'i, AtRule = I, Error = E>, +{ /// Create a new `DeclarationListParser` for the given `input` and `parser`. /// /// Note that all CSS declaration lists can on principle contain at-rules. @@ -250,8 +258,9 @@ /// `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> -where P: DeclarationParser<'i, Declaration = I, Error = E> + - AtRuleParser<'i, AtRule = I, Error = E> { +where + P: DeclarationParser<'i, Declaration = I, Error = E> + AtRuleParser<'i, AtRule = I, Error = E>, +{ type Item = Result<I, (ParseError<'i, E>, &'i str)>; fn next(&mut self) -> Option<Self::Item> { @@ -259,7 +268,9 @@ let start = self.input.state(); // FIXME: remove intermediate variable when lifetimes are non-lexical let ident = match self.input.next_including_whitespace_and_comments() { - Ok(&Token::WhiteSpace(_)) | Ok(&Token::Comment(_)) | Ok(&Token::Semicolon) => continue, + Ok(&Token::WhiteSpace(_)) | Ok(&Token::Comment(_)) | Ok(&Token::Semicolon) => { + continue + } Ok(&Token::Ident(ref name)) => Ok(Ok(name.clone())), Ok(&Token::AtKeyword(ref name)) => Ok(Err(name.clone())), Ok(token) => Err(token.clone()), @@ -271,28 +282,33 @@ let result = { let parser = &mut self.parser; // FIXME: https://github.com/rust-lang/rust/issues/42508 - parse_until_after::<'i, 't, _, _, _>(self.input, Delimiter::Semicolon, |input| { - input.expect_colon()?; - parser.parse_value(name, input) - }) + parse_until_after::<'i, 't, _, _, _>( + self.input, + Delimiter::Semicolon, + |input| { + input.expect_colon()?; + parser.parse_value(name, input) + }, + ) }; - return Some(result.map_err(|e| (e, self.input.slice_from(start.position())))) + return Some(result.map_err(|e| (e, self.input.slice_from(start.position())))); } Ok(Err(name)) => { // At-keyword - return Some(parse_at_rule(&start, name, self.input, &mut self.parser)) + return Some(parse_at_rule(&start, name, self.input, &mut self.parser)); } Err(token) => { let result = self.input.parse_until_after(Delimiter::Semicolon, |_| { - Err(start.source_location().new_unexpected_token_error(token.clone())) + Err(start + .source_location() + .new_unexpected_token_error(token.clone())) }); - return Some(result.map_err(|e| (e, self.input.slice_from(start.position())))) - } - } - } - } -} - + return Some(result.map_err(|e| (e, self.input.slice_from(start.position())))); + } + } + } + } +} /// Provides an iterator for rule list parsing. pub struct RuleListParser<'i: 't, 't: 'a, 'a, P> { @@ -306,10 +322,11 @@ any_rule_so_far: bool, } - impl<'i: 't, 't: 'a, 'a, R, P, E: 'i> RuleListParser<'i, 't, 'a, P> -where P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E> + - AtRuleParser<'i, AtRule = R, Error = E> { +where + P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E> + + AtRuleParser<'i, AtRule = R, Error = E>, +{ /// Create a new `RuleListParser` for the given `input` at the top-level of a stylesheet /// and the given `parser`. /// @@ -345,12 +362,12 @@ } } - - /// `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> -where P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E> + - AtRuleParser<'i, AtRule = R, Error = E> { +where + P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E> + + AtRuleParser<'i, AtRule = R, Error = E>, +{ type Item = Result<R, (ParseError<'i, E>, &'i str)>; fn next(&mut self) -> Option<Self::Item> { @@ -375,7 +392,7 @@ } } Some(_) => at_keyword = None, - None => return None + None => return None, } if let Some(name) = at_keyword { @@ -383,40 +400,52 @@ self.any_rule_so_far = true; if first_stylesheet_rule && name.eq_ignore_ascii_case("charset") { let delimiters = Delimiter::Semicolon | Delimiter::CurlyBracketBlock; - let _: Result<(), ParseError<()>> = self.input.parse_until_after(delimiters, |_| Ok(())); + let _: Result<(), ParseError<()>> = + self.input.parse_until_after(delimiters, |_| Ok(())); } else { - return Some(parse_at_rule(&start, name.clone(), self.input, &mut self.parser)) + return Some(parse_at_rule( + &start, + name.clone(), + self.input, + &mut self.parser, + )); } } else { self.any_rule_so_far = true; let result = parse_qualified_rule(self.input, &mut self.parser); - return Some(result.map_err(|e| (e, self.input.slice_from(start.position())))) - } - } - } -} - + return Some(result.map_err(|e| (e, self.input.slice_from(start.position())))); + } + } + } +} /// Parse a single declaration, such as an `( /* ... */ )` parenthesis in an `@supports` prelude. -pub fn parse_one_declaration<'i, 't, P, E>(input: &mut Parser<'i, 't>, parser: &mut P) - -> Result<<P as DeclarationParser<'i>>::Declaration, - (ParseError<'i, E>, &'i str)> - where P: DeclarationParser<'i, Error = E> { +pub fn parse_one_declaration<'i, 't, P, E>( + input: &mut Parser<'i, 't>, + parser: &mut P, +) -> Result<<P as DeclarationParser<'i>>::Declaration, (ParseError<'i, E>, &'i str)> +where + P: DeclarationParser<'i, Error = E>, +{ let start_position = input.position(); - input.parse_entirely(|input| { - let name = input.expect_ident()?.clone(); - input.expect_colon()?; - parser.parse_value(name, input) - }) - .map_err(|e| (e, input.slice_from(start_position))) -} - + input + .parse_entirely(|input| { + let name = input.expect_ident()?.clone(); + input.expect_colon()?; + parser.parse_value(name, input) + }) + .map_err(|e| (e, input.slice_from(start_position))) +} /// Parse a single rule, such as for CSSOM’s `CSSStyleSheet.insertRule`. -pub fn parse_one_rule<'i, 't, R, P, E>(input: &mut Parser<'i, 't>, parser: &mut P) - -> Result<R, ParseError<'i, E>> -where P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E> + - AtRuleParser<'i, AtRule = R, Error = E> { +pub fn parse_one_rule<'i, 't, R, P, E>( + input: &mut Parser<'i, 't>, + parser: &mut P, +) -> Result<R, ParseError<'i, E>> +where + P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E> + + AtRuleParser<'i, AtRule = R, Error = E>, +{ input.parse_entirely(|input| { input.skip_whitespace(); let start = input.state(); @@ -450,7 +479,7 @@ parser: &mut P, ) -> Result<<P as AtRuleParser<'i>>::AtRule, (ParseError<'i, E>, &'i str)> where - P: AtRuleParser<'i, Error = E> + P: AtRuleParser<'i, Error = E>, { let location = input.current_source_location(); let delimiters = Delimiter::Semicolon | Delimiter::CurlyBracketBlock; @@ -459,67 +488,64 @@ parser.parse_prelude(name, input) }); match result { - Ok(AtRuleType::WithoutBlock(prelude)) => { - match input.next() { - Ok(&Token::Semicolon) | Err(_) => Ok(parser.rule_without_block(prelude, location)), - Ok(&Token::CurlyBracketBlock) => Err(( - input.new_unexpected_token_error(Token::CurlyBracketBlock), - input.slice_from(start.position()), - )), - Ok(_) => unreachable!() - } - } + Ok(AtRuleType::WithoutBlock(prelude)) => match input.next() { + Ok(&Token::Semicolon) | Err(_) => Ok(parser.rule_without_block(prelude, location)), + Ok(&Token::CurlyBracketBlock) => Err(( + input.new_unexpected_token_error(Token::CurlyBracketBlock), + input.slice_from(start.position()), + )), + Ok(_) => unreachable!(), + }, Ok(AtRuleType::WithBlock(prelude)) => { match input.next() { Ok(&Token::CurlyBracketBlock) => { // FIXME: https://github.com/rust-lang/rust/issues/42508 - parse_nested_block::<'i, 't, _, _, _>( - input, - move |input| parser.parse_block(prelude, location, input) - ).map_err(|e| (e, input.slice_from(start.position()))) + parse_nested_block::<'i, 't, _, _, _>(input, move |input| { + parser.parse_block(prelude, location, input) + }) + .map_err(|e| (e, input.slice_from(start.position()))) } Ok(&Token::Semicolon) => Err(( input.new_unexpected_token_error(Token::Semicolon), input.slice_from(start.position()), )), Err(e) => Err((e.into(), input.slice_from(start.position()))), - Ok(_) => unreachable!() + Ok(_) => unreachable!(), } } Err(error) => { let end_position = input.position(); match input.next() { - Ok(&Token::CurlyBracketBlock) | Ok(&Token::Semicolon) | Err(_) => {}, - _ => unreachable!() + Ok(&Token::CurlyBracketBlock) | Ok(&Token::Semicolon) | Err(_) => {} + _ => unreachable!(), }; Err((error, input.slice(start.position()..end_position))) } } } - fn parse_qualified_rule<'i, 't, P, E>( input: &mut Parser<'i, 't>, parser: &mut P, ) -> Result<<P as QualifiedRuleParser<'i>>::QualifiedRule, ParseError<'i, E>> where - P: QualifiedRuleParser<'i, Error = E> + P: QualifiedRuleParser<'i, Error = E>, { let location = input.current_source_location(); // FIXME: https://github.com/rust-lang/rust/issues/42508 - let prelude = parse_until_before::<'i, 't, _, _, _>(input, Delimiter::CurlyBracketBlock, |input| { - parser.parse_prelude(input) - }); + let prelude = + parse_until_before::<'i, 't, _, _, _>(input, Delimiter::CurlyBracketBlock, |input| { + parser.parse_prelude(input) + }); match *input.next()? { Token::CurlyBracketBlock => { // Do this here so that we consume the `{` even if the prelude is `Err`. let prelude = prelude?; // FIXME: https://github.com/rust-lang/rust/issues/42508 - parse_nested_block::<'i, 't, _, _, _>( - input, - move |input| parser.parse_block(prelude, location, input), - ) - } - _ => unreachable!() - } -} + parse_nested_block::<'i, 't, _, _, _>(input, move |input| { + parser.parse_block(prelude, location, input) + }) + } + _ => unreachable!(), + } +} diff --git a/third_party/rust/cssparser/src/serializer.rs b/third_party/rust/cssparser/src/serializer.rs --- a/third_party/rust/cssparser/src/serializer.rs +++ b/third_party/rust/cssparser/src/serializer.rs @@ -4,18 +4,18 @@ use dtoa_short::{self, Notation}; use itoa; -#[allow(unused_imports)] use std::ascii::AsciiExt; use std::fmt::{self, Write}; use std::io; use std::str; use super::Token; - /// Trait for things the can serialize themselves in CSS syntax. pub trait ToCss { /// Serialize `self` in CSS syntax, writing to `dest`. - fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write; + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write; /// Serialize `self` in CSS syntax and return a string. /// @@ -29,8 +29,10 @@ } #[inline] -fn write_numeric<W>(value: f32, int_value: Option<i32>, has_sign: bool, dest: &mut W) - -> fmt::Result where W: fmt::Write { +fn write_numeric<W>(value: f32, int_value: Option<i32>, has_sign: bool, dest: &mut W) -> fmt::Result +where + W: fmt::Write, +{ // `value.value >= 0` is true for negative 0. if has_sign && value.is_sign_positive() { dest.write_str("+")?; @@ -39,7 +41,10 @@ let notation = if value == 0.0 && value.is_sign_negative() { // Negative zero. Work around #20596. dest.write_str("-0")?; - Notation { decimal_point: false, scientific: false } + Notation { + decimal_point: false, + scientific: false, + } } else { dtoa_short::write(dest, value)? }; @@ -52,19 +57,21 @@ Ok(()) } - impl<'a> ToCss for Token<'a> { - fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { match *self { Token::Ident(ref value) => serialize_identifier(&**value, dest)?, Token::AtKeyword(ref value) => { dest.write_str("@")?; serialize_identifier(&**value, dest)?; - }, + } Token::Hash(ref value) => { dest.write_str("#")?; serialize_name(value, dest)?; - }, + } Token::IDHash(ref value) => { dest.write_str("#")?; serialize_identifier(&**value, dest)?; @@ -74,17 +81,28 @@ dest.write_str("url(")?; serialize_unquoted_url(&**value, dest)?; dest.write_str(")")?; - }, + } Token::Delim(value) => dest.write_char(value)?, - Token::Number { value, int_value, has_sign } => { - write_numeric(value, int_value, has_sign, dest)? - } - Token::Percentage { unit_value, int_value, has_sign } => { + Token::Number { + value, + int_value, + has_sign, + } => write_numeric(value, int_value, has_sign, dest)?, + Token::Percentage { + unit_value, + int_value, + has_sign, + } => { write_numeric(unit_value * 100., int_value, has_sign, dest)?; dest.write_str("%")?; - }, - Token::Dimension { value, int_value, has_sign, ref unit } => { + } + Token::Dimension { + value, + int_value, + has_sign, + ref unit, + } => { write_numeric(value, int_value, has_sign, dest)?; // Disambiguate with scientific notation. let unit = &**unit; @@ -94,7 +112,7 @@ } else { serialize_identifier(unit, dest)?; } - }, + } Token::WhiteSpace(content) => dest.write_str(content)?, Token::Comment(content) => { @@ -116,7 +134,7 @@ Token::Function(ref name) => { serialize_identifier(&**name, dest)?; dest.write_str("(")?; - }, + } Token::ParenthesisBlock => dest.write_str("(")?, Token::SquareBracketBlock => dest.write_str("[")?, Token::CurlyBracketBlock => dest.write_str("{")?, @@ -134,7 +152,7 @@ // and therefore does not have a closing quote. dest.write_char('"')?; CssStringWriter::new(dest).write_str(value)?; - }, + } Token::CloseParenthesis => dest.write_str(")")?, Token::CloseSquareBracket => dest.write_str("]")?, Token::CloseCurlyBracket => dest.write_str("}")?, @@ -143,7 +161,10 @@ } } -fn hex_escape<W>(ascii_byte: u8, dest: &mut W) -> fmt::Result where W:fmt::Write { +fn hex_escape<W>(ascii_byte: u8, dest: &mut W) -> fmt::Result +where + W: fmt::Write, +{ static HEX_DIGITS: &'static [u8; 16] = b"0123456789abcdef"; let b3; let b4; @@ -159,15 +180,21 @@ dest.write_str(unsafe { str::from_utf8_unchecked(&bytes) }) } -fn char_escape<W>(ascii_byte: u8, dest: &mut W) -> fmt::Result where W:fmt::Write { +fn char_escape<W>(ascii_byte: u8, dest: &mut W) -> fmt::Result +where + W: fmt::Write, +{ let bytes = [b'\\', ascii_byte]; dest.write_str(unsafe { str::from_utf8_unchecked(&bytes) }) } /// Write a CSS identifier, escaping characters as necessary. -pub fn serialize_identifier<W>(mut value: &str, dest: &mut W) -> fmt::Result where W:fmt::Write { +pub fn serialize_identifier<W>(mut value: &str, dest: &mut W) -> fmt::Result +where + W: fmt::Write, +{ if value.is_empty() { - return Ok(()) + return Ok(()); } if value.starts_with("--") { @@ -192,7 +219,10 @@ /// /// You should only use this when you know what you're doing, when in doubt, /// consider using `serialize_identifier`. -pub fn serialize_name<W>(value: &str, dest: &mut W) -> fmt::Result where W:fmt::Write { +pub fn serialize_name<W>(value: &str, dest: &mut W) -> fmt::Result +where + W: fmt::Write, +{ let mut chunk_start = 0; for (i, b) in value.bytes().enumerate() { let escaped = match b { @@ -214,14 +244,16 @@ dest.write_str(&value[chunk_start..]) } - -fn serialize_unquoted_url<W>(value: &str, dest: &mut W) -> fmt::Result where W:fmt::Write { +fn serialize_unquoted_url<W>(value: &str, dest: &mut W) -> fmt::Result +where + W: fmt::Write, +{ let mut chunk_start = 0; for (i, b) in value.bytes().enumerate() { let hex = match b { - b'\0' ... b' ' | b'\x7F' => true, + b'\0'...b' ' | b'\x7F' => true, b'(' | b')' | b'"' | b'\'' | b'\\' => false, - _ => continue + _ => continue, }; dest.write_str(&value[chunk_start..i])?; if hex { @@ -234,15 +266,16 @@ dest.write_str(&value[chunk_start..]) } - /// Write a double-quoted CSS string token, escaping content as necessary. -pub fn serialize_string<W>(value: &str, dest: &mut W) -> fmt::Result where W: fmt::Write { +pub fn serialize_string<W>(value: &str, dest: &mut W) -> fmt::Result +where + W: fmt::Write, +{ dest.write_str("\"")?; CssStringWriter::new(dest).write_str(value)?; dest.write_str("\"")?; Ok(()) } - /// A `fmt::Write` adapter that escapes text for writing as a double-quoted CSS string. /// Quotes are not included. @@ -251,12 +284,12 @@ /// /// ```{rust,ignore} /// fn write_foo<W>(foo: &Foo, dest: &mut W) -> fmt::Result where W: fmt::Write { -/// try!(dest.write_str("\"")); +/// dest.write_str("\"")?; /// { /// let mut string_dest = CssStringWriter::new(dest); /// // Write into string_dest... /// } -/// try!(dest.write_str("\"")); +/// dest.write_str("\"")?; /// Ok(()) /// } /// ``` @@ -264,14 +297,20 @@ inner: &'a mut W, } -impl<'a, W> CssStringWriter<'a, W> where W: fmt::Write { +impl<'a, W> CssStringWriter<'a, W> +where + W: fmt::Write, +{ /// Wrap a text writer to create a `CssStringWriter`. pub fn new(inner: &'a mut W) -> CssStringWriter<'a, W> { CssStringWriter { inner: inner } } } -impl<'a, W> fmt::Write for CssStringWriter<'a, W> where W: fmt::Write { +impl<'a, W> fmt::Write for CssStringWriter<'a, W> +where + W: fmt::Write, +{ fn write_str(&mut self, s: &str) -> fmt::Result { let mut chunk_start = 0; for (i, b) in s.bytes().enumerate() { @@ -293,11 +332,13 @@ } } - macro_rules! impl_tocss_for_int { ($T: ty) => { impl<'a> ToCss for $T { - fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { struct AssumeUtf8<W: fmt::Write>(W); impl<W: fmt::Write> io::Write for AssumeUtf8<W> { @@ -305,7 +346,8 @@ fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { // Safety: itoa only emits ASCII, which is also well-formed UTF-8. debug_assert!(buf.is_ascii()); - self.0.write_str(unsafe { str::from_utf8_unchecked(buf) }) + self.0 + .write_str(unsafe { str::from_utf8_unchecked(buf) }) .map_err(|_| io::ErrorKind::Other.into()) } @@ -323,11 +365,11 @@ match itoa::write(AssumeUtf8(dest), *self) { Ok(_) => Ok(()), - Err(_) => Err(fmt::Error) + Err(_) => Err(fmt::Error), } } } - } + }; } impl_tocss_for_int!(i8); @@ -342,11 +384,14 @@ macro_rules! impl_tocss_for_float { ($T: ty) => { impl<'a> ToCss for $T { - fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { dtoa_short::write(dest, *self).map(|_| ()) } } - } + }; } impl_tocss_for_float!(f32); @@ -381,22 +426,33 @@ pub fn needs_separator_when_before(self, other: TokenSerializationType) -> bool { use self::TokenSerializationTypeVariants::*; match self.0 { - Ident => matches!(other.0, - Ident | Function | UrlOrBadUrl | DelimMinus | Number | Percentage | Dimension | - CDC | OpenParen), - AtKeywordOrHash | Dimension => matches!(other.0, - Ident | Function | UrlOrBadUrl | DelimMinus | Number | Percentage | Dimension | - CDC), - DelimHash | DelimMinus | Number => matches!(other.0, - Ident | Function | UrlOrBadUrl | DelimMinus | Number | Percentage | Dimension), - DelimAt => matches!(other.0, - Ident | Function | UrlOrBadUrl | DelimMinus), + Ident => matches!( + other.0, + Ident + | Function + | UrlOrBadUrl + | DelimMinus + | Number + | Percentage + | Dimension + | CDC + | OpenParen + ), + AtKeywordOrHash | Dimension => matches!( + other.0, + Ident | Function | UrlOrBadUrl | DelimMinus | Number | Percentage | Dimension | CDC + ), + DelimHash | DelimMinus | Number => matches!( + other.0, + Ident | Function | UrlOrBadUrl | DelimMinus | Number | Percentage | Dimension + ), + DelimAt => matches!(other.0, Ident | Function | UrlOrBadUrl | DelimMinus), DelimDotOrPlus => matches!(other.0, Number | Percentage | Dimension), DelimAssorted | DelimAsterisk => matches!(other.0, DelimEquals), DelimBar => matches!(other.0, DelimEquals | DelimBar | DashMatch), DelimSlash => matches!(other.0, DelimAsterisk | SubstringMatch), - Nothing | WhiteSpace | Percentage | UrlOrBadUrl | Function | CDC | OpenParen | - DashMatch | SubstringMatch | DelimQuestion | DelimEquals | Other => false, + Nothing | WhiteSpace | Percentage | UrlOrBadUrl | Function | CDC | OpenParen + | DashMatch | SubstringMatch | DelimQuestion | DelimEquals | Other => false, } } } @@ -415,18 +471,18 @@ CDC, DashMatch, SubstringMatch, - OpenParen, // '(' - DelimHash, // '#' - DelimAt, // '@' - DelimDotOrPlus, // '.', '+' - DelimMinus, // '-' - DelimQuestion, // '?' - DelimAssorted, // '$', '^', '~' - DelimEquals, // '=' - DelimBar, // '|' - DelimSlash, // '/' - DelimAsterisk, // '*' - Other, // anything else + OpenParen, // '(' + DelimHash, // '#' + DelimAt, // '@' + DelimDotOrPlus, // '.', '+' + DelimMinus, // '-' + DelimQuestion, // '?' + DelimAssorted, // '$', '^', '~' + DelimEquals, // '=' + DelimBar, // '|' + DelimSlash, // '/' + DelimAsterisk, // '*' + Other, // anything else } impl<'a> Token<'a> { @@ -460,12 +516,21 @@ Token::CDC => CDC, Token::Function(_) => Function, Token::ParenthesisBlock => OpenParen, - Token::SquareBracketBlock | Token::CurlyBracketBlock | - Token::CloseParenthesis | Token::CloseSquareBracket | Token::CloseCurlyBracket | - Token::QuotedString(_) | Token::BadString(_) | - Token::Delim(_) | Token::Colon | Token::Semicolon | Token::Comma | Token::CDO | - Token::IncludeMatch | Token::PrefixMatch | Token::SuffixMatch - => Other, + Token::SquareBracketBlock + | Token::CurlyBracketBlock + | Token::CloseParenthesis + | Token::CloseSquareBracket + | Token::CloseCurlyBracket + | Token::QuotedString(_) + | Token::BadString(_) + | Token::Delim(_) + | Token::Colon + | Token::Semicolon + | Token::Comma + | Token::CDO + | Token::IncludeMatch + | Token::PrefixMatch + | Token::SuffixMatch => Other, }) } } diff --git a/third_party/rust/cssparser/src/size_of_tests.rs b/third_party/rust/cssparser/src/size_of_tests.rs --- a/third_party/rust/cssparser/src/size_of_tests.rs +++ b/third_party/rust/cssparser/src/size_of_tests.rs @@ -16,18 +16,24 @@ panic!( "Your changes have decreased the stack size of {} from {} to {}. \ Good work! Please update the expected size in {}.", - stringify!($t), old, new, file!() + stringify!($t), + old, + new, + file!() ) } else if new > old { panic!( "Your changes have increased the stack size of {} from {} to {}. \ Please consider choosing a design which avoids this increase. \ If you feel that the increase is necessary, update the size in {}.", - stringify!($t), old, new, file!() + stringify!($t), + old, + new, + file!() ) } } - } + }; } // Some of these assume 64-bit @@ -36,10 +42,18 @@ size_of_test!(cow_rc_str, CowRcStr, 16); size_of_test!(tokenizer, ::tokenizer::Tokenizer, 72); -size_of_test!(parser_input, ::parser::ParserInput, if cfg!(rustc_has_pr45225) { 136 } else { 144 }); +size_of_test!( + parser_input, + ::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!(basic_parse_error, ::BasicParseError, 48); -size_of_test!(parse_error_lower_bound, ::ParseError<()>, if cfg!(rustc_has_pr45225) { 48 } else { 56 }); +size_of_test!( + parse_error_lower_bound, + ::ParseError<()>, + if cfg!(rustc_has_pr45225) { 48 } else { 56 } +); diff --git a/third_party/rust/cssparser/src/tests.rs b/third_party/rust/cssparser/src/tests.rs --- a/third_party/rust/cssparser/src/tests.rs +++ b/third_party/rust/cssparser/src/tests.rs @@ -11,14 +11,13 @@ #[cfg(feature = "bench")] use self::test::Bencher; -use super::{Parser, Delimiter, Token, SourceLocation, - ParseError, ParseErrorKind, BasicParseError, BasicParseErrorKind, - DeclarationListParser, DeclarationParser, RuleListParser, - AtRuleType, AtRuleParser, QualifiedRuleParser, ParserInput, - parse_one_declaration, parse_one_rule, parse_important, - stylesheet_encoding, EncodingSupport, - TokenSerializationType, CowRcStr, - Color, RGBA, parse_nth, UnicodeRange, ToCss}; +use super::{ + parse_important, parse_nth, parse_one_declaration, parse_one_rule, stylesheet_encoding, + AtRuleParser, AtRuleType, BasicParseError, BasicParseErrorKind, Color, CowRcStr, + DeclarationListParser, DeclarationParser, Delimiter, EncodingSupport, ParseError, + ParseErrorKind, Parser, ParserInput, QualifiedRuleParser, RuleListParser, SourceLocation, + ToCss, Token, TokenSerializationType, UnicodeRange, RGBA, +}; macro_rules! JArray { ($($e: expr,)*) => { JArray![ $( $e ),* ] }; @@ -37,9 +36,11 @@ (&Json::Boolean(a), &Json::Boolean(b)) => a == b, (&Json::String(ref a), &Json::String(ref b)) => a == b, (&Json::Array(ref a), &Json::Array(ref b)) => { - a.len() == b.len() && - a.iter().zip(b.iter()).all(|(ref a, ref b)| almost_equals(*a, *b)) - }, + a.len() == b.len() + && a.iter() + .zip(b.iter()) + .all(|(ref a, ref b)| almost_equals(*a, *b)) + } (&Json::Object(_), &Json::Object(_)) => panic!("Not implemented"), (&Json::Null, &Json::Null) => true, _ => false, @@ -65,11 +66,14 @@ fn assert_json_eq(results: json::Json, mut expected: json::Json, message: &str) { normalize(&mut expected); if !almost_equals(&results, &expected) { - println!("{}", ::difference::Changeset::new( - &results.pretty().to_string(), - &expected.pretty().to_string(), - "\n", - )); + println!( + "{}", + ::difference::Changeset::new( + &results.pretty().to_string(), + &expected.pretty().to_string(), + "\n", + ) + ); panic!("{}", message) } } @@ -77,7 +81,7 @@ fn run_raw_json_tests<F: Fn(Json, Json) -> ()>(json_data: &str, run: F) { let items = match Json::from_str(json_data) { Ok(Json::Array(items)) => items, - _ => panic!("Invalid JSON") + _ => panic!("Invalid JSON"), }; assert!(items.len() % 2 == 0); let mut input = None; @@ -87,82 +91,88 @@ (&Some(_), expected) => { let input = input.take().unwrap(); run(input, expected) - }, + } }; } } - fn run_json_tests<F: Fn(&mut Parser) -> Json>(json_data: &str, parse: F) { - run_raw_json_tests(json_data, |input, expected| { - match input { - Json::String(input) => { - let mut parse_input = ParserInput::new(&input); - let result = parse(&mut Parser::new(&mut parse_input)); - assert_json_eq(result, expected, &input); - }, - _ => panic!("Unexpected JSON") - } + run_raw_json_tests(json_data, |input, expected| match input { + Json::String(input) => { + let mut parse_input = ParserInput::new(&input); + let result = parse(&mut Parser::new(&mut parse_input)); + assert_json_eq(result, expected, &input); + } + _ => panic!("Unexpected JSON"), }); } - #[test] fn component_value_list() { - run_json_tests(include_str!("css-parsing-tests/component_value_list.json"), |input| { - Json::Array(component_values_to_json(input)) - }); -} - + run_json_tests( + include_str!("css-parsing-tests/component_value_list.json"), + |input| Json::Array(component_values_to_json(input)), + ); +} #[test] fn one_component_value() { - run_json_tests(include_str!("css-parsing-tests/one_component_value.json"), |input| { - let result: Result<Json, ParseError<()>> = input.parse_entirely(|input| { - Ok(one_component_value_to_json(input.next()?.clone(), input)) - }); - result.unwrap_or(JArray!["error", "invalid"]) - }); -} - + run_json_tests( + include_str!("css-parsing-tests/one_component_value.json"), + |input| { + let result: Result<Json, ParseError<()>> = input.parse_entirely(|input| { + Ok(one_component_value_to_json(input.next()?.clone(), input)) + }); + result.unwrap_or(JArray!["error", "invalid"]) + }, + ); +} #[test] fn declaration_list() { - run_json_tests(include_str!("css-parsing-tests/declaration_list.json"), |input| { - Json::Array(DeclarationListParser::new(input, JsonParser).map(|result| { - result.unwrap_or(JArray!["error", "invalid"]) - }).collect()) - }); -} - + run_json_tests( + include_str!("css-parsing-tests/declaration_list.json"), + |input| { + Json::Array( + DeclarationListParser::new(input, JsonParser) + .map(|result| result.unwrap_or(JArray!["error", "invalid"])) + .collect(), + ) + }, + ); +} #[test] fn one_declaration() { - run_json_tests(include_str!("css-parsing-tests/one_declaration.json"), |input| { - parse_one_declaration(input, &mut JsonParser).unwrap_or(JArray!["error", "invalid"]) - }); -} - + run_json_tests( + include_str!("css-parsing-tests/one_declaration.json"), + |input| { + parse_one_declaration(input, &mut JsonParser).unwrap_or(JArray!["error", "invalid"]) + }, + ); +} #[test] fn rule_list() { run_json_tests(include_str!("css-parsing-tests/rule_list.json"), |input| { - Json::Array(RuleListParser::new_for_nested_rule(input, JsonParser).map(|result| { - result.unwrap_or(JArray!["error", "invalid"]) - }).collect()) + Json::Array( + RuleListParser::new_for_nested_rule(input, JsonParser) + .map(|result| result.unwrap_or(JArray!["error", "invalid"])) + .collect(), + ) }); } - #[test] fn stylesheet() { run_json_tests(include_str!("css-parsing-tests/stylesheet.json"), |input| { - Json::Array(RuleListParser::new_for_stylesheet(input, JsonParser).map(|result| { - result.unwrap_or(JArray!["error", "invalid"]) - }).collect()) + Json::Array( + RuleListParser::new_for_stylesheet(input, JsonParser) + .map(|result| result.unwrap_or(JArray!["error", "invalid"])) + .collect(), + ) }); } - #[test] fn one_rule() { @@ -171,7 +181,6 @@ }); } - #[test] fn stylesheet_from_bytes() { pub struct EncodingRs; @@ -184,8 +193,7 @@ } fn is_utf16_be_or_le(encoding: &Self::Encoding) -> bool { - *encoding == encoding_rs::UTF_16LE || - *encoding == encoding_rs::UTF_16BE + *encoding == encoding_rs::UTF_16LE || *encoding == encoding_rs::UTF_16BE } fn from_label(ascii_label: &[u8]) -> Option<Self::Encoding> { @@ -193,37 +201,45 @@ } } - - run_raw_json_tests(include_str!("css-parsing-tests/stylesheet_bytes.json"), - |input, expected| { - let map = match input { - Json::Object(map) => map, - _ => panic!("Unexpected JSON") - }; - - let result = { - let css = get_string(&map, "css_bytes").unwrap().chars().map(|c| { - assert!(c as u32 <= 0xFF); - c as u8 - }).collect::<Vec<u8>>(); - let protocol_encoding_label = get_string(&map, "protocol_encoding") - .map(|s| s.as_bytes()); - let environment_encoding = get_string(&map, "environment_encoding") - .map(|s| s.as_bytes()) - .and_then(EncodingRs::from_label); - - let encoding = stylesheet_encoding::<EncodingRs>( - &css, protocol_encoding_label, environment_encoding); - let (css_unicode, used_encoding, _) = encoding.decode(&css); - let mut input = ParserInput::new(&css_unicode); - let input = &mut Parser::new(&mut input); - let rules = RuleListParser::new_for_stylesheet(input, JsonParser) - .map(|result| result.unwrap_or(JArray!["error", "invalid"])) - .collect::<Vec<_>>(); - JArray![rules, used_encoding.name().to_lowercase()] - }; - assert_json_eq(result, expected, &Json::Object(map).to_string()); - }); + run_raw_json_tests( + include_str!("css-parsing-tests/stylesheet_bytes.json"), + |input, expected| { + let map = match input { + Json::Object(map) => map, + _ => panic!("Unexpected JSON"), + }; + + let result = { + let css = get_string(&map, "css_bytes") + .unwrap() + .chars() + .map(|c| { + assert!(c as u32 <= 0xFF); + c as u8 + }) + .collect::<Vec<u8>>(); + let protocol_encoding_label = + get_string(&map, "protocol_encoding").map(|s| s.as_bytes()); + let environment_encoding = get_string(&map, "environment_encoding") + .map(|s| s.as_bytes()) + .and_then(EncodingRs::from_label); + + let encoding = stylesheet_encoding::<EncodingRs>( + &css, + protocol_encoding_label, + environment_encoding, + ); + let (css_unicode, used_encoding, _) = encoding.decode(&css); + let mut input = ParserInput::new(&css_unicode); + let input = &mut Parser::new(&mut input); + let rules = RuleListParser::new_for_stylesheet(input, JsonParser) + .map(|result| result.unwrap_or(JArray!["error", "invalid"])) + .collect::<Vec<_>>(); + JArray![rules, used_encoding.name().to_lowercase()] + }; + assert_json_eq(result, expected, &Json::Object(map).to_string()); + }, + ); fn get_string<'a>(map: &'a json::Object, key: &str) -> Option<&'a str> { match map.get(key) { @@ -234,7 +250,6 @@ } } } - #[test] fn expect_no_error_token() { @@ -256,16 +271,17 @@ assert!(Parser::new(&mut input).expect_no_error_token().is_err()); } - /// https://github.com/servo/rust-cssparser/issues/71 #[test] fn outer_block_end_consumed() { let mut input = ParserInput::new("(calc(true))"); let mut input = Parser::new(&mut input); assert!(input.expect_parenthesis_block().is_ok()); - assert!(input.parse_nested_block(|input| { - input.expect_function_matching("calc").map_err(Into::<ParseError<()>>::into) - }).is_ok()); + assert!(input + .parse_nested_block(|input| input + .expect_function_matching("calc") + .map_err(Into::<ParseError<()>>::into)) + .is_ok()); println!("{:?}", input.position()); assert!(input.next().is_err()); } @@ -275,7 +291,7 @@ fn bad_url_slice_out_of_bounds() { let mut input = ParserInput::new("url(\u{1}\\"); let mut parser = Parser::new(&mut input); - let result = parser.next_including_whitespace_and_comments(); // This used to panic + let result = parser.next_including_whitespace_and_comments(); // This used to panic assert_eq!(result, Ok(&Token::BadUrl("\u{1}\\".into()))); } @@ -284,27 +300,33 @@ fn bad_url_slice_not_at_char_boundary() { let mut input = ParserInput::new("url(9\n۰"); let mut parser = Parser::new(&mut input); - let result = parser.next_including_whitespace_and_comments(); // This used to panic + let result = parser.next_including_whitespace_and_comments(); // This used to panic assert_eq!(result, Ok(&Token::BadUrl("9\n۰".into()))); } #[test] fn unquoted_url_escaping() { - let token = Token::UnquotedUrl("\ - \x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\ - \x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f \ - !\"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]\ - ^_`abcdefghijklmnopqrstuvwxyz{|}~\x7fé\ - ".into()); + let token = Token::UnquotedUrl( + "\ + \x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\ + \x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f \ + !\"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]\ + ^_`abcdefghijklmnopqrstuvwxyz{|}~\x7fé\ + " + .into(), + ); let serialized = token.to_css_string(); - assert_eq!(serialized, "\ - url(\ - \\1 \\2 \\3 \\4 \\5 \\6 \\7 \\8 \\9 \\a \\b \\c \\d \\e \\f \\10 \ - \\11 \\12 \\13 \\14 \\15 \\16 \\17 \\18 \\19 \\1a \\1b \\1c \\1d \\1e \\1f \\20 \ - !\\\"#$%&\\'\\(\\)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]\ - ^_`abcdefghijklmnopqrstuvwxyz{|}~\\7f é\ - )\ - "); + assert_eq!( + serialized, + "\ + url(\ + \\1 \\2 \\3 \\4 \\5 \\6 \\7 \\8 \\9 \\a \\b \\c \\d \\e \\f \\10 \ + \\11 \\12 \\13 \\14 \\15 \\16 \\17 \\18 \\19 \\1a \\1b \\1c \\1d \\1e \\1f \\20 \ + !\\\"#$%&\\'\\(\\)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]\ + ^_`abcdefghijklmnopqrstuvwxyz{|}~\\7f é\ + )\ + " + ); let mut input = ParserInput::new(&serialized); assert_eq!(Parser::new(&mut input).next(), Ok(&token)); } @@ -332,43 +354,47 @@ assert!(parse(&mut input).is_err()); } - fn run_color_tests<F: Fn(Result<Color, ()>) -> Json>(json_data: &str, to_json: F) { run_json_tests(json_data, |input| { - let result: Result<_, ParseError<()>> = input.parse_entirely(|i| { - Color::parse(i).map_err(Into::into) - }); + let result: Result<_, ParseError<()>> = + input.parse_entirely(|i| Color::parse(i).map_err(Into::into)); to_json(result.map_err(|_| ())) }); } - #[test] fn color3() { - run_color_tests(include_str!("css-parsing-tests/color3.json"), |c| c.ok().to_json()) -} - + run_color_tests(include_str!("css-parsing-tests/color3.json"), |c| { + c.ok().to_json() + }) +} #[test] fn color3_hsl() { - run_color_tests(include_str!("css-parsing-tests/color3_hsl.json"), |c| c.ok().to_json()) -} - + run_color_tests(include_str!("css-parsing-tests/color3_hsl.json"), |c| { + c.ok().to_json() + }) +} /// color3_keywords.json is different: R, G and B are in 0..255 rather than 0..1 #[test] fn color3_keywords() { - run_color_tests(include_str!("css-parsing-tests/color3_keywords.json"), |c| c.ok().to_json()) -} - + run_color_tests( + include_str!("css-parsing-tests/color3_keywords.json"), + |c| c.ok().to_json(), + ) +} #[test] fn nth() { run_json_tests(include_str!("css-parsing-tests/An+B.json"), |input| { - input.parse_entirely(|i| { - let result: Result<_, ParseError<()>> = parse_nth(i).map_err(Into::into); - result - }).ok().to_json() + input + .parse_entirely(|i| { + let result: Result<_, ParseError<()>> = parse_nth(i).map_err(Into::into); + result + }) + .ok() + .to_json() }); } @@ -388,7 +414,6 @@ }); } - #[test] fn serializer_not_preserving_comments() { serializer(false) @@ -400,44 +425,59 @@ } fn serializer(preserve_comments: bool) { - run_json_tests(include_str!("css-parsing-tests/component_value_list.json"), |input| { - fn write_to(mut previous_token: TokenSerializationType, - input: &mut Parser, - string: &mut String, - preserve_comments: bool) { - while let Ok(token) = if preserve_comments { - input.next_including_whitespace_and_comments().map(|t| t.clone()) - } else { - input.next_including_whitespace().map(|t| t.clone()) - } { - let token_type = token.serialization_type(); - if !preserve_comments && previous_token.needs_separator_when_before(token_type) { - string.push_str("/**/") - } - previous_token = token_type; - token.to_css(string).unwrap(); - let closing_token = match token { - Token::Function(_) | Token::ParenthesisBlock => Some(Token::CloseParenthesis), - Token::SquareBracketBlock => Some(Token::CloseSquareBracket), - Token::CurlyBracketBlock => Some(Token::CloseCurlyBracket), - _ => 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(()) - }); - result.unwrap(); - closing_token.to_css(string).unwrap(); + run_json_tests( + include_str!("css-parsing-tests/component_value_list.json"), + |input| { + fn write_to( + mut previous_token: TokenSerializationType, + input: &mut Parser, + string: &mut String, + preserve_comments: bool, + ) { + while let Ok(token) = if preserve_comments { + input + .next_including_whitespace_and_comments() + .map(|t| t.clone()) + } else { + input.next_including_whitespace().map(|t| t.clone()) + } { + let token_type = token.serialization_type(); + if !preserve_comments && previous_token.needs_separator_when_before(token_type) + { + string.push_str("/**/") + } + previous_token = token_type; + token.to_css(string).unwrap(); + let closing_token = match token { + Token::Function(_) | Token::ParenthesisBlock => { + Some(Token::CloseParenthesis) + } + Token::SquareBracketBlock => Some(Token::CloseSquareBracket), + Token::CurlyBracketBlock => Some(Token::CloseCurlyBracket), + _ => 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(()) + }); + result.unwrap(); + closing_token.to_css(string).unwrap(); + } } } - } - let mut serialized = String::new(); - write_to(TokenSerializationType::nothing(), input, &mut serialized, preserve_comments); - let mut input = ParserInput::new(&serialized); - let parser = &mut Parser::new(&mut input); - Json::Array(component_values_to_json(parser)) - }); + let mut serialized = String::new(); + write_to( + TokenSerializationType::nothing(), + input, + &mut serialized, + preserve_comments, + ); + let mut input = ParserInput::new(&serialized); + let parser = &mut Parser::new(&mut input); + Json::Array(component_values_to_json(parser)) + }, + ); } #[test] @@ -497,36 +537,90 @@ "b\"" )); let mut input = Parser::new(&mut input); - assert_eq!(input.current_source_location(), SourceLocation { line: 0, column: 1 }); - assert_eq!(input.next_including_whitespace(), Ok(&Token::Ident("fo00o".into()))); - assert_eq!(input.current_source_location(), SourceLocation { line: 1, column: 3 }); - assert_eq!(input.next_including_whitespace(), Ok(&Token::WhiteSpace(" "))); - assert_eq!(input.current_source_location(), SourceLocation { line: 1, column: 4 }); - assert_eq!(input.next_including_whitespace(), Ok(&Token::Ident("bar".into()))); - assert_eq!(input.current_source_location(), SourceLocation { line: 1, column: 7 }); - assert_eq!(input.next_including_whitespace_and_comments(), Ok(&Token::Comment("\n"))); - assert_eq!(input.current_source_location(), SourceLocation { line: 2, column: 3 }); - assert_eq!(input.next_including_whitespace(), Ok(&Token::Ident("baz".into()))); - assert_eq!(input.current_source_location(), SourceLocation { line: 2, column: 6 }); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 0, column: 1 } + ); + assert_eq!( + input.next_including_whitespace(), + Ok(&Token::Ident("fo00o".into())) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 1, column: 3 } + ); + assert_eq!( + input.next_including_whitespace(), + Ok(&Token::WhiteSpace(" ")) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 1, column: 4 } + ); + assert_eq!( + input.next_including_whitespace(), + Ok(&Token::Ident("bar".into())) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 1, column: 7 } + ); + assert_eq!( + input.next_including_whitespace_and_comments(), + Ok(&Token::Comment("\n")) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 2, column: 3 } + ); + assert_eq!( + input.next_including_whitespace(), + Ok(&Token::Ident("baz".into())) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 2, column: 6 } + ); let state = input.state(); - assert_eq!(input.next_including_whitespace(), Ok(&Token::WhiteSpace("\r\n\n"))); - assert_eq!(input.current_source_location(), SourceLocation { line: 4, column: 1 }); - - assert_eq!(state.source_location(), SourceLocation { line: 2, column: 6 }); - - assert_eq!(input.next_including_whitespace(), Ok(&Token::UnquotedUrl("u".into()))); - assert_eq!(input.current_source_location(), SourceLocation { line: 6, column: 2 }); - - assert_eq!(input.next_including_whitespace(), Ok(&Token::QuotedString("ab".into()))); - assert_eq!(input.current_source_location(), SourceLocation { line: 7, column: 3 }); + assert_eq!( + input.next_including_whitespace(), + Ok(&Token::WhiteSpace("\r\n\n")) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 4, column: 1 } + ); + + assert_eq!( + state.source_location(), + SourceLocation { line: 2, column: 6 } + ); + + assert_eq!( + input.next_including_whitespace(), + Ok(&Token::UnquotedUrl("u".into())) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 6, column: 2 } + ); + + assert_eq!( + input.next_including_whitespace(), + Ok(&Token::QuotedString("ab".into())) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 7, column: 3 } + ); assert!(input.next_including_whitespace().is_err()); } #[test] fn overflow() { + use std::f32; use std::iter::repeat; - use std::f32; let css = r" 2147483646 @@ -551,7 +645,8 @@ -3.40282347e+38 -3.402824e+38 - ".replace("{309 zeros}", &repeat('0').take(309).collect::<String>()); + " + .replace("{309 zeros}", &repeat('0').take(309).collect::<String>()); let mut input = ParserInput::new(&css); let mut input = Parser::new(&mut input); @@ -586,9 +681,11 @@ let mut input = Parser::new(&mut input); assert_eq!(input.next(), Ok(&Token::CurlyBracketBlock)); assert!({ - let result: Result<_, ParseError<()>> = input.parse_until_after(Delimiter::Semicolon, |_| Ok(42)); + let result: Result<_, ParseError<()>> = + input.parse_until_after(Delimiter::Semicolon, |_| Ok(42)); result - }.is_err()); + } + .is_err()); assert_eq!(input.next(), Ok(&Token::Comma)); assert!(input.next().is_err()); } @@ -603,9 +700,18 @@ // Replacement character assert_eq!(Token::Ident("\u{FFFD}".into()).to_css_string(), "\u{FFFD}"); - assert_eq!(Token::Ident("a\u{FFFD}".into()).to_css_string(), "a\u{FFFD}"); - assert_eq!(Token::Ident("\u{FFFD}b".into()).to_css_string(), "\u{FFFD}b"); - assert_eq!(Token::Ident("a\u{FFFD}b".into()).to_css_string(), "a\u{FFFD}b"); + assert_eq!( + Token::Ident("a\u{FFFD}".into()).to_css_string(), + "a\u{FFFD}" + ); + assert_eq!( + Token::Ident("\u{FFFD}b".into()).to_css_string(), + "\u{FFFD}b" + ); + assert_eq!( + Token::Ident("a\u{FFFD}b".into()).to_css_string(), + "a\u{FFFD}b" + ); // Number prefix assert_eq!(Token::Ident("0a".into()).to_css_string(), "\\30 a"); @@ -647,30 +753,52 @@ assert_eq!(Token::Ident("--a".into()).to_css_string(), "--a"); // Various tests - assert_eq!(Token::Ident("\x01\x02\x1E\x1F".into()).to_css_string(), "\\1 \\2 \\1e \\1f "); - assert_eq!(Token::Ident("\u{0080}\x2D\x5F\u{00A9}".into()).to_css_string(), "\u{0080}\x2D\x5F\u{00A9}"); + assert_eq!( + Token::Ident("\x01\x02\x1E\x1F".into()).to_css_string(), + "\\1 \\2 \\1e \\1f " + ); + assert_eq!( + Token::Ident("\u{0080}\x2D\x5F\u{00A9}".into()).to_css_string(), + "\u{0080}\x2D\x5F\u{00A9}" + ); assert_eq!(Token::Ident("\x7F\u{0080}\u{0081}\u{0082}\u{0083}\u{0084}\u{0085}\u{0086}\u{0087}\u{0088}\u{0089}\ \u{008A}\u{008B}\u{008C}\u{008D}\u{008E}\u{008F}\u{0090}\u{0091}\u{0092}\u{0093}\u{0094}\u{0095}\u{0096}\ \u{0097}\u{0098}\u{0099}\u{009A}\u{009B}\u{009C}\u{009D}\u{009E}\u{009F}".into()).to_css_string(), "\\7f \u{0080}\u{0081}\u{0082}\u{0083}\u{0084}\u{0085}\u{0086}\u{0087}\u{0088}\u{0089}\u{008A}\u{008B}\u{008C}\ \u{008D}\u{008E}\u{008F}\u{0090}\u{0091}\u{0092}\u{0093}\u{0094}\u{0095}\u{0096}\u{0097}\u{0098}\u{0099}\ \u{009A}\u{009B}\u{009C}\u{009D}\u{009E}\u{009F}"); - assert_eq!(Token::Ident("\u{00A0}\u{00A1}\u{00A2}".into()).to_css_string(), "\u{00A0}\u{00A1}\u{00A2}"); - assert_eq!(Token::Ident("a0123456789b".into()).to_css_string(), "a0123456789b"); - assert_eq!(Token::Ident("abcdefghijklmnopqrstuvwxyz".into()).to_css_string(), "abcdefghijklmnopqrstuvwxyz"); - assert_eq!(Token::Ident("ABCDEFGHIJKLMNOPQRSTUVWXYZ".into()).to_css_string(), "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); - assert_eq!(Token::Ident("\x20\x21\x78\x79".into()).to_css_string(), "\\ \\!xy"); + assert_eq!( + Token::Ident("\u{00A0}\u{00A1}\u{00A2}".into()).to_css_string(), + "\u{00A0}\u{00A1}\u{00A2}" + ); + assert_eq!( + Token::Ident("a0123456789b".into()).to_css_string(), + "a0123456789b" + ); + assert_eq!( + Token::Ident("abcdefghijklmnopqrstuvwxyz".into()).to_css_string(), + "abcdefghijklmnopqrstuvwxyz" + ); + assert_eq!( + Token::Ident("ABCDEFGHIJKLMNOPQRSTUVWXYZ".into()).to_css_string(), + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + ); + assert_eq!( + Token::Ident("\x20\x21\x78\x79".into()).to_css_string(), + "\\ \\!xy" + ); // astral symbol (U+1D306 TETRAGRAM FOR CENTRE) - assert_eq!(Token::Ident("\u{1D306}".into()).to_css_string(), "\u{1D306}"); + assert_eq!( + Token::Ident("\u{1D306}".into()).to_css_string(), + "\u{1D306}" + ); } impl ToJson for Color { fn to_json(&self) -> json::Json { match *self { - Color::RGBA(ref rgba) => { - [rgba.red, rgba.green, rgba.blue, rgba.alpha].to_json() - }, + Color::RGBA(ref rgba) => [rgba.red, rgba.green, rgba.blue, rgba.alpha].to_json(), Color::CurrentColor => "currentcolor".to_json(), } } @@ -687,7 +815,7 @@ let mut input = Parser::new(&mut input); input.look_for_var_or_env_functions(); - let result = input.try(|input| input.expect_url()); + let result = input.try_parse(|input| input.expect_url()); assert!(result.is_ok()); @@ -695,7 +823,6 @@ (result.is_ok(), input.seen_var_or_env_functions()) }) } - #[cfg(feature = "bench")] #[bench] @@ -720,15 +847,18 @@ } let mut input = ParserInput::new(&input); let mut input = Parser::new(&mut input); - while let Ok(..) = input.next() { } + while let Ok(..) = input.next() {} } impl<'i> DeclarationParser<'i> for JsonParser { type Declaration = Json; type Error = (); - fn parse_value<'t>(&mut self, name: CowRcStr<'i>, input: &mut Parser<'i, 't>) - -> Result<Json, ParseError<'i, ()>> { + fn parse_value<'t>( + &mut self, + name: CowRcStr<'i>, + input: &mut Parser<'i, 't>, + ) -> Result<Json, ParseError<'i, ()>> { let mut value = vec![]; let mut important = false; loop { @@ -743,7 +873,7 @@ if parse_important(input).is_ok() { if input.is_exhausted() { important = true; - break + break; } } input.reset(&start); @@ -751,15 +881,10 @@ } value.push(one_component_value_to_json(token, input)); } else { - break + break; } } - Ok(JArray![ - "declaration", - name, - value, - important, - ]) + Ok(JArray!["declaration", name, value, important,]) } } @@ -769,8 +894,11 @@ type AtRule = Json; type Error = (); - fn parse_prelude<'t>(&mut self, name: CowRcStr<'i>, input: &mut Parser<'i, 't>) - -> Result<AtRuleType<Vec<Json>, Vec<Json>>, ParseError<'i, ()>> { + fn parse_prelude<'t>( + &mut self, + name: CowRcStr<'i>, + input: &mut Parser<'i, 't>, + ) -> Result<AtRuleType<Vec<Json>, Vec<Json>>, ParseError<'i, ()>> { let prelude = vec![ "at-rule".to_json(), name.to_json(), @@ -785,11 +913,7 @@ } } - fn rule_without_block( - &mut self, - mut prelude: Vec<Json>, - _location: SourceLocation, - ) -> Json { + fn rule_without_block(&mut self, mut prelude: Vec<Json>, _location: SourceLocation) -> Json { prelude.push(Json::Null); Json::Array(prelude) } @@ -810,7 +934,10 @@ type QualifiedRule = Json; type Error = (); - fn parse_prelude<'t>(&mut self, input: &mut Parser<'i, 't>) -> Result<Vec<Json>, ParseError<'i, ()>> { + fn parse_prelude<'t>( + &mut self, + input: &mut Parser<'i, 't>, + ) -> Result<Vec<Json>, ParseError<'i, ()>> { Ok(component_values_to_json(input)) } @@ -843,16 +970,24 @@ value: value, int_value: int_value, has_sign: has_sign, - }.to_css_string().to_json(), - match int_value { Some(i) => i.to_json(), None => value.to_json() }, - match int_value { Some(_) => "integer", None => "number" }.to_json() + } + .to_css_string() + .to_json(), + match int_value { + Some(i) => i.to_json(), + None => value.to_json(), + }, + match int_value { + Some(_) => "integer", + None => "number", + } + .to_json(), ] } fn nested(input: &mut Parser) -> Vec<Json> { - let result: Result<_, ParseError<()>> = input.parse_nested_block(|input| { - Ok(component_values_to_json(input)) - }); + let result: Result<_, ParseError<()>> = + input.parse_nested_block(|input| Ok(component_values_to_json(input))); result.unwrap() } @@ -866,17 +1001,30 @@ Token::Delim('\\') => "\\".to_json(), Token::Delim(value) => value.to_string().to_json(), - Token::Number { value, int_value, has_sign } => Json::Array({ + Token::Number { + value, + int_value, + has_sign, + } => Json::Array({ let mut v = vec!["number".to_json()]; v.extend(numeric(value, int_value, has_sign)); v }), - Token::Percentage { unit_value, int_value, has_sign } => Json::Array({ + Token::Percentage { + unit_value, + int_value, + has_sign, + } => Json::Array({ let mut v = vec!["percentage".to_json()]; v.extend(numeric(unit_value * 100., int_value, has_sign)); v }), - Token::Dimension { value, int_value, has_sign, unit } => Json::Array({ + Token::Dimension { + value, + int_value, + has_sign, + unit, + } => Json::Array({ let mut v = vec!["dimension".to_json()]; v.extend(numeric(value, int_value, has_sign)); v.push(unit.to_json()); @@ -955,12 +1103,13 @@ // For all j and k, inputs[i].1[j] should parse the same as inputs[i].1[k] // when we use delimiters inputs[i].0. let inputs = vec![ - (Delimiter::Bang | Delimiter::Semicolon, - // Note that the ';extra' is fine, because the ';' acts the same as - // the end of input. - vec!["token stream;extra", "token stream!", "token stream"]), - (Delimiter::Bang | Delimiter::Semicolon, - vec![";", "!", ""]), + ( + Delimiter::Bang | Delimiter::Semicolon, + // Note that the ';extra' is fine, because the ';' acts the same as + // the end of input. + vec!["token stream;extra", "token stream!", "token stream"], + ), + (Delimiter::Bang | Delimiter::Semicolon, vec![";", "!", ""]), ]; for equivalent in inputs { for (j, x) in equivalent.1.iter().enumerate() { @@ -978,7 +1127,7 @@ let oy = iy.next(); assert_eq!(ox, oy); if let Err(_) = ox { - break + break; } } Ok(()) @@ -1012,14 +1161,46 @@ fn parser_with_line_number_offset() { let mut input = ParserInput::new_with_line_number_offset("ident\nident", 72); let mut parser = Parser::new(&mut input); - assert_eq!(parser.current_source_location(), SourceLocation { line: 72, column: 1 }); - assert_eq!(parser.next_including_whitespace_and_comments(), Ok(&Token::Ident("ident".into()))); - assert_eq!(parser.current_source_location(), SourceLocation { line: 72, column: 6 }); - assert_eq!(parser.next_including_whitespace_and_comments(), - Ok(&Token::WhiteSpace("\n".into()))); - assert_eq!(parser.current_source_location(), SourceLocation { line: 73, column: 1 }); - assert_eq!(parser.next_including_whitespace_and_comments(), Ok(&Token::Ident("ident".into()))); - assert_eq!(parser.current_source_location(), SourceLocation { line: 73, column: 6 }); + assert_eq!( + parser.current_source_location(), + SourceLocation { + line: 72, + column: 1 + } + ); + assert_eq!( + parser.next_including_whitespace_and_comments(), + Ok(&Token::Ident("ident".into())) + ); + assert_eq!( + parser.current_source_location(), + SourceLocation { + line: 72, + column: 6 + } + ); + assert_eq!( + parser.next_including_whitespace_and_comments(), + Ok(&Token::WhiteSpace("\n".into())) + ); + assert_eq!( + parser.current_source_location(), + SourceLocation { + line: 73, + column: 1 + } + ); + assert_eq!( + parser.next_including_whitespace_and_comments(), + Ok(&Token::Ident("ident".into())) + ); + assert_eq!( + parser.current_source_location(), + SourceLocation { + line: 73, + column: 6 + } + ); } #[test] @@ -1028,23 +1209,31 @@ let mut parser = Parser::new(&mut input); parser.skip_cdc_and_cdo(); assert_eq!(parser.next(), Ok(&Token::Ident("x".into()))); - assert_eq!(parser.next(), Err(BasicParseError { - kind: BasicParseErrorKind::EndOfInput, - location: SourceLocation { line: 0, column: 5 } - })); + assert_eq!( + parser.next(), + Err(BasicParseError { + kind: BasicParseErrorKind::EndOfInput, + location: SourceLocation { line: 0, column: 5 } + }) + ); } #[test] fn parse_entirely_reports_first_error() { #[derive(PartialEq, Debug)] - enum E { Foo } + enum E { + Foo, + } let mut input = ParserInput::new("ident"); let mut parser = Parser::new(&mut input); let result: Result<(), _> = parser.parse_entirely(|p| Err(p.new_custom_error(E::Foo))); - assert_eq!(result, Err(ParseError { - kind: ParseErrorKind::Custom(E::Foo), - location: SourceLocation { line: 0, column: 1 }, - })); + assert_eq!( + result, + Err(ParseError { + kind: ParseErrorKind::Custom(E::Foo), + location: SourceLocation { line: 0, column: 1 }, + }) + ); } #[test] @@ -1053,21 +1242,23 @@ ("/*# sourceMappingURL=here*/", Some("here")), ("/*# sourceMappingURL=here */", Some("here")), ("/*@ sourceMappingURL=here*/", Some("here")), - ("/*@ sourceMappingURL=there*/ /*# sourceMappingURL=here*/", Some("here")), + ( + "/*@ sourceMappingURL=there*/ /*# sourceMappingURL=here*/", + Some("here"), + ), ("/*# sourceMappingURL=here there */", Some("here")), ("/*# sourceMappingURL= here */", Some("")), ("/*# sourceMappingURL=*/", Some("")), ("/*# sourceMappingUR=here */", None), ("/*! sourceMappingURL=here */", None), ("/*# sourceMappingURL = here */", None), - ("/* # sourceMappingURL=here */", None) + ("/* # sourceMappingURL=here */", None), ]; for test in tests { let mut input = ParserInput::new(test.0); let mut parser = Parser::new(&mut input); - while let Ok(_) = parser.next_including_whitespace() { - } + while let Ok(_) = parser.next_including_whitespace() {} assert_eq!(parser.current_source_map_url(), test.1); } } @@ -1085,14 +1276,13 @@ ("/*# sourceMappingUR=here */", None), ("/*! sourceURL=here */", None), ("/*# sourceURL = here */", None), - ("/* # sourceURL=here */", None) + ("/* # sourceURL=here */", None), ]; for test in tests { let mut input = ParserInput::new(test.0); let mut parser = Parser::new(&mut input); - while let Ok(_) = parser.next_including_whitespace() { - } + while let Ok(_) = parser.next_including_whitespace() {} assert_eq!(parser.current_source_url(), test.1); } } @@ -1158,8 +1348,15 @@ // Read all tokens. loop { match parser.next() { - Err(BasicParseError { kind: BasicParseErrorKind::EndOfInput, .. }) => { break; } - Err(_) => { assert!(false); } + Err(BasicParseError { + kind: BasicParseErrorKind::EndOfInput, + .. + }) => { + break; + } + Err(_) => { + assert!(false); + } Ok(_) => {} }; } diff --git a/third_party/rust/cssparser/src/tokenizer.rs b/third_party/rust/cssparser/src/tokenizer.rs --- a/third_party/rust/cssparser/src/tokenizer.rs +++ b/third_party/rust/cssparser/src/tokenizer.rs @@ -4,15 +4,13 @@ // https://drafts.csswg.org/css-syntax/#tokenization +use std::char; +use std::i32; use std::ops::Range; -use std::char; -#[allow(unused_imports)] use std::ascii::AsciiExt; -use std::i32; - + +use self::Token::*; +use cow_rc_str::CowRcStr; use parser::ParserState; -use cow_rc_str::CowRcStr; -use self::Token::*; - /// One of the pieces the CSS input is broken into. /// @@ -20,7 +18,6 @@ /// and avoid allocating/copying when possible. #[derive(PartialEq, Debug, Clone)] pub enum Token<'a> { - /// A [`<ident-token>`](https://drafts.csswg.org/css-syntax/#ident-token-diagram) Ident(CowRcStr<'a>), @@ -37,7 +34,7 @@ /// A [`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with the type flag set to "id" /// /// The value does not include the `#` marker. - IDHash(CowRcStr<'a>), // Hash that is a valid ID selector. + IDHash(CowRcStr<'a>), // Hash that is a valid ID selector. /// A [`<string-token>`](https://drafts.csswg.org/css-syntax/#string-token-diagram) /// @@ -94,7 +91,7 @@ int_value: Option<i32>, /// The unit, e.g. "px" in `12px` - unit: CowRcStr<'a> + unit: CowRcStr<'a>, }, /// A [`<whitespace-token>`](https://drafts.csswg.org/css-syntax/#whitespace-token-diagram) @@ -109,13 +106,13 @@ Comment(&'a str), /// A `:` `<colon-token>` - Colon, // : + Colon, // : /// A `;` `<semicolon-token>` - Semicolon, // ; + Semicolon, // ; /// A `,` `<comma-token>` - Comma, // , + Comma, // , /// A `~=` [`<include-match-token>`](https://drafts.csswg.org/css-syntax/#include-match-token-diagram) IncludeMatch, @@ -180,7 +177,6 @@ /// this token is always unmatched and indicates a parse error. CloseCurlyBracket, } - impl<'a> Token<'a> { /// Return whether this token represents a parse error. @@ -196,7 +192,6 @@ ) } } - #[derive(Clone)] pub struct Tokenizer<'a> { @@ -220,7 +215,6 @@ SeenAtLeastOne, } - impl<'a> Tokenizer<'a> { #[inline] pub fn new(input: &str) -> Tokenizer { @@ -255,9 +249,7 @@ #[inline] pub fn see_function(&mut self, name: &str) { if self.var_or_env_functions == SeenStatus::LookingForThem { - if name.eq_ignore_ascii_case("var") || - name.eq_ignore_ascii_case("env") - { + if name.eq_ignore_ascii_case("var") || name.eq_ignore_ascii_case("env") { self.var_or_env_functions = SeenStatus::SeenAtLeastOne; } } @@ -340,12 +332,16 @@ // If false, `tokenizer.next_char()` will not panic. #[inline] - fn is_eof(&self) -> bool { !self.has_at_least(0) } + fn is_eof(&self) -> bool { + !self.has_at_least(0) + } // If true, the input has at least `n` bytes left *after* the current one. // That is, `tokenizer.char_at(n)` will not panic. #[inline] - fn has_at_least(&self, n: usize) -> bool { self.position + n < self.input.len() } + fn has_at_least(&self, n: usize) -> bool { + self.position + n < self.input.len() + } // Advance over N bytes in the input. This function can advance // over ASCII bytes (excluding newlines), or UTF-8 sequence @@ -367,7 +363,9 @@ // Assumes non-EOF #[inline] - fn next_byte_unchecked(&self) -> u8 { self.byte_at(0) } + fn next_byte_unchecked(&self) -> u8 { + self.byte_at(0) + } #[inline] fn byte_at(&self, offset: usize) -> u8 { @@ -435,8 +433,8 @@ #[inline] fn has_newline_at(&self, offset: usize) -> bool { - self.position + offset < self.input.len() && - matches!(self.byte_at(offset), b'\n' | b'\r' | b'\x0C') + self.position + offset < self.input.len() + && matches!(self.byte_at(offset), b'\n' | b'\r' | b'\x0C') } #[inline] @@ -446,7 +444,9 @@ self.position += len_utf8; // Note that due to the special case for the 4-byte sequence // intro, we must use wrapping add here. - self.current_line_start_position = self.current_line_start_position.wrapping_add(len_utf8 - c.len_utf16()); + self.current_line_start_position = self + .current_line_start_position + .wrapping_add(len_utf8 - c.len_utf16()); c } @@ -520,7 +520,6 @@ #[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)] pub struct SourcePosition(pub(crate) usize); - /// The line and column number for a given position within the input. #[derive(PartialEq, Eq, Debug, Clone, Copy)] pub struct SourceLocation { @@ -532,10 +531,9 @@ pub column: u32, } - fn next_token<'a>(tokenizer: &mut Tokenizer<'a>) -> Result<Token<'a>, ()> { if tokenizer.is_eof() { - return Err(()) + return Err(()); } let b = tokenizer.next_byte_unchecked(); let token = match_byte! { b, @@ -671,7 +669,6 @@ Ok(token) } - fn consume_whitespace<'a>(tokenizer: &mut Tokenizer<'a>, newline: bool) -> Token<'a> { let start_position = tokenizer.position(); if newline { @@ -696,7 +693,6 @@ WhiteSpace(tokenizer.slice_from(start_position)) } - // Check for sourceMappingURL or sourceURL comments and update the // tokenizer appropriately. fn check_for_source_map<'a>(tokenizer: &mut Tokenizer<'a>, contents: &'a str) { @@ -706,9 +702,9 @@ // If there is a source map directive, extract the URL. if contents.starts_with(directive) || contents.starts_with(directive_old) { let contents = &contents[directive.len()..]; - tokenizer.source_map_url = contents.split(|c| { - c == ' ' || c == '\t' || c == '\x0C' || c == '\r' || c == '\n' - }).next() + tokenizer.source_map_url = contents + .split(|c| c == ' ' || c == '\t' || c == '\x0C' || c == '\r' || c == '\n') + .next() } let directive = "# sourceURL="; @@ -717,14 +713,14 @@ // If there is a source map directive, extract the URL. if contents.starts_with(directive) || contents.starts_with(directive_old) { let contents = &contents[directive.len()..]; - tokenizer.source_url = contents.split(|c| { - c == ' ' || c == '\t' || c == '\x0C' || c == '\r' || c == '\n' - }).next() + tokenizer.source_url = contents + .split(|c| c == ' ' || c == '\t' || c == '\x0C' || c == '\r' || c == '\n') + .next() } } fn consume_comment<'a>(tokenizer: &mut Tokenizer<'a>) -> &'a str { - tokenizer.advance(2); // consume "/*" + tokenizer.advance(2); // consume "/*" let start_position = tokenizer.position(); while !tokenizer.is_eof() { match_byte! { tokenizer.next_byte_unchecked(), @@ -757,21 +753,22 @@ fn consume_string<'a>(tokenizer: &mut Tokenizer<'a>, single_quote: bool) -> Token<'a> { match consume_quoted_string(tokenizer, single_quote) { Ok(value) => QuotedString(value), - Err(value) => BadString(value) - } -} - + Err(value) => BadString(value), + } +} /// Return `Err(())` on syntax error (ie. unescaped newline) -fn consume_quoted_string<'a>(tokenizer: &mut Tokenizer<'a>, single_quote: bool) - -> Result<CowRcStr<'a>, CowRcStr<'a>> { - tokenizer.advance(1); // Skip the initial quote - // start_pos is at code point boundary, after " or ' +fn consume_quoted_string<'a>( + tokenizer: &mut Tokenizer<'a>, + single_quote: bool, +) -> Result<CowRcStr<'a>, CowRcStr<'a>> { + tokenizer.advance(1); // Skip the initial quote + // start_pos is at code point boundary, after " or ' let start_pos = tokenizer.position(); let mut string_bytes; loop { if tokenizer.is_eof() { - return Ok(tokenizer.slice_from(start_pos).into()) + return Ok(tokenizer.slice_from(start_pos).into()); } match_byte! { tokenizer.next_byte_unchecked(), b'"' => { @@ -869,29 +866,28 @@ Ok( // string_bytes is well-formed UTF-8, see other comments. - unsafe { from_utf8_release_unchecked(string_bytes) }.into() + unsafe { from_utf8_release_unchecked(string_bytes) }.into(), ) } - #[inline] fn is_ident_start(tokenizer: &mut Tokenizer) -> bool { - !tokenizer.is_eof() && match_byte! { tokenizer.next_byte_unchecked(), - b'a'...b'z' | b'A'...b'Z' | b'_' | b'\0' => { true }, - b'-' => { - tokenizer.has_at_least(1) && match_byte! { tokenizer.byte_at(1), - b'a'...b'z' | b'A'...b'Z' | b'-' | b'_' | b'\0' => { - true - } - b'\\' => { !tokenizer.has_newline_at(1) } - b => { !b.is_ascii() }, - } - }, - b'\\' => { !tokenizer.has_newline_at(1) }, - b => { !b.is_ascii() }, - } -} - + !tokenizer.is_eof() + && match_byte! { tokenizer.next_byte_unchecked(), + b'a'...b'z' | b'A'...b'Z' | b'_' | b'\0' => { true }, + b'-' => { + tokenizer.has_at_least(1) && match_byte! { tokenizer.byte_at(1), + b'a'...b'z' | b'A'...b'Z' | b'-' | b'_' | b'\0' => { + true + } + b'\\' => { !tokenizer.has_newline_at(1) } + b => { !b.is_ascii() }, + } + }, + b'\\' => { !tokenizer.has_newline_at(1) }, + b => { !b.is_ascii() }, + } +} fn consume_ident_like<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> { let value = consume_name(tokenizer); @@ -914,7 +910,7 @@ let mut value_bytes; loop { if tokenizer.is_eof() { - return tokenizer.slice_from(start_pos).into() + return tokenizer.slice_from(start_pos).into(); } match_byte! { tokenizer.next_byte_unchecked(), b'a'...b'z' | b'A'...b'Z' | b'0'...b'9' | b'_' | b'-' => { tokenizer.advance(1) }, @@ -1019,37 +1015,37 @@ integral_part = integral_part * 10. + digit as f64; tokenizer.advance(1); if tokenizer.is_eof() { - break + break; } } let mut is_integer = true; let mut fractional_part: f64 = 0.; - if tokenizer.has_at_least(1) && tokenizer.next_byte_unchecked() == b'.' - && matches!(tokenizer.byte_at(1), b'0'...b'9') { + if tokenizer.has_at_least(1) + && tokenizer.next_byte_unchecked() == b'.' + && matches!(tokenizer.byte_at(1), b'0'...b'9') + { is_integer = false; - tokenizer.advance(1); // Consume '.' + tokenizer.advance(1); // Consume '.' let mut factor = 0.1; while let Some(digit) = byte_to_decimal_digit(tokenizer.next_byte_unchecked()) { fractional_part += digit as f64 * factor; factor *= 0.1; tokenizer.advance(1); if tokenizer.is_eof() { - break + break; } } } let mut value = sign * (integral_part + fractional_part); - if tokenizer.has_at_least(1) - && matches!(tokenizer.next_byte_unchecked(), b'e' | b'E') { - - if matches!(tokenizer.byte_at(1), b'0'...b'9') || - (tokenizer.has_at_least(2) - && matches!(tokenizer.byte_at(1), b'+' | b'-') - && matches!(tokenizer.byte_at(2), b'0'...b'9')) + if tokenizer.has_at_least(1) && matches!(tokenizer.next_byte_unchecked(), b'e' | b'E') { + if matches!(tokenizer.byte_at(1), b'0'...b'9') + || (tokenizer.has_at_least(2) + && matches!(tokenizer.byte_at(1), b'+' | b'-') + && matches!(tokenizer.byte_at(2), b'0'...b'9')) { is_integer = false; tokenizer.advance(1); @@ -1066,7 +1062,7 @@ exponent = exponent * 10. + digit as f64; tokenizer.advance(1); if tokenizer.is_eof() { - break + break; } } value *= f64::powf(10., sign * exponent); @@ -1091,7 +1087,7 @@ unit_value: (value / 100.) as f32, int_value: int_value, has_sign: has_sign, - } + }; } let value = value as f32; if is_ident_start(tokenizer) { @@ -1110,7 +1106,6 @@ } } } - #[inline] unsafe fn from_utf8_release_unchecked(string_bytes: Vec<u8>) -> String { @@ -1134,7 +1129,7 @@ Some(item) => item, None => { tokenizer.position = tokenizer.input.len(); - break + break; } }; match_byte! { b, @@ -1176,9 +1171,9 @@ if found_printable_char { // This function only consumed ASCII (whitespace) bytes, // so the current position is a code point boundary. - return Ok(consume_unquoted_url_internal(tokenizer)) + return Ok(consume_unquoted_url_internal(tokenizer)); } else { - return Ok(UnquotedUrl("".into())) + return Ok(UnquotedUrl("".into())); } fn consume_unquoted_url_internal<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> { @@ -1187,7 +1182,7 @@ let mut string_bytes: Vec<u8>; loop { if tokenizer.is_eof() { - return UnquotedUrl(tokenizer.slice_from(start_pos).into()) + return UnquotedUrl(tokenizer.slice_from(start_pos).into()); } match_byte! { tokenizer.next_byte_unchecked(), b' ' | b'\t' | b'\n' | b'\r' | b'\x0C' => { @@ -1274,14 +1269,15 @@ } UnquotedUrl( // string_bytes is well-formed UTF-8, see other comments. - unsafe { from_utf8_release_unchecked(string_bytes) }.into() + unsafe { from_utf8_release_unchecked(string_bytes) }.into(), ) } - fn consume_url_end<'a>(tokenizer: &mut Tokenizer<'a>, - start_pos: SourcePosition, - string: CowRcStr<'a>) - -> Token<'a> { + fn consume_url_end<'a>( + tokenizer: &mut Tokenizer<'a>, + start_pos: SourcePosition, + string: CowRcStr<'a>, + ) -> Token<'a> { while !tokenizer.is_eof() { match_byte! { tokenizer.next_byte_unchecked(), b')' => { @@ -1339,24 +1335,29 @@ digits += 1; tokenizer.advance(1); } - None => break + None => break, } } (value, digits) } - // Same constraints as consume_escape except it writes into `bytes` the result // instead of returning it. fn consume_escape_and_write(tokenizer: &mut Tokenizer, bytes: &mut Vec<u8>) { - bytes.extend(consume_escape(tokenizer).encode_utf8(&mut [0; 4]).as_bytes()) + bytes.extend( + consume_escape(tokenizer) + .encode_utf8(&mut [0; 4]) + .as_bytes(), + ) } // Assumes that the U+005C REVERSE SOLIDUS (\) has already been consumed // and that the next input character has already been verified // to not be a newline. fn consume_escape(tokenizer: &mut Tokenizer) -> char { - if tokenizer.is_eof() { return '\u{FFFD}' } // Escaped EOF + if tokenizer.is_eof() { + return '\u{FFFD}'; + } // Escaped EOF match_byte! { tokenizer.next_byte_unchecked(), b'0'...b'9' | b'A'...b'F' | b'a'...b'f' => { let (c, _) = consume_hex_digits(tokenizer); diff --git a/third_party/rust/cssparser/src/unicode_range.rs b/third_party/rust/cssparser/src/unicode_range.rs --- a/third_party/rust/cssparser/src/unicode_range.rs +++ b/third_party/rust/cssparser/src/unicode_range.rs @@ -4,10 +4,10 @@ //! https://drafts.csswg.org/css-syntax/#urange -use {Parser, ToCss, BasicParseError}; use std::char; use std::fmt; use tokenizer::Token; +use {BasicParseError, Parser, ToCss}; /// One contiguous range of code points. /// @@ -44,7 +44,10 @@ let range = match parse_concatenated(concatenated_tokens.as_bytes()) { Ok(range) => range, - Err(()) => return Err(input.new_basic_unexpected_token_error(Token::Ident(concatenated_tokens.into()))), + Err(()) => { + return Err(input + .new_basic_unexpected_token_error(Token::Ident(concatenated_tokens.into()))) + } }; if range.end > char::MAX as u32 || range.start > range.end { Err(input.new_basic_unexpected_token_error(Token::Ident(concatenated_tokens.into()))) @@ -61,23 +64,21 @@ match input.next_including_whitespace()?.clone() { Token::Ident(_) => {} Token::Delim('?') => {} - t => return Err(input.new_basic_unexpected_token_error(t)) + t => return Err(input.new_basic_unexpected_token_error(t)), } parse_question_marks(input) } - Token::Dimension { .. } => { - parse_question_marks(input) - } + Token::Dimension { .. } => parse_question_marks(input), Token::Number { .. } => { let after_number = input.state(); match input.next_including_whitespace() { Ok(&Token::Delim('?')) => parse_question_marks(input), Ok(&Token::Dimension { .. }) => {} Ok(&Token::Number { .. }) => {} - _ => input.reset(&after_number) + _ => input.reset(&after_number), } } - t => return Err(input.new_basic_unexpected_token_error(t)) + t => return Err(input.new_basic_unexpected_token_error(t)), } Ok(()) } @@ -90,7 +91,7 @@ Ok(&Token::Delim('?')) => {} _ => { input.reset(&start); - return + return; } } } @@ -99,13 +100,13 @@ fn parse_concatenated(text: &[u8]) -> Result<UnicodeRange, ()> { let mut text = match text.split_first() { Some((&b'+', text)) => text, - _ => return Err(()) + _ => return Err(()), }; let (first_hex_value, hex_digit_count) = consume_hex(&mut text); let question_marks = consume_question_marks(&mut text); let consumed = hex_digit_count + question_marks; if consumed == 0 || consumed > 6 { - return Err(()) + return Err(()); } if question_marks > 0 { @@ -113,13 +114,13 @@ return Ok(UnicodeRange { start: first_hex_value << (question_marks * 4), end: ((first_hex_value + 1) << (question_marks * 4)) - 1, - }) + }); } } else if text.is_empty() { return Ok(UnicodeRange { start: first_hex_value, end: first_hex_value, - }) + }); } else { if let Some((&b'-', mut text)) = text.split_first() { let (second_hex_value, hex_digit_count) = consume_hex(&mut text); @@ -127,7 +128,7 @@ return Ok(UnicodeRange { start: first_hex_value, end: second_hex_value, - }) + }); } } } @@ -143,7 +144,7 @@ digits += 1; *text = rest } else { - break + break; } } (value, digits) @@ -165,7 +166,10 @@ } impl ToCss for UnicodeRange { - fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { write!(dest, "U+{:X}", self.start)?; if self.end != self.start { write!(dest, "-{:X}", self.end)?;
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
