diff --git a/components/style/properties/declaration_block.rs b/components/style/properties/declaration_block.rs index 6078f6712a7..930d4400d3d 100644 --- a/components/style/properties/declaration_block.rs +++ b/components/style/properties/declaration_block.rs @@ -6,34 +6,36 @@ #![deny(missing_docs)] +use super::*; use crate::context::QuirksMode; -use cssparser::{DeclarationListParser, parse_important, ParserInput, CowRcStr}; -use cssparser::{Parser, AtRuleParser, DeclarationParser, Delimiter, ParseErrorKind}; -use crate::custom_properties::{CustomPropertiesBuilder, CssEnvironment}; -use crate::error_reporting::{ParseErrorReporter, ContextualParseError}; -use itertools::Itertools; +use crate::custom_properties::{CssEnvironment, CustomPropertiesBuilder}; +use crate::error_reporting::{ContextualParseError, ParseErrorReporter}; use crate::parser::ParserContext; use crate::properties::animated_properties::{AnimationValue, AnimationValueMap}; +use crate::selector_parser::SelectorImpl; use crate::shared_lock::Locked; +use crate::str::{CssString, CssStringBorrow, CssStringWriter}; +use crate::stylesheets::{CssRuleType, Origin, UrlExtraData}; +use crate::values::computed::Context; +use cssparser::{parse_important, CowRcStr, DeclarationListParser, ParserInput}; +use cssparser::{AtRuleParser, DeclarationParser, Delimiter, ParseErrorKind, Parser}; +use itertools::Itertools; +use selectors::SelectorList; use smallbitvec::{self, SmallBitVec}; use smallvec::SmallVec; use std::fmt::{self, Write}; use std::iter::{DoubleEndedIterator, Zip}; use std::slice::Iter; -use crate::str::{CssString, CssStringBorrow, CssStringWriter}; use style_traits::{CssWriter, ParseError, ParsingMode, StyleParseErrorKind, ToCss}; -use crate::stylesheets::{CssRuleType, Origin, UrlExtraData}; -use super::*; -use crate::values::computed::Context; -use crate::selector_parser::SelectorImpl; -use selectors::SelectorList; /// The animation rules. /// /// The first one is for Animation cascade level, and the second one is for /// Transition cascade level. -pub struct AnimationRules(pub Option>>, - pub Option>>); +pub struct AnimationRules( + pub Option>>, + pub Option>>, +); impl AnimationRules { /// Returns whether these animation rules represents an actual rule or not. @@ -122,8 +124,16 @@ impl<'a> Iterator for DeclarationImportanceIterator<'a> { #[inline] fn next(&mut self) -> Option { - self.iter.next().map(|(decl, important)| - (decl, if important { Importance::Important } else { Importance::Normal })) + self.iter.next().map(|(decl, important)| { + ( + decl, + if important { + Importance::Important + } else { + Importance::Normal + }, + ) + }) } #[inline] @@ -135,13 +145,21 @@ impl<'a> Iterator for DeclarationImportanceIterator<'a> { impl<'a> DoubleEndedIterator for DeclarationImportanceIterator<'a> { #[inline(always)] fn next_back(&mut self) -> Option { - self.iter.next_back().map(|(decl, important)| - (decl, if important { Importance::Important } else { Importance::Normal })) + self.iter.next_back().map(|(decl, important)| { + ( + decl, + if important { + Importance::Important + } else { + Importance::Normal + }, + ) + }) } } /// Iterator for AnimationValue to be generated from PropertyDeclarationBlock. -pub struct AnimationValueIterator<'a, 'cx, 'cx_a:'cx> { +pub struct AnimationValueIterator<'a, 'cx, 'cx_a: 'cx> { iter: DeclarationImportanceIterator<'a>, context: &'cx mut Context<'cx_a>, default_values: &'a ComputedValues, @@ -149,7 +167,7 @@ pub struct AnimationValueIterator<'a, 'cx, 'cx_a:'cx> { extra_custom_properties: Option<&'a Arc>, } -impl<'a, 'cx, 'cx_a:'cx> AnimationValueIterator<'a, 'cx, 'cx_a> { +impl<'a, 'cx, 'cx_a: 'cx> AnimationValueIterator<'a, 'cx, 'cx_a> { fn new( declarations: &'a PropertyDeclarationBlock, context: &'cx mut Context<'cx_a>, @@ -165,7 +183,7 @@ impl<'a, 'cx, 'cx_a:'cx> AnimationValueIterator<'a, 'cx, 'cx_a> { } } -impl<'a, 'cx, 'cx_a:'cx> Iterator for AnimationValueIterator<'a, 'cx, 'cx_a> { +impl<'a, 'cx, 'cx_a: 'cx> Iterator for AnimationValueIterator<'a, 'cx, 'cx_a> { type Item = AnimationValue; #[inline] fn next(&mut self) -> Option { @@ -256,7 +274,7 @@ impl PropertyDeclarationBlock { /// Return an iterator of (AnimatableLonghand, AnimationValue). #[inline] - pub fn to_animation_value_iter<'a, 'cx, 'cx_a:'cx>( + pub fn to_animation_value_iter<'a, 'cx, 'cx_a: 'cx>( &'a self, context: &'cx mut Context<'cx_a>, default_values: &'a ComputedValues, @@ -300,7 +318,10 @@ impl PropertyDeclarationBlock { /// NOTE: This is linear time in the case of custom properties or in the /// case the longhand is actually in the declaration block. #[inline] - pub fn get(&self, property: PropertyDeclarationId) -> Option<(&PropertyDeclaration, Importance)> { + pub fn get( + &self, + property: PropertyDeclarationId, + ) -> Option<(&PropertyDeclaration, Importance)> { if let PropertyDeclarationId::Longhand(id) = property { if !self.contains(id) { return None; @@ -350,9 +371,7 @@ impl PropertyDeclarationBlock { // We don't print !important when serializing individual properties, // so we treat this as a normal-importance property match shorthand.get_shorthand_appendable_value(list.iter().cloned()) { - Some(appendable_value) => { - append_declaration_value(dest, appendable_value) - } + Some(appendable_value) => append_declaration_value(dest, appendable_value), None => return Ok(()), } } @@ -360,7 +379,11 @@ impl PropertyDeclarationBlock { /// Find the value of the given property in this block and serialize it /// /// - pub fn property_value_to_css(&self, property: &PropertyId, dest: &mut CssStringWriter) -> fmt::Result { + pub fn property_value_to_css( + &self, + property: &PropertyId, + dest: &mut CssStringWriter, + ) -> fmt::Result { // Step 1.1: done when parsing a string to PropertyId // Step 1.2 @@ -394,11 +417,12 @@ impl PropertyDeclarationBlock { } else { Importance::Normal } - } + }, Err(longhand_or_custom) => { // Step 3 - self.get(longhand_or_custom).map_or(Importance::Normal, |(_, importance)| importance) - } + self.get(longhand_or_custom) + .map_or(Importance::Normal, |(_, importance)| importance) + }, } } @@ -407,7 +431,9 @@ impl PropertyDeclarationBlock { /// and it doesn't exist in the block, and returns false otherwise. #[inline] fn is_definitely_new(&self, decl: &PropertyDeclaration) -> bool { - decl.id().as_longhand().map_or(false, |id| !self.longhands.contains(id)) + decl.id() + .as_longhand() + .map_or(false, |id| !self.longhands.contains(id)) } /// Adds or overrides the declaration for a given property in this block. @@ -421,11 +447,11 @@ impl PropertyDeclarationBlock { ) -> bool { let all_shorthand_len = match drain.all_shorthand { AllShorthand::NotSet => 0, - AllShorthand::CSSWideKeyword(_) | - AllShorthand::WithVariables(_) => shorthands::ALL_SHORTHAND_MAX_LEN, + AllShorthand::CSSWideKeyword(_) | AllShorthand::WithVariables(_) => { + shorthands::ALL_SHORTHAND_MAX_LEN + }, }; - let push_calls_count = - drain.declarations.len() + all_shorthand_len; + let push_calls_count = drain.declarations.len() + all_shorthand_len; // With deduplication the actual length increase may be less than this. self.declarations.reserve(push_calls_count); @@ -434,9 +460,12 @@ impl PropertyDeclarationBlock { for decl in &mut drain.declarations { changed |= self.push(decl, importance); } - drain.all_shorthand.declarations().fold(changed, |changed, decl| { - changed | self.push(decl, importance) - }) + drain + .all_shorthand + .declarations() + .fold(changed, |changed, decl| { + changed | self.push(decl, importance) + }) } /// Adds or overrides the declaration for a given property in this block. @@ -444,11 +473,7 @@ impl PropertyDeclarationBlock { /// Returns whether the declaration has changed. /// /// This is only used for parsing and internal use. - pub fn push( - &mut self, - declaration: PropertyDeclaration, - importance: Importance, - ) -> bool { + pub fn push(&mut self, declaration: PropertyDeclaration, importance: Importance) -> bool { if !self.is_definitely_new(&declaration) { let mut index_to_remove = None; for (i, slot) in self.declarations.iter_mut().enumerate() { @@ -498,78 +523,92 @@ impl PropertyDeclarationBlock { // Check whether we are updating for an all shorthand change. if !matches!(source_declarations.all_shorthand, AllShorthand::NotSet) { debug_assert!(source_declarations.declarations.is_empty()); - return source_declarations.all_shorthand.declarations().any(|decl| { - self.is_definitely_new(&decl) || - self.declarations.iter().enumerate() - .find(|&(_, ref d)| d.id() == decl.id()) - .map_or(true, |(i, d)| { - let important = self.declarations_importance[i]; - *d != decl || important != importance.important() - }) - }); + return source_declarations + .all_shorthand + .declarations() + .any(|decl| { + self.is_definitely_new(&decl) || + self.declarations + .iter() + .enumerate() + .find(|&(_, ref d)| d.id() == decl.id()) + .map_or(true, |(i, d)| { + let important = self.declarations_importance[i]; + *d != decl || important != importance.important() + }) + }); } // Fill `updates` with update information. let mut any_update = false; let new_count = &mut updates.new_count; let any_removal = &mut updates.any_removal; let updates = &mut updates.updates; - updates.extend(source_declarations.declarations.iter().map(|declaration| { - if self.is_definitely_new(declaration) { - return DeclarationUpdate::Append; - } - let longhand_id = declaration.id().as_longhand(); - if let Some(longhand_id) = longhand_id { - if let Some(logical_group) = longhand_id.logical_group() { - let mut needs_append = false; - for (pos, decl) in self.declarations.iter().enumerate().rev() { - let id = match decl.id().as_longhand() { - Some(id) => id, - None => continue, - }; - if id == longhand_id { - if needs_append { - return DeclarationUpdate::AppendAndRemove { pos }; + updates.extend( + source_declarations + .declarations + .iter() + .map(|declaration| { + if self.is_definitely_new(declaration) { + return DeclarationUpdate::Append; + } + let longhand_id = declaration.id().as_longhand(); + if let Some(longhand_id) = longhand_id { + if let Some(logical_group) = longhand_id.logical_group() { + let mut needs_append = false; + for (pos, decl) in self.declarations.iter().enumerate().rev() { + let id = match decl.id().as_longhand() { + Some(id) => id, + None => continue, + }; + if id == longhand_id { + if needs_append { + return DeclarationUpdate::AppendAndRemove { pos }; + } + let important = self.declarations_importance[pos]; + if decl == declaration && important == importance.important() { + return DeclarationUpdate::None; + } + return DeclarationUpdate::UpdateInPlace { pos }; + } + if !needs_append && + id.logical_group() == Some(logical_group) && + id.is_logical() != longhand_id.is_logical() + { + needs_append = true; + } } + unreachable!("Longhand should be found in loop above"); + } + } + self.declarations + .iter() + .enumerate() + .find(|&(_, ref decl)| decl.id() == declaration.id()) + .map_or(DeclarationUpdate::Append, |(pos, decl)| { let important = self.declarations_importance[pos]; if decl == declaration && important == importance.important() { - return DeclarationUpdate::None; + DeclarationUpdate::None + } else { + DeclarationUpdate::UpdateInPlace { pos } } - return DeclarationUpdate::UpdateInPlace { pos }; - } - if !needs_append && - id.logical_group() == Some(logical_group) && - id.is_logical() != longhand_id.is_logical() { - needs_append = true; - } - } - unreachable!("Longhand should be found in loop above"); - } - } - self.declarations.iter().enumerate() - .find(|&(_, ref decl)| decl.id() == declaration.id()) - .map_or(DeclarationUpdate::Append, |(pos, decl)| { - let important = self.declarations_importance[pos]; - if decl == declaration && important == importance.important() { - DeclarationUpdate::None - } else { - DeclarationUpdate::UpdateInPlace { pos } - } + }) }) - }).inspect(|update| { - if matches!(update, DeclarationUpdate::None) { - return; - } - any_update = true; - match update { - DeclarationUpdate::Append => { - *new_count += 1; - } - DeclarationUpdate::AppendAndRemove { .. } => { - *any_removal = true; - } - _ => {} - } - })); + .inspect(|update| { + if matches!(update, DeclarationUpdate::None) { + return; + } + any_update = true; + match update { + DeclarationUpdate::Append => { + *new_count += 1; + }, + DeclarationUpdate::AppendAndRemove { .. } => { + *any_removal = true; + }, + _ => {}, + } + }), + ); any_update } @@ -590,8 +629,12 @@ impl PropertyDeclarationBlock { self.declarations_importance.push(important); self.longhands.insert(longhand_id); } else { - let (idx, slot) = self.declarations.iter_mut() - .enumerate().find(|&(_, ref d)| d.id() == decl.id()).unwrap(); + let (idx, slot) = self + .declarations + .iter_mut() + .enumerate() + .find(|&(_, ref d)| d.id() == decl.id()) + .unwrap(); *slot = decl; self.declarations_importance.set(idx, important); } @@ -607,19 +650,24 @@ impl PropertyDeclarationBlock { pos: usize, remove: bool, } - let mut updates_and_removals: SubpropertiesVec = - updates.updates.iter_mut().filter_map(|item| { + let mut updates_and_removals: SubpropertiesVec = updates + .updates + .iter_mut() + .filter_map(|item| { let (pos, remove) = match *item { DeclarationUpdate::UpdateInPlace { pos } => (pos, false), DeclarationUpdate::AppendAndRemove { pos } => (pos, true), _ => return None, }; Some(UpdateOrRemoval { item, pos, remove }) - }).collect(); + }) + .collect(); // Execute removals. It's important to do it in reverse index order, // so that removing doesn't invalidate following positions. updates_and_removals.sort_unstable_by_key(|update| update.pos); - updates_and_removals.iter().rev() + updates_and_removals + .iter() + .rev() .filter(|update| update.remove) .for_each(|update| { self.declarations.remove(update.pos); @@ -637,7 +685,7 @@ impl PropertyDeclarationBlock { DeclarationUpdate::UpdateInPlace { pos: update.pos } ); *update.item = DeclarationUpdate::UpdateInPlace { - pos: update.pos - removed_count + pos: update.pos - removed_count, }; } } @@ -645,18 +693,17 @@ impl PropertyDeclarationBlock { for (decl, update) in drain.declarations.zip_eq(updates.updates.iter()) { match *update { DeclarationUpdate::None => {}, - DeclarationUpdate::Append | - DeclarationUpdate::AppendAndRemove { .. } => { + DeclarationUpdate::Append | DeclarationUpdate::AppendAndRemove { .. } => { if let Some(id) = decl.id().as_longhand() { self.longhands.insert(id); } self.declarations.push(decl); self.declarations_importance.push(important); - } + }, DeclarationUpdate::UpdateInPlace { pos } => { self.declarations[pos] = decl; self.declarations_importance.set(pos, important); - } + }, } } updates.updates.clear(); @@ -665,19 +712,16 @@ impl PropertyDeclarationBlock { /// Returns the first declaration that would be removed by removing /// `property`. #[inline] - pub fn first_declaration_to_remove( - &self, - property: &PropertyId, - ) -> Option { + pub fn first_declaration_to_remove(&self, property: &PropertyId) -> Option { if let Some(id) = property.longhand_id() { if !self.longhands.contains(id) { return None; } } - self.declarations.iter().position(|declaration| { - declaration.id().is_or_is_longhand_of(property) - }) + self.declarations + .iter() + .position(|declaration| declaration.id().is_or_is_longhand_of(property)) } /// Removes a given declaration at a given index. @@ -698,16 +742,14 @@ impl PropertyDeclarationBlock { /// `first_declaration` needs to be the result of /// `first_declaration_to_remove`. #[inline] - pub fn remove_property( - &mut self, - property: &PropertyId, - first_declaration: usize, - ) { + pub fn remove_property(&mut self, property: &PropertyId, first_declaration: usize) { debug_assert_eq!( Some(first_declaration), self.first_declaration_to_remove(property) ); - debug_assert!(self.declarations[first_declaration].id().is_or_is_longhand_of(property)); + debug_assert!(self.declarations[first_declaration] + .id() + .is_or_is_longhand_of(property)); self.remove_declaration_at(first_declaration); @@ -776,16 +818,16 @@ impl PropertyDeclarationBlock { // getKeyframes() implementation for CSS animations, if // |computed_values| is supplied, we use it to expand such variable // declarations. This will be fixed properly in Gecko bug 1391537. - ( - &PropertyDeclaration::WithVariables(ref declaration), - Some(ref _computed_values), - ) => { - declaration.value.substitute_variables( - declaration.id, - custom_properties.as_ref(), - QuirksMode::NoQuirks, - &env, - ).to_css(dest) + (&PropertyDeclaration::WithVariables(ref declaration), Some(ref _computed_values)) => { + declaration + .value + .substitute_variables( + declaration.id, + custom_properties.as_ref(), + QuirksMode::NoQuirks, + &env, + ) + .to_css(dest) }, (ref d, _) => d.to_css(dest), } @@ -798,8 +840,8 @@ impl PropertyDeclarationBlock { let mut longhands = LonghandIdSet::new(); for (property, animation_value) in animation_value_map.iter() { - longhands.insert(*property); - declarations.push(animation_value.uncompute()); + longhands.insert(*property); + declarations.push(animation_value.uncompute()); } PropertyDeclarationBlock { @@ -814,13 +856,12 @@ impl PropertyDeclarationBlock { pub fn has_css_wide_keyword(&self, property: &PropertyId) -> bool { if let Some(id) = property.longhand_id() { if !self.longhands.contains(id) { - return false + return false; } } - self.declarations.iter().any(|decl| - decl.id().is_or_is_longhand_of(property) && - decl.get_css_wide_keyword().is_some() - ) + self.declarations.iter().any(|decl| { + decl.id().is_or_is_longhand_of(property) && decl.get_css_wide_keyword().is_some() + }) } /// Returns a custom properties map which is the result of cascading custom @@ -844,10 +885,7 @@ impl PropertyDeclarationBlock { inherited_custom_properties: Option<&Arc>, environment: &CssEnvironment, ) -> Option> { - let mut builder = CustomPropertiesBuilder::new( - inherited_custom_properties, - environment, - ); + let mut builder = CustomPropertiesBuilder::new(inherited_custom_properties, environment); for declaration in self.normal_declaration_iter() { if let PropertyDeclaration::Custom(ref declaration) = *declaration { @@ -899,7 +937,7 @@ impl PropertyDeclarationBlock { &mut is_first_serialization, )?; continue; - } + }, }; // Step 3.2 @@ -928,22 +966,19 @@ impl PropertyDeclarationBlock { let mut important_count = 0; let mut found_system = None; - let is_system_font = - shorthand == ShorthandId::Font && - self.declarations.iter().any(|l| { - match l.id() { - PropertyDeclarationId::Longhand(id) => { - if already_serialized.contains(id.into()) { - return false; - } + let is_system_font = shorthand == ShorthandId::Font && + self.declarations.iter().any(|l| match l.id() { + PropertyDeclarationId::Longhand(id) => { + if already_serialized.contains(id.into()) { + return false; + } - l.get_system().is_some() - } - PropertyDeclarationId::Custom(..) => { - debug_assert!(l.get_system().is_none()); - false - } - } + l.get_system().is_some() + }, + PropertyDeclarationId::Custom(..) => { + debug_assert!(l.get_system().is_none()); + false + }, }); if is_system_font { @@ -951,7 +986,7 @@ impl PropertyDeclarationBlock { if longhand.get_system().is_some() || longhand.is_default_line_height() { current_longhands.push(longhand); if found_system.is_none() { - found_system = longhand.get_system(); + found_system = longhand.get_system(); } if importance.important() { important_count += 1; @@ -967,11 +1002,11 @@ impl PropertyDeclarationBlock { if importance.important() { important_count += 1; } - } + }, None => { contains_all_longhands = false; break; - } + }, } } @@ -994,23 +1029,30 @@ impl PropertyDeclarationBlock { // Substep 5 - Let value be the result of invoking serialize // a CSS value of current longhands. - let appendable_value = - match shorthand.get_shorthand_appendable_value(current_longhands.iter().cloned()) { - None => continue, - Some(appendable_value) => appendable_value, - }; + let appendable_value = match shorthand + .get_shorthand_appendable_value(current_longhands.iter().cloned()) + { + None => continue, + Some(appendable_value) => appendable_value, + }; // We avoid re-serializing if we're already an // AppendableValue::Css. let mut v = CssString::new(); let value = match (appendable_value, found_system) { - (AppendableValue::Css { css, with_variables }, _) => { + ( + AppendableValue::Css { + css, + with_variables, + }, + _, + ) => { debug_assert!(!css.is_empty()); AppendableValue::Css { css: css, with_variables: with_variables, } - } + }, #[cfg(feature = "gecko")] (_, Some(sys)) => { sys.to_css(&mut CssWriter::new(&mut v))?; @@ -1018,7 +1060,7 @@ impl PropertyDeclarationBlock { css: CssStringBorrow::from(&v), with_variables: false, } - } + }, (other, _) => { append_declaration_value(&mut v, other)?; @@ -1031,7 +1073,7 @@ impl PropertyDeclarationBlock { css: CssStringBorrow::from(&v), with_variables: false, } - } + }, }; // Substeps 7 and 8 @@ -1091,7 +1133,8 @@ impl PropertyDeclarationBlock { /// A convenient enum to represent different kinds of stuff that can represent a /// _value_ in the serialization of a property declaration. pub enum AppendableValue<'a, I> - where I: Iterator, +where + I: Iterator, { /// A given declaration, of which we'll serialize just the value. Declaration(&'a PropertyDeclaration), @@ -1107,14 +1150,11 @@ pub enum AppendableValue<'a, I> css: CssStringBorrow<'a>, /// Whether the original serialization contained variables or not. with_variables: bool, - } + }, } /// Potentially appends whitespace after the first (property: value;) pair. -fn handle_first_serialization( - dest: &mut W, - is_first_serialization: &mut bool, -) -> fmt::Result +fn handle_first_serialization(dest: &mut W, is_first_serialization: &mut bool) -> fmt::Result where W: Write, { @@ -1132,18 +1172,14 @@ pub fn append_declaration_value<'a, I>( appendable_value: AppendableValue<'a, I>, ) -> fmt::Result where - I: Iterator, + I: Iterator, { match appendable_value { - AppendableValue::Css { css, .. } => { - css.append_to(dest) - }, - AppendableValue::Declaration(decl) => { - decl.to_css(dest) - }, + AppendableValue::Css { css, .. } => css.append_to(dest), + AppendableValue::Declaration(decl) => decl.to_css(dest), AppendableValue::DeclarationsForShorthand(shorthand, decls) => { shorthand.longhands_to_css(decls, &mut CssWriter::new(dest)) - } + }, } } @@ -1153,10 +1189,10 @@ pub fn append_serialization<'a, I, N>( property_name: &N, appendable_value: AppendableValue<'a, I>, importance: Importance, - is_first_serialization: &mut bool + is_first_serialization: &mut bool, ) -> fmt::Result where - I: Iterator, + I: Iterator, N: ToCss, { handle_first_serialization(dest, is_first_serialization)?; @@ -1176,7 +1212,7 @@ where if !with_variables { dest.write_str(" ")? } - } + }, // Currently append_serialization is only called with a Css or // a Declaration AppendableValue. AppendableValue::DeclarationsForShorthand(..) => unreachable!(), @@ -1228,7 +1264,7 @@ pub fn parse_one_declaration_into( url_data: &UrlExtraData, error_reporter: Option<&dyn ParseErrorReporter>, parsing_mode: ParsingMode, - quirks_mode: QuirksMode + quirks_mode: QuirksMode, ) -> Result<(), ()> { let context = ParserContext::new( Origin::Author, @@ -1249,20 +1285,22 @@ pub fn parse_one_declaration_into( let mut input = ParserInput::new(input); let mut parser = Parser::new(&mut input); let start_position = parser.position(); - parser.parse_entirely(|parser| { - PropertyDeclaration::parse_into(declarations, id, &context, parser) - }).map_err(|err| { - if context.error_reporting_enabled() { - report_one_css_error( - &context, - None, - None, - err, - parser.slice_from(start_position), - property_id_for_error_reporting, - ) - } - }) + parser + .parse_entirely(|parser| { + PropertyDeclaration::parse_into(declarations, id, &context, parser) + }) + .map_err(|err| { + if context.error_reporting_enabled() { + report_one_css_error( + &context, + None, + None, + err, + parser.slice_from(start_position), + property_id_for_error_reporting, + ) + } + }) } /// A struct to parse property declarations. @@ -1273,7 +1311,6 @@ struct PropertyDeclarationParser<'a, 'b: 'a> { last_parsed_property_id: Option, } - /// Default methods reject all at rules. impl<'a, 'b, 'i> AtRuleParser<'i> for PropertyDeclarationParser<'a, 'b> { type PreludeNoBlock = (); @@ -1284,8 +1321,7 @@ impl<'a, 'b, 'i> AtRuleParser<'i> for PropertyDeclarationParser<'a, 'b> { /// Based on NonMozillaVendorIdentifier from Gecko's CSS parser. fn is_non_mozilla_vendor_identifier(name: &str) -> bool { - (name.starts_with("-") && !name.starts_with("-moz-")) || - name.starts_with("_") + (name.starts_with("-") && !name.starts_with("-moz-")) || name.starts_with("_") } impl<'a, 'b, 'i> DeclarationParser<'i> for PropertyDeclarationParser<'a, 'b> { @@ -1301,10 +1337,8 @@ impl<'a, 'b, 'i> DeclarationParser<'i> for PropertyDeclarationParser<'a, 'b> { Ok(id) => id, Err(..) => { self.last_parsed_property_id = None; - return Err(input.new_custom_error( - StyleParseErrorKind::UnknownProperty(name) - )); - } + return Err(input.new_custom_error(StyleParseErrorKind::UnknownProperty(name))); + }, }; if self.context.error_reporting_enabled() { self.last_parsed_property_id = Some(id.clone()); @@ -1344,10 +1378,8 @@ fn report_one_css_error<'i>( fn all_properties_in_block(block: &PropertyDeclarationBlock, property: &PropertyId) -> bool { match *property { - PropertyId::LonghandAlias(id, _) | - PropertyId::Longhand(id) => block.contains(id), - PropertyId::ShorthandAlias(id, _) | - PropertyId::Shorthand(id) => { + PropertyId::LonghandAlias(id, _) | PropertyId::Longhand(id) => block.contains(id), + PropertyId::ShorthandAlias(id, _) | PropertyId::Shorthand(id) => { id.longhands().all(|longhand| block.contains(longhand)) }, // NOTE(emilio): We could do this, but it seems of limited utility, @@ -1382,7 +1414,9 @@ fn report_one_css_error<'i>( } } error = match *property { - PropertyId::Custom(ref c) => StyleParseErrorKind::new_invalid(format!("--{}", c), error), + PropertyId::Custom(ref c) => { + StyleParseErrorKind::new_invalid(format!("--{}", c), error) + }, _ => StyleParseErrorKind::new_invalid(property.non_custom_id().unwrap().name(), error), }; } @@ -1409,7 +1443,7 @@ fn report_css_errors( pub fn parse_property_declaration_list( context: &ParserContext, input: &mut Parser, - selectors: Option<&SelectorList> + selectors: Option<&SelectorList>, ) -> PropertyDeclarationBlock { let mut declarations = SourcePropertyDeclaration::new(); let mut block = PropertyDeclarationBlock::new(); @@ -1423,11 +1457,8 @@ pub fn parse_property_declaration_list( while let Some(declaration) = iter.next() { match declaration { Ok(importance) => { - block.extend( - iter.parser.declarations.drain(), - importance, - ); - } + block.extend(iter.parser.declarations.drain(), importance); + }, Err((error, slice)) => { iter.parser.declarations.clear(); @@ -1435,7 +1466,7 @@ pub fn parse_property_declaration_list( let property = iter.parser.last_parsed_property_id.take(); errors.push((error, slice, property)); } - } + }, } }