Run cargo fmt

Loirooriol · Loirooriol · commit a32ada1b4146 · 2025-11-10T12:32:55.000+09:00
Signed-off-by: Oriol Brufau &lt;obrufau@igalia.com&gt;
diff --git a/color/lib.rs b/color/lib.rs
@@ -12,10 +12,10 @@
 mod tests;
 
 use cssparser::color::{
-    clamp_floor_256_f32, clamp_unit_f32, parse_hash_color, serialize_color_alpha,
-    PredefinedColorSpace, OPAQUE,
+    OPAQUE, PredefinedColorSpace, clamp_floor_256_f32, clamp_unit_f32, parse_hash_color,
+    serialize_color_alpha,
 };
-use cssparser::{match_ignore_ascii_case, CowRcStr, ParseError, Parser, ToCss, Token};
+use cssparser::{CowRcStr, ParseError, Parser, ToCss, Token, match_ignore_ascii_case};
 use std::f32::consts::PI;
 use std::fmt;
 
@@ -54,14 +54,14 @@ where
     match *token {
         Token::Hash(ref value) | Token::IDHash(ref value) => {
             parse_hash_color(value.as_bytes()).map(|(r, g, b, a)| P::Output::from_rgba(r, g, b, a))
-        }
+        },
         Token::Ident(ref value) => parse_color_keyword(value),
         Token::Function(ref name) => {
             let name = name.clone();
             return input.parse_nested_block(|arguments| {
                 parse_color_function(color_parser, name, arguments)
             });
-        }
+        },
         _ => Err(()),
     }
     .map_err(|()| location.new_unexpected_token_error(token.clone()))
@@ -178,14 +178,14 @@ where
                 arguments.expect_comma()?;
                 let blue = clamp_floor_256_f32(color_parser.parse_number(arguments)?);
                 (red, green, blue)
-            }
+            },
             NumberOrPercentage::Percentage { unit_value } => {
                 let red = clamp_unit_f32(unit_value);
                 let green = clamp_unit_f32(color_parser.parse_percentage(arguments)?);
                 arguments.expect_comma()?;
                 let blue = clamp_unit_f32(color_parser.parse_percentage(arguments)?);
                 (red, green, blue)
-            }
+            },
         };
 
         let alpha = parse_legacy_alpha(color_parser, arguments)?;
@@ -1001,7 +1001,7 @@ pub trait ColorParser<'i> {
                 };
 
                 AngleOrNumber::Angle { degrees }
-            }
+            },
             ref t => return Err(location.new_unexpected_token_error(t.clone())),
         })
     }
@@ -1081,7 +1081,7 @@ pub trait FromParsedColor {
 
     /// Construct a new color from the `lab` notation.
     fn from_lab(lightness: Option<f32>, a: Option<f32>, b: Option<f32>, alpha: Option<f32>)
-        -> Self;
+    -> Self;
 
     /// Construct a new color from the `lch` notation.
     fn from_lch(
diff --git a/color/tests.rs b/color/tests.rs
@@ -4,21 +4,21 @@
 
 use super::*;
 use cssparser::ParserInput;
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 
 fn almost_equals(a: &Value, b: &Value) -> bool {
     match (a, b) {
         (Value::Number(a), Value::Number(b)) => {
             let a = a.as_f64().unwrap();
             let b = b.as_f64().unwrap();
             (a - b).abs() <= a.abs() * 1e-6
-        }
+        },
 
         (&Value::Bool(a), &Value::Bool(b)) => a == b,
         (Value::String(a), Value::String(b)) => a == b,
         (Value::Array(a), Value::Array(b)) => {
             a.len() == b.len() && a.iter().zip(b.iter()).all(|(a, b)| almost_equals(a, b))
-        }
+        },
         (&Value::Object(_), &Value::Object(_)) => panic!("Not implemented"),
         (&Value::Null, &Value::Null) => true,
         _ => false,
@@ -52,7 +52,7 @@ fn run_raw_json_tests<F: Fn(Value, Value)>(json_data: &str, run: F) {
             (&Some(_), expected) => {
                 let input = input.take().unwrap();
                 run(input, expected)
-            }
+            },
         };
     }
 }
@@ -63,7 +63,7 @@ fn run_json_tests<F: Fn(&mut Parser) -> Value>(json_data: &str, parse: F) {
             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"),
     });
 }
