pool/MozillaThunderbird
SHA256
4
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity
1fd97561e6
MozillaThunderbird/mozilla-bmo1585099.patch
Wolfgang Rosenauer 44771bf8fd - Mozilla Thunderbird 68.1.2 
Bugfixes
  * Some attachments couldn't be opened in messages originating from
    MS Outlook 2016
  * Address book import from CSV
  * Performance problem in message body search
  * Ctrl+Enter to send a message would open an attachment if the
    attachment pane had focus
  * Calendar: Issues with "Today Pane" start-up
  * Calendar: Glitches with custom repeat and reminder number input
  * Calendar: Problems with WCAP provider
- add mozilla-bmo1585099.patch to fix build with rust >= 1.38

OBS-URL: https://build.opensuse.org/package/show/mozilla:Factory/MozillaThunderbird?expand=0&rev=496
2019-10-11 12:48:56 +00:00

4134 lines
153 KiB
Diff
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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)?;
Reference in New Issue View Git Blame Copy Permalink