@@ -207,7 +207,7 @@ impl ToJson for Color {
             Color::CurrentColor => "currentcolor".to_json(),
             Color::Rgba(ref rgba) => {
                 json!([rgba.red, rgba.green, rgba.blue, rgba.alpha])
-            }
+            },
             Color::Hsl(ref c) => json!([c.hue, c.saturation, c.lightness, c.alpha]),
             Color::Hwb(ref c) => json!([c.hue, c.whiteness, c.blackness, c.alpha]),
             Color::Lab(ref c) => json!([c.lightness, c.a, c.b, c.alpha]),
@@ -216,7 +216,7 @@ impl ToJson for Color {
             Color::Oklch(ref c) => json!([c.lightness, c.chroma, c.hue, c.alpha]),
             Color::ColorFunction(ref c) => {
                 json!([c.color_space.to_css_string(), c.c1, c.c2, c.c3, c.alpha])
-            }
+            },
         }
     }
 }
diff --git a/macros/lib.rs b/macros/lib.rs
@@ -66,7 +66,7 @@ fn parse_pat_to_table<'a>(
             if table[value as usize] == 0 {
                 table[value as usize] = case_id;
             }
-        }
+        },
         syn::Pat::Range(syn::PatRange {
             ref start, ref end, ..
         }) => {
@@ -80,14 +80,14 @@ fn parse_pat_to_table<'a>(
             if table[hi as usize] == 0 {
                 table[hi as usize] = case_id;
             }
-        }
+        },
         syn::Pat::Wild(_) => {
             for byte in table.iter_mut() {
                 if *byte == 0 {
                     *byte = case_id;
                 }
             }
-        }
+        },
         syn::Pat::Ident(syn::PatIdent { ref ident, .. }) => {
             assert_eq!(*wildcard, None);
             *wildcard = Some(ident);
@@ -96,15 +96,15 @@ fn parse_pat_to_table<'a>(
                     *byte = case_id;
                 }
             }
-        }
+        },
         syn::Pat::Or(syn::PatOr { ref cases, .. }) => {
             for case in cases {
                 parse_pat_to_table(case, case_id, wildcard, table);
             }
-        }
+        },
         _ => {
             panic!("Unexpected pattern: {:?}. Buggy code ?", pat);
-        }
+        },
     }
 }
 
diff --git a/src/cow_rc_str.rs b/src/cow_rc_str.rs
@@ -93,7 +93,7 @@ impl Clone for CowRcStr<'_> {
                 let new_rc = rc.clone();
                 mem::forget(rc); // Don’t actually take ownership of this strong reference
                 CowRcStr::from_rc(new_rc)
-            }
+            },
             Ok(_) => CowRcStr { ..*self },
         }
     }
diff --git a/src/lib.rs b/src/lib.rs
@@ -68,20 +68,20 @@ fn parse_border_spacing(_context: &ParserContext, input: &mut Parser)
 #![recursion_limit = "200"] // For color::parse_color_keyword
 
 pub use crate::cow_rc_str::CowRcStr;
-pub use crate::from_bytes::{stylesheet_encoding, EncodingSupport};
+pub use crate::from_bytes::{EncodingSupport, stylesheet_encoding};
 #[doc(hidden)]
 pub use crate::macros::{
     _cssparser_internal_create_uninit_array, _cssparser_internal_to_lowercase,
 };
 pub use crate::nth::parse_nth;
 pub use crate::parser::{BasicParseError, BasicParseErrorKind, ParseError, ParseErrorKind};
 pub use crate::parser::{Delimiter, Delimiters, Parser, ParserInput, ParserState};
-pub use crate::rules_and_declarations::{parse_important, parse_one_declaration};
-pub use crate::rules_and_declarations::{parse_one_rule, StyleSheetParser};
 pub use crate::rules_and_declarations::{AtRuleParser, QualifiedRuleParser};
 pub use crate::rules_and_declarations::{DeclarationParser, RuleBodyItemParser, RuleBodyParser};
-pub use crate::serializer::{serialize_identifier, serialize_name, serialize_string};
+pub use crate::rules_and_declarations::{StyleSheetParser, parse_one_rule};
+pub use crate::rules_and_declarations::{parse_important, parse_one_declaration};
 pub use crate::serializer::{CssStringWriter, ToCss, TokenSerializationType};
+pub use crate::serializer::{serialize_identifier, serialize_name, serialize_string};
 pub use crate::tokenizer::{SourceLocation, SourcePosition, Token};
 pub use crate::unicode_range::UnicodeRange;
 pub use cssparser_macros::*;
@@ -102,7 +102,7 @@ mod parser;
 mod serializer;
 mod unicode_range;
 
-#[cfg(all(test,target_pointer_width = "64"))]
+#[cfg(all(test, target_pointer_width = "64"))]
 mod size_of_tests;
 #[cfg(test)]
 mod tests;
diff --git a/src/nth.rs b/src/nth.rs
@@ -30,7 +30,7 @@ pub fn parse_nth<'i>(input: &mut Parser<'i, '_>) -> Result<(i32, i32), BasicPars
                     }
                 }
             }
-        }
+        },
         Token::Ident(ref value) => {
             match_ignore_ascii_case! { value,
                 "even" => Ok((2, 0)),
@@ -54,7 +54,7 @@ pub fn parse_nth<'i>(input: &mut Parser<'i, '_>) -> Result<(i32, i32), BasicPars
                     }
                 }
             }
-        }
+        },
         Token::Delim('+') => match *input.next_including_whitespace()? {
             Token::Ident(ref value) => {
                 match_ignore_ascii_case! { value,
@@ -68,16 +68,16 @@ pub fn parse_nth<'i>(input: &mut Parser<'i, '_>) -> Result<(i32, i32), BasicPars
                         }
                     }
                 }
-            }
+            },
             ref token => {
                 let token = token.clone();
                 Err(input.new_basic_unexpected_token_error(token))
-            }
+            },
         },
         ref token => {
             let token = token.clone();
             Err(input.new_basic_unexpected_token_error(token))
-        }
+        },
     }
 }
 
@@ -94,7 +94,7 @@ fn parse_b<'i>(input: &mut Parser<'i, '_>, a: i32) -> Result<(i32, i32), BasicPa
         _ => {
             input.reset(&start);
             Ok((a, 0))
-        }
+        },
     }
 }
 
diff --git a/src/parser.rs b/src/parser.rs
@@ -81,15 +81,15 @@ impl fmt::Display for BasicParseErrorKind<'_> {
         match self {
             BasicParseErrorKind::UnexpectedToken(token) => {
                 write!(f, "unexpected token: {token:?}")
-            }
+            },
             BasicParseErrorKind::EndOfInput => write!(f, "unexpected end of input"),
             BasicParseErrorKind::AtRuleInvalid(rule) => {
                 write!(f, "invalid @ rule encountered: '@{rule}'")
-            }
+            },
             BasicParseErrorKind::AtRuleBodyInvalid => write!(f, "invalid @ rule body encountered"),
             BasicParseErrorKind::QualifiedRuleInvalid => {
                 write!(f, "invalid qualified rule encountered")
-            }
+            },
         }
     }
 }
@@ -621,7 +621,7 @@ impl<'i: 't, 't> Parser<'i, 't> {
         loop {
             match self.next_including_whitespace_and_comments() {
                 Err(e) => return Err(e),
-                Ok(&Token::Comment(_)) => {}
+                Ok(&Token::Comment(_)) => {},
                 _ => break,
             }
         }
@@ -752,7 +752,7 @@ impl<'i: 't, 't> Parser<'i, 't> {
             match self.parse_until_before(Delimiter::Comma, &mut parse_one) {
                 Ok(v) => values.push(v),
                 Err(e) if !ignore_errors => return Err(e),
-                Err(_) => {}
+                Err(_) => {},
             }
             match self.next() {
                 Err(_) => return Ok(values),
@@ -1035,7 +1035,7 @@ impl<'i: 't, 't> Parser<'i, 't> {
                         let token = t.clone();
                         return Err(self.new_basic_unexpected_token_error(token));
                     }
-                }
+                },
                 Err(_) => return Ok(()),
             }
         }
diff --git a/src/rules_and_declarations.rs b/src/rules_and_declarations.rs
@@ -6,7 +6,7 @@
 
 use super::{BasicParseError, BasicParseErrorKind, Delimiter, ParseError, Parser, Token};
 use crate::cow_rc_str::CowRcStr;
-use crate::parser::{parse_nested_block, parse_until_after, ParseUntilErrorBehavior, ParserState};
+use crate::parser::{ParseUntilErrorBehavior, ParserState, parse_nested_block, parse_until_after};
 
 /// Parse `!important`.
 ///
@@ -260,7 +260,7 @@ where
                 Token::AtKeyword(ref name) => {
                     let name = name.clone();
                     return Some(parse_at_rule(&start, name, self.input, &mut *self.parser));
-                }
+                },
                 // https://drafts.csswg.org/css-syntax/#consume-a-declaration bails out just to
                 // keep parsing as a qualified rule if the token is not an ident, so we implement
                 // that in a slightly more straight-forward way
@@ -299,7 +299,7 @@ where
                     }
 
                     return Some(result.map_err(|e| (e, self.input.slice_from(start.position()))));
-                }
+                },
                 token => {
                     let result = if self.parser.parse_qualified() {
                         self.input.reset(&start);
@@ -312,7 +312,7 @@ where
                         })
                     };
                     return Some(result.map_err(|e| (e, self.input.slice_from(start.position()))));
-                }
+                },
             }
         }
     }
@@ -367,7 +367,7 @@ where
                     _ => {
                         self.input.reset(&start);
                         None
-                    }
+                    },
                 },
                 _ => None,
             };
@@ -438,7 +438,7 @@ where
                 _ => {
                     input.reset(&start);
                     None
-                }
+                },
             }
         } else {
             None
@@ -471,19 +471,19 @@ where
                     .map_err(|()| input.new_unexpected_token_error(Token::Semicolon)),
                 Ok(&Token::CurlyBracketBlock) => {
                     parse_nested_block(input, |input| parser.parse_block(prelude, start, input))
-                }
+                },
                 Ok(_) => unreachable!(),
             };
             result.map_err(|e| (e, input.slice_from(start.position())))
-        }
+        },
         Err(error) => {
             let end_position = input.position();
             match input.next() {
-                Ok(&Token::CurlyBracketBlock) | Ok(&Token::Semicolon) | Err(_) => {}
+                Ok(&Token::CurlyBracketBlock) | Ok(&Token::Semicolon) | Err(_) => {},
                 _ => unreachable!(),
             };
             Err((error, input.slice(start.position()..end_position)))
-        }
+        },
     }
 }
 
diff --git a/src/serializer.rs b/src/serializer.rs
diff --git a/src/tests.rs b/src/tests.rs
diff --git a/src/tokenizer.rs b/src/tokenizer.rs
diff --git a/src/unicode_range.rs b/src/unicode_range.rs

Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ fn parse_pat_to_table<'a>(`
`66`	`66`	`if table[value as usize] == 0 {`
`67`	`67`	`table[value as usize] = case_id;`
`68`	`68`	`}`
`69`		`- }`
	`69`	`+ },`
`70`	`70`	`syn::Pat::Range(syn::PatRange {`
`71`	`71`	`ref start, ref end, ..`
`72`	`72`	`}) => {`
`@@ -80,14 +80,14 @@ fn parse_pat_to_table<'a>(`
`80`	`80`	`if table[hi as usize] == 0 {`
`81`	`81`	`table[hi as usize] = case_id;`
`82`	`82`	`}`
`83`		`- }`
	`83`	`+ },`
`84`	`84`	`syn::Pat::Wild(_) => {`
`85`	`85`	`for byte in table.iter_mut() {`
`86`	`86`	`if *byte == 0 {`
`87`	`87`	`*byte = case_id;`
`88`	`88`	`}`
`89`	`89`	`}`
`90`		`- }`
	`90`	`+ },`
`91`	`91`	`syn::Pat::Ident(syn::PatIdent { ref ident, .. }) => {`
`92`	`92`	`assert_eq!(*wildcard, None);`
`93`	`93`	`*wildcard = Some(ident);`
`@@ -96,15 +96,15 @@ fn parse_pat_to_table<'a>(`
`96`	`96`	`*byte = case_id;`
`97`	`97`	`}`
`98`	`98`	`}`
`99`		`- }`
	`99`	`+ },`
`100`	`100`	`syn::Pat::Or(syn::PatOr { ref cases, .. }) => {`
`101`	`101`	`for case in cases {`
`102`	`102`	`parse_pat_to_table(case, case_id, wildcard, table);`
`103`	`103`	`}`
`104`		`- }`
	`104`	`+ },`
`105`	`105`	`_ => {`
`106`	`106`	`panic!("Unexpected pattern: {:?}. Buggy code ?", pat);`
`107`		`- }`
	`107`	`+ },`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ impl Clone for CowRcStr<'_> {`
`93`	`93`	`let new_rc = rc.clone();`
`94`	`94`	`mem::forget(rc); // Don’t actually take ownership of this strong reference`
`95`	`95`	`CowRcStr::from_rc(new_rc)`
`96`		`- }`
	`96`	`+ },`
`97`	`97`	`Ok(_) => CowRcStr { ..*self },`
`98`	`98`	`}`
`99`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ pub fn parse_nth<'i>(input: &mut Parser<'i, '_>) -> Result<(i32, i32), BasicPars`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`	`}`
`33`		`- }`
	`33`	`+ },`
`34`	`34`	`Token::Ident(ref value) => {`
`35`	`35`	`match_ignore_ascii_case! { value,`
`36`	`36`	`"even" => Ok((2, 0)),`
`@@ -54,7 +54,7 @@ pub fn parse_nth<'i>(input: &mut Parser<'i, '_>) -> Result<(i32, i32), BasicPars`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`	`}`
`57`		`- }`
	`57`	`+ },`
`58`	`58`	`Token::Delim('+') => match *input.next_including_whitespace()? {`
`59`	`59`	`Token::Ident(ref value) => {`
`60`	`60`	`match_ignore_ascii_case! { value,`
`@@ -68,16 +68,16 @@ pub fn parse_nth<'i>(input: &mut Parser<'i, '_>) -> Result<(i32, i32), BasicPars`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`	`}`
`71`		`- }`
	`71`	`+ },`
`72`	`72`	`ref token => {`
`73`	`73`	`let token = token.clone();`
`74`	`74`	`Err(input.new_basic_unexpected_token_error(token))`
`75`		`- }`
	`75`	`+ },`
`76`	`76`	`},`
`77`	`77`	`ref token => {`
`78`	`78`	`let token = token.clone();`
`79`	`79`	`Err(input.new_basic_unexpected_token_error(token))`
`80`		`- }`
	`80`	`+ },`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`@@ -94,7 +94,7 @@ fn parse_b<'i>(input: &mut Parser<'i, '_>, a: i32) -> Result<(i32, i32), BasicPa`
`94`	`94`	`_ => {`
`95`	`95`	`input.reset(&start);`
`96`	`96`	`Ok((a, 0))`
`97`		`- }`
	`97`	`+ },`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`
Original file line number	Diff line number	Diff line change
`@@ -81,15 +81,15 @@ impl fmt::Display for BasicParseErrorKind<'_> {`
`81`	`81`	`match self {`
`82`	`82`	`BasicParseErrorKind::UnexpectedToken(token) => {`
`83`	`83`	`write!(f, "unexpected token: {token:?}")`
`84`		`- }`
	`84`	`+ },`
`85`	`85`	`BasicParseErrorKind::EndOfInput => write!(f, "unexpected end of input"),`
`86`	`86`	`BasicParseErrorKind::AtRuleInvalid(rule) => {`
`87`	`87`	`write!(f, "invalid @ rule encountered: '@{rule}'")`
`88`		`- }`
	`88`	`+ },`
`89`	`89`	`BasicParseErrorKind::AtRuleBodyInvalid => write!(f, "invalid @ rule body encountered"),`
`90`	`90`	`BasicParseErrorKind::QualifiedRuleInvalid => {`
`91`	`91`	`write!(f, "invalid qualified rule encountered")`
`92`		`- }`
	`92`	`+ },`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`	`}`
`@@ -621,7 +621,7 @@ impl<'i: 't, 't> Parser<'i, 't> {`
`621`	`621`	`loop {`
`622`	`622`	`match self.next_including_whitespace_and_comments() {`
`623`	`623`	`Err(e) => return Err(e),`
`624`		`- Ok(&Token::Comment(_)) => {}`
	`624`	`+ Ok(&Token::Comment(_)) => {},`
`625`	`625`	`_ => break,`
`626`	`626`	`}`
`627`	`627`	`}`
`@@ -752,7 +752,7 @@ impl<'i: 't, 't> Parser<'i, 't> {`
`752`	`752`	`match self.parse_until_before(Delimiter::Comma, &mut parse_one) {`
`753`	`753`	`Ok(v) => values.push(v),`
`754`	`754`	`Err(e) if !ignore_errors => return Err(e),`
`755`		`- Err(_) => {}`
	`755`	`+ Err(_) => {},`
`756`	`756`	`}`
`757`	`757`	`match self.next() {`
`758`	`758`	`Err(_) => return Ok(values),`
`@@ -1035,7 +1035,7 @@ impl<'i: 't, 't> Parser<'i, 't> {`
`1035`	`1035`	`let token = t.clone();`
`1036`	`1036`	`return Err(self.new_basic_unexpected_token_error(token));`
`1037`	`1037`	`}`
`1038`		`- }`
	`1038`	`+ },`
`1039`	`1039`	`Err(_) => return Ok(()),`
`1040`	`1040`	`}`
`1041`	`1041`	`}`