tor-browser

declaration_block.rs (62975B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */

//! A property declaration block.

#![deny(missing_docs)]

use super::{
   property_counts, AllShorthand, ComputedValues, LogicalGroupSet, LonghandIdSet,
   LonghandIdSetIterator, NonCustomPropertyIdSet, PropertyDeclaration, PropertyDeclarationId,
   PropertyId, ShorthandId, SourcePropertyDeclaration, SourcePropertyDeclarationDrain,
   SubpropertiesVec,
};
use crate::context::QuirksMode;
use crate::custom_properties;
use crate::derives::*;
use crate::dom::DummyAttributeProvider;
use crate::error_reporting::{ContextualParseError, ParseErrorReporter};
use crate::parser::ParserContext;
use crate::properties::{
   animated_properties::{AnimationValue, AnimationValueMap},
   StyleBuilder,
};
use crate::rule_cache::RuleCacheConditions;
use crate::selector_map::PrecomputedHashSet;
use crate::selector_parser::SelectorImpl;
use crate::shared_lock::Locked;
use crate::stylesheets::container_rule::ContainerSizeQuery;
use crate::stylesheets::{CssRuleType, Origin, UrlExtraData};
use crate::stylist::Stylist;
use crate::values::computed::Context;
use cssparser::{
   parse_important, AtRuleParser, CowRcStr, DeclarationParser, Delimiter, ParseErrorKind, Parser,
   ParserInput, ParserState, QualifiedRuleParser, RuleBodyItemParser, RuleBodyParser,
   SourceLocation,
};
use itertools::Itertools;
use selectors::SelectorList;
use servo_arc::Arc;
use smallbitvec::SmallBitVec;
use smallvec::SmallVec;
use std::fmt::{self, Write};
use std::iter::Zip;
use std::slice::Iter;
use style_traits::{
   CssString, CssStringWriter, CssWriter, ParseError, ParsingMode, StyleParseErrorKind, ToCss,
   TypedValue,
};
use thin_vec::ThinVec;

/// A set of property declarations including animations and transitions.
#[derive(Default)]
pub struct AnimationDeclarations {
   /// Declarations for animations.
   pub animations: Option<Arc<Locked<PropertyDeclarationBlock>>>,
   /// Declarations for transitions.
   pub transitions: Option<Arc<Locked<PropertyDeclarationBlock>>>,
}

impl AnimationDeclarations {
   /// Whether or not this `AnimationDeclarations` is empty.
   pub fn is_empty(&self) -> bool {
       self.animations.is_none() && self.transitions.is_none()
   }
}

/// An enum describes how a declaration should update
/// the declaration block.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum DeclarationUpdate {
   /// The given declaration doesn't update anything.
   None,
   /// The given declaration is new, and should be append directly.
   Append,
   /// The given declaration can be updated in-place at the given position.
   UpdateInPlace { pos: usize },
   /// The given declaration cannot be updated in-place, and an existing
   /// one needs to be removed at the given position.
   AppendAndRemove { pos: usize },
}

/// A struct describes how a declaration block should be updated by
/// a `SourcePropertyDeclaration`.
#[derive(Default)]
pub struct SourcePropertyDeclarationUpdate {
   updates: SubpropertiesVec<DeclarationUpdate>,
   new_count: usize,
   any_removal: bool,
}

/// A declaration [importance][importance].
///
/// [importance]: https://drafts.csswg.org/css-cascade/#importance
#[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, PartialEq)]
pub enum Importance {
   /// Indicates a declaration without `!important`.
   Normal,

   /// Indicates a declaration with `!important`.
   Important,
}

impl Default for Importance {
   fn default() -> Self {
       Self::Normal
   }
}

impl Importance {
   /// Return whether this is an important declaration.
   pub fn important(self) -> bool {
       match self {
           Self::Normal => false,
           Self::Important => true,
       }
   }
}

/// A property-aware wrapper around reification results.
///
/// While `TypedValue` is property-agnostic, this enum represents the outcome
/// of reifying a specific property inside a `PropertyDeclarationBlock`.
#[derive(Clone, Debug)]
pub enum PropertyTypedValue {
   /// The property is not present in the declaration block.
   None,

   /// The property exists but cannot be expressed as a `TypedValue`.
   /// Used for shorthands and other unrepresentable cases, which must be
   /// exposed as `CSSUnsupportedValue` objects tied to the property.
   Unsupported,

   /// The property was successfully reified into a `TypedValue`.
   Typed(TypedValue),
}

/// A set of properties.
#[derive(Clone, Debug, ToShmem, Default, MallocSizeOf)]
pub struct PropertyDeclarationIdSet {
   longhands: LonghandIdSet,
   custom: PrecomputedHashSet<custom_properties::Name>,
}

impl PropertyDeclarationIdSet {
   /// Add the given property to the set.
   pub fn insert(&mut self, id: PropertyDeclarationId) -> bool {
       match id {
           PropertyDeclarationId::Longhand(id) => {
               if self.longhands.contains(id) {
                   return false;
               }
               self.longhands.insert(id);
               return true;
           },
           PropertyDeclarationId::Custom(name) => self.custom.insert((*name).clone()),
       }
   }

   /// Return whether the given property is in the set.
   pub fn contains(&self, id: PropertyDeclarationId) -> bool {
       match id {
           PropertyDeclarationId::Longhand(id) => self.longhands.contains(id),
           PropertyDeclarationId::Custom(name) => self.custom.contains(name),
       }
   }

   /// Remove the given property from the set.
   pub fn remove(&mut self, id: PropertyDeclarationId) {
       match id {
           PropertyDeclarationId::Longhand(id) => self.longhands.remove(id),
           PropertyDeclarationId::Custom(name) => {
               self.custom.remove(name);
           },
       }
   }

   /// Remove all properties from the set.
   pub fn clear(&mut self) {
       self.longhands.clear();
       self.custom.clear();
   }

   /// Returns whether the set is empty.
   #[inline]
   pub fn is_empty(&self) -> bool {
       self.longhands.is_empty() && self.custom.is_empty()
   }
   /// Returns whether this set contains any reset longhand.
   #[inline]
   pub fn contains_any_reset(&self) -> bool {
       self.longhands.contains_any_reset()
   }

   /// Returns whether this set contains all longhands in the specified set.
   #[inline]
   pub fn contains_all_longhands(&self, longhands: &LonghandIdSet) -> bool {
       self.longhands.contains_all(longhands)
   }

   /// Returns whether this set contains all properties in the specified set.
   #[inline]
   pub fn contains_all(&self, properties: &PropertyDeclarationIdSet) -> bool {
       if !self.longhands.contains_all(&properties.longhands) {
           return false;
       }
       if properties.custom.len() > self.custom.len() {
           return false;
       }
       properties
           .custom
           .iter()
           .all(|item| self.custom.contains(item))
   }

   /// Iterate over the current property declaration id set.
   pub fn iter(&self) -> PropertyDeclarationIdSetIterator<'_> {
       PropertyDeclarationIdSetIterator {
           longhands: self.longhands.iter(),
           custom: self.custom.iter(),
       }
   }
}

/// An iterator over a set of longhand ids.
pub struct PropertyDeclarationIdSetIterator<'a> {
   longhands: LonghandIdSetIterator<'a>,
   custom: std::collections::hash_set::Iter<'a, custom_properties::Name>,
}

impl<'a> Iterator for PropertyDeclarationIdSetIterator<'a> {
   type Item = PropertyDeclarationId<'a>;

   fn next(&mut self) -> Option<Self::Item> {
       // LonghandIdSetIterator's implementation always returns None
       // after it did it once, so the code below will then continue
       // to iterate over the custom properties.
       match self.longhands.next() {
           Some(id) => Some(PropertyDeclarationId::Longhand(id)),
           None => match self.custom.next() {
               Some(a) => Some(PropertyDeclarationId::Custom(a)),
               None => None,
           },
       }
   }
}

/// Overridden declarations are skipped.
#[cfg_attr(feature = "gecko", derive(MallocSizeOf))]
#[derive(Clone, ToShmem, Default)]
pub struct PropertyDeclarationBlock {
   /// The group of declarations, along with their importance.
   ///
   /// Only deduplicated declarations appear here.
   declarations: ThinVec<PropertyDeclaration>,

   /// The "important" flag for each declaration in `declarations`.
   declarations_importance: SmallBitVec,

   /// The set of properties that are present in the block.
   property_ids: PropertyDeclarationIdSet,
}

impl PartialEq for PropertyDeclarationBlock {
   fn eq(&self, other: &Self) -> bool {
       // property_ids must be equal if declarations are equal, so we don't
       // need to compare them explicitly.
       self.declarations == other.declarations
           && self.declarations_importance == other.declarations_importance
   }
}

/// Iterator over `(PropertyDeclaration, Importance)` pairs.
pub struct DeclarationImportanceIterator<'a> {
   iter: Zip<Iter<'a, PropertyDeclaration>, smallbitvec::Iter<'a>>,
}

impl<'a> Default for DeclarationImportanceIterator<'a> {
   fn default() -> Self {
       Self {
           iter: [].iter().zip(smallbitvec::Iter::default()),
       }
   }
}

impl<'a> DeclarationImportanceIterator<'a> {
   /// Constructor.
   fn new(declarations: &'a [PropertyDeclaration], important: &'a SmallBitVec) -> Self {
       DeclarationImportanceIterator {
           iter: declarations.iter().zip(important.iter()),
       }
   }
}

impl<'a> Iterator for DeclarationImportanceIterator<'a> {
   type Item = (&'a PropertyDeclaration, Importance);

   #[inline]
   fn next(&mut self) -> Option<Self::Item> {
       self.iter.next().map(|(decl, important)| {
           (
               decl,
               if important {
                   Importance::Important
               } else {
                   Importance::Normal
               },
           )
       })
   }

   #[inline]
   fn size_hint(&self) -> (usize, Option<usize>) {
       self.iter.size_hint()
   }
}

impl<'a> DoubleEndedIterator for DeclarationImportanceIterator<'a> {
   #[inline(always)]
   fn next_back(&mut self) -> Option<Self::Item> {
       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> {
   iter: DeclarationImportanceIterator<'a>,
   context: &'cx mut Context<'cx_a>,
   style: &'a ComputedValues,
   default_values: &'a ComputedValues,
}

impl<'a, 'cx, 'cx_a: 'cx> AnimationValueIterator<'a, 'cx, 'cx_a> {
   fn new(
       declarations: &'a PropertyDeclarationBlock,
       context: &'cx mut Context<'cx_a>,
       style: &'a ComputedValues,
       default_values: &'a ComputedValues,
   ) -> AnimationValueIterator<'a, 'cx, 'cx_a> {
       AnimationValueIterator {
           iter: declarations.declaration_importance_iter(),
           context,
           style,
           default_values,
       }
   }
}

impl<'a, 'cx, 'cx_a: 'cx> Iterator for AnimationValueIterator<'a, 'cx, 'cx_a> {
   type Item = AnimationValue;
   #[inline]
   fn next(&mut self) -> Option<Self::Item> {
       loop {
           let (decl, importance) = self.iter.next()?;

           if importance.important() {
               continue;
           }

           let animation = AnimationValue::from_declaration(
               decl,
               &mut self.context,
               self.style,
               self.default_values,
               // TODO (descalante): should be able to get an attr from an animated element
               &DummyAttributeProvider {},
           );

           if let Some(anim) = animation {
               return Some(anim);
           }
       }
   }
}

impl fmt::Debug for PropertyDeclarationBlock {
   fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
       self.declarations.fmt(f)
   }
}

impl PropertyDeclarationBlock {
   /// Returns the number of declarations in the block.
   #[inline]
   pub fn len(&self) -> usize {
       self.declarations.len()
   }

   /// Returns whether the block is empty.
   #[inline]
   pub fn is_empty(&self) -> bool {
       self.declarations.is_empty()
   }

   /// Create an empty block
   #[inline]
   pub fn new() -> Self {
       PropertyDeclarationBlock {
           declarations: ThinVec::new(),
           declarations_importance: SmallBitVec::new(),
           property_ids: PropertyDeclarationIdSet::default(),
       }
   }

   /// Create a block with a single declaration
   pub fn with_one(declaration: PropertyDeclaration, importance: Importance) -> Self {
       let mut property_ids = PropertyDeclarationIdSet::default();
       property_ids.insert(declaration.id());
       let mut declarations = ThinVec::with_capacity(1);
       declarations.push(declaration);
       PropertyDeclarationBlock {
           declarations,
           declarations_importance: SmallBitVec::from_elem(1, importance.important()),
           property_ids,
       }
   }

   /// The declarations in this block
   #[inline]
   pub fn declarations(&self) -> &[PropertyDeclaration] {
       &self.declarations
   }

   /// The `important` flags for declarations in this block
   #[inline]
   pub fn declarations_importance(&self) -> &SmallBitVec {
       &self.declarations_importance
   }

   /// Iterate over `(PropertyDeclaration, Importance)` pairs
   #[inline]
   pub fn declaration_importance_iter(&self) -> DeclarationImportanceIterator<'_> {
       DeclarationImportanceIterator::new(&self.declarations, &self.declarations_importance)
   }

   /// Iterate over `PropertyDeclaration` for Importance::Normal
   #[inline]
   pub fn normal_declaration_iter<'a>(
       &'a self,
   ) -> impl DoubleEndedIterator<Item = &'a PropertyDeclaration> {
       self.declaration_importance_iter()
           .filter(|(_, importance)| !importance.important())
           .map(|(declaration, _)| declaration)
   }

   /// Return an iterator of (AnimatableLonghand, AnimationValue).
   #[inline]
   pub fn to_animation_value_iter<'a, 'cx, 'cx_a: 'cx>(
       &'a self,
       context: &'cx mut Context<'cx_a>,
       style: &'a ComputedValues,
       default_values: &'a ComputedValues,
   ) -> AnimationValueIterator<'a, 'cx, 'cx_a> {
       AnimationValueIterator::new(self, context, style, default_values)
   }

   /// Returns whether this block contains any declaration with `!important`.
   ///
   /// This is based on the `declarations_importance` bit-vector,
   /// which should be maintained whenever `declarations` is changed.
   #[inline]
   pub fn any_important(&self) -> bool {
       !self.declarations_importance.all_false()
   }

   /// Returns whether this block contains any declaration without `!important`.
   ///
   /// This is based on the `declarations_importance` bit-vector,
   /// which should be maintained whenever `declarations` is changed.
   #[inline]
   pub fn any_normal(&self) -> bool {
       !self.declarations_importance.all_true()
   }

   /// Returns a `PropertyDeclarationIdSet` representing the properties that are changed in
   /// this block.
   #[inline]
   pub fn property_ids(&self) -> &PropertyDeclarationIdSet {
       &self.property_ids
   }

   /// Returns whether this block contains a declaration of a given property id.
   #[inline]
   pub fn contains(&self, id: PropertyDeclarationId) -> bool {
       self.property_ids.contains(id)
   }

   /// Returns whether this block contains any reset longhand.
   #[inline]
   pub fn contains_any_reset(&self) -> bool {
       self.property_ids.contains_any_reset()
   }

   /// Get a declaration for a given property.
   ///
   /// 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)> {
       if !self.contains(property) {
           return None;
       }
       self.declaration_importance_iter()
           .find(|(declaration, _)| declaration.id() == property)
   }

   /// Tries to serialize a given shorthand from the declarations in this
   /// block.
   pub fn shorthand_to_css(
       &self,
       shorthand: ShorthandId,
       dest: &mut CssStringWriter,
   ) -> fmt::Result {
       // Step 1.2.1 of
       // https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-getpropertyvalue
       let mut list = SmallVec::<[&_; 10]>::new();
       let mut important_count = 0;

       // Step 1.2.2
       for longhand in shorthand.longhands() {
           // Step 1.2.2.1
           let declaration = self.get(PropertyDeclarationId::Longhand(longhand));

           // Step 1.2.2.2 & 1.2.2.3
           match declaration {
               Some((declaration, importance)) => {
                   list.push(declaration);
                   if importance.important() {
                       important_count += 1;
                   }
               },
               None => return Ok(()),
           }
       }

       // If there is one or more longhand with important, and one or more
       // without important, we don't serialize it as a shorthand.
       if important_count > 0 && important_count != list.len() {
           return Ok(());
       }

       // Step 1.2.3
       // 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) {
           Some(appendable_value) => append_declaration_value(dest, appendable_value),
           None => return Ok(()),
       }
   }

   /// Find the value of the given property in this block and serialize it
   ///
   /// <https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-getpropertyvalue>
   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
       let longhand_or_custom = match property.as_shorthand() {
           Ok(shorthand) => return self.shorthand_to_css(shorthand, dest),
           Err(longhand_or_custom) => longhand_or_custom,
       };

       if let Some((value, _importance)) = self.get(longhand_or_custom) {
           // Step 2
           value.to_css(dest)
       } else {
           // Step 3
           Ok(())
       }
   }

   /// <https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-getpropertypriority>
   pub fn property_priority(&self, property: &PropertyId) -> Importance {
       // Step 1: done when parsing a string to PropertyId

       // Step 2
       match property.as_shorthand() {
           Ok(shorthand) => {
               // Step 2.1 & 2.2 & 2.3
               if shorthand.longhands().all(|l| {
                   self.get(PropertyDeclarationId::Longhand(l))
                       .map_or(false, |(_, importance)| importance.important())
               }) {
                   Importance::Important
               } else {
                   Importance::Normal
               }
           },
           Err(longhand_or_custom) => {
               // Step 3
               self.get(longhand_or_custom)
                   .map_or(Importance::Normal, |(_, importance)| importance)
           },
       }
   }

   /// Find the value of the given property in this block and reify it
   pub fn property_value_to_typed(&self, property: &PropertyId) -> PropertyTypedValue {
       match property.as_shorthand() {
           Ok(shorthand) => {
               if shorthand
                   .longhands()
                   .all(|longhand| self.contains(PropertyDeclarationId::Longhand(longhand)))
               {
                   PropertyTypedValue::Unsupported
               } else {
                   PropertyTypedValue::None
               }
           },
           Err(longhand_or_custom) => match self.get(longhand_or_custom) {
               Some((value, _importance)) => {
                   if let Some(typed_value) = value.to_typed() {
                       PropertyTypedValue::Typed(typed_value)
                   } else {
                       PropertyTypedValue::Unsupported
                   }
               },
               None => PropertyTypedValue::None,
           },
       }
   }

   /// Adds or overrides the declaration for a given property in this block.
   ///
   /// See the documentation of `push` to see what impact `source` has when the
   /// property is already there.
   pub fn extend(
       &mut self,
       mut drain: SourcePropertyDeclarationDrain,
       importance: Importance,
   ) -> bool {
       let all_shorthand_len = match drain.all_shorthand {
           AllShorthand::NotSet => 0,
           AllShorthand::CSSWideKeyword(_) | AllShorthand::WithVariables(_) => {
               property_counts::ALL_SHORTHAND_EXPANDED
           },
       };
       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);

       let mut changed = false;
       for decl in &mut drain.declarations {
           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.
   ///
   /// 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 {
       let id = declaration.id();
       if !self.property_ids.insert(id) {
           let mut index_to_remove = None;
           for (i, slot) in self.declarations.iter_mut().enumerate() {
               if slot.id() != id {
                   continue;
               }

               let important = self.declarations_importance[i];

               // For declarations from parsing, non-important declarations
               // shouldn't override existing important one.
               if important && !importance.important() {
                   return false;
               }

               index_to_remove = Some(i);
               break;
           }

           if let Some(index) = index_to_remove {
               self.declarations.remove(index);
               self.declarations_importance.remove(index);
               self.declarations.push(declaration);
               self.declarations_importance.push(importance.important());
               return true;
           }
       }

       self.declarations.push(declaration);
       self.declarations_importance.push(importance.important());
       true
   }

   /// Prepares updating this declaration block with the given
   /// `SourcePropertyDeclaration` and importance, and returns whether
   /// there is something to update.
   pub fn prepare_for_update(
       &self,
       source_declarations: &SourcePropertyDeclaration,
       importance: Importance,
       updates: &mut SourcePropertyDeclarationUpdate,
   ) -> bool {
       debug_assert!(updates.updates.is_empty());
       // 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.contains(decl.id())
                       || 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.contains(declaration.id()) {
                       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() {
                               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;
                       },
                       _ => {},
                   }
               }),
       );
       any_update
   }

   /// Update this declaration block with the given data.
   pub fn update(
       &mut self,
       drain: SourcePropertyDeclarationDrain,
       importance: Importance,
       updates: &mut SourcePropertyDeclarationUpdate,
   ) {
       let important = importance.important();
       if !matches!(drain.all_shorthand, AllShorthand::NotSet) {
           debug_assert!(updates.updates.is_empty());
           for decl in drain.all_shorthand.declarations() {
               let id = decl.id();
               if self.property_ids.insert(id) {
                   self.declarations.push(decl);
                   self.declarations_importance.push(important);
               } else {
                   let (idx, slot) = self
                       .declarations
                       .iter_mut()
                       .enumerate()
                       .find(|&(_, ref d)| d.id() == decl.id())
                       .unwrap();
                   *slot = decl;
                   self.declarations_importance.set(idx, important);
               }
           }
           return;
       }

       self.declarations.reserve(updates.new_count);
       if updates.any_removal {
           // Prepare for removal and fixing update positions.
           struct UpdateOrRemoval<'a> {
               item: &'a mut DeclarationUpdate,
               pos: usize,
               remove: bool,
           }
           let mut updates_and_removals: SubpropertiesVec<UpdateOrRemoval> = 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();
           // 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()
               .filter(|update| update.remove)
               .for_each(|update| {
                   self.declarations.remove(update.pos);
                   self.declarations_importance.remove(update.pos);
               });
           // Fixup pos field for updates.
           let mut removed_count = 0;
           for update in updates_and_removals.iter_mut() {
               if update.remove {
                   removed_count += 1;
                   continue;
               }
               debug_assert_eq!(
                   *update.item,
                   DeclarationUpdate::UpdateInPlace { pos: update.pos }
               );
               *update.item = DeclarationUpdate::UpdateInPlace {
                   pos: update.pos - removed_count,
               };
           }
       }
       // Execute updates and appends.
       for (decl, update) in drain.declarations.zip_eq(updates.updates.iter()) {
           match *update {
               DeclarationUpdate::None => {},
               DeclarationUpdate::Append | DeclarationUpdate::AppendAndRemove { .. } => {
                   self.property_ids.insert(decl.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();
   }

   /// Returns the first declaration that would be removed by removing
   /// `property`.
   #[inline]
   pub fn first_declaration_to_remove(&self, property: &PropertyId) -> Option<usize> {
       if let Err(longhand_or_custom) = property.as_shorthand() {
           if !self.contains(longhand_or_custom) {
               return None;
           }
       }

       self.declarations
           .iter()
           .position(|declaration| declaration.id().is_or_is_longhand_of(property))
   }

   /// Removes a given declaration at a given index.
   #[inline]
   fn remove_declaration_at(&mut self, i: usize) {
       self.property_ids.remove(self.declarations[i].id());
       self.declarations_importance.remove(i);
       self.declarations.remove(i);
   }

   /// Clears all the declarations from this block.
   #[inline]
   pub fn clear(&mut self) {
       self.declarations_importance.clear();
       self.declarations.clear();
       self.property_ids.clear();
   }

   /// <https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-removeproperty>
   ///
   /// `first_declaration` needs to be the result of
   /// `first_declaration_to_remove`.
   #[inline]
   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));

       self.remove_declaration_at(first_declaration);

       let shorthand = match property.as_shorthand() {
           Ok(s) => s,
           Err(_longhand_or_custom) => return,
       };

       let mut i = first_declaration;
       let mut len = self.len();
       while i < len {
           if !self.declarations[i].id().is_longhand_of(shorthand) {
               i += 1;
               continue;
           }

           self.remove_declaration_at(i);
           len -= 1;
       }
   }

   /// Take a declaration block known to contain a single property and serialize it.
   pub fn single_value_to_css(
       &self,
       property: &PropertyId,
       dest: &mut CssStringWriter,
       computed_values: Option<&ComputedValues>,
       stylist: &Stylist,
   ) -> fmt::Result {
       if let Ok(shorthand) = property.as_shorthand() {
           return self.shorthand_to_css(shorthand, dest);
       }

       // FIXME(emilio): Should this assert, or assert that the declaration is
       // the property we expect?
       let declaration = match self.declarations.get(0) {
           Some(d) => d,
           None => return Err(fmt::Error),
       };

       let mut rule_cache_conditions = RuleCacheConditions::default();
       let mut context = Context::new(
           StyleBuilder::new(
               stylist.device(),
               Some(stylist),
               computed_values,
               None,
               None,
               false,
           ),
           stylist.quirks_mode(),
           &mut rule_cache_conditions,
           ContainerSizeQuery::none(),
       );

       if let Some(cv) = computed_values {
           context.builder.custom_properties = cv.custom_properties().clone();
       };

       match (declaration, computed_values) {
           // If we have a longhand declaration with variables, those variables
           // will be stored as unparsed values.
           //
           // As a temporary measure to produce sensible results in Gecko's
           // 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(_)) => declaration
               .value
               .substitute_variables(
                   declaration.id,
                   &context.builder.custom_properties,
                   stylist,
                   &context,
                   &mut Default::default(),
                   &DummyAttributeProvider {},
               )
               .to_css(dest),
           (ref d, _) => d.to_css(dest),
       }
   }

   /// Convert AnimationValueMap to PropertyDeclarationBlock.
   pub fn from_animation_value_map(animation_value_map: &AnimationValueMap) -> Self {
       let len = animation_value_map.len();
       let mut declarations = ThinVec::with_capacity(len);
       let mut property_ids = PropertyDeclarationIdSet::default();

       for (property, animation_value) in animation_value_map.iter() {
           property_ids.insert(property.as_borrowed());
           declarations.push(animation_value.uncompute());
       }

       PropertyDeclarationBlock {
           declarations,
           property_ids,
           declarations_importance: SmallBitVec::from_elem(len, false),
       }
   }

   /// Returns true if the declaration block has a CSSWideKeyword for the given
   /// property.
   pub fn has_css_wide_keyword(&self, property: &PropertyId) -> bool {
       if let Err(longhand_or_custom) = property.as_shorthand() {
           if !self.property_ids.contains(longhand_or_custom) {
               return false;
           }
       }
       self.declarations.iter().any(|decl| {
           decl.id().is_or_is_longhand_of(property) && decl.get_css_wide_keyword().is_some()
       })
   }

   /// Like the method on ToCss, but without the type parameter to avoid
   /// accidentally monomorphizing this large function multiple times for
   /// different writers.
   ///
   /// https://drafts.csswg.org/cssom/#serialize-a-css-declaration-block
   pub fn to_css(&self, dest: &mut CssStringWriter) -> fmt::Result {
       let mut is_first_serialization = true; // trailing serializations should have a prepended space

       // Step 1 -> dest = result list

       // Step 2
       //
       // NOTE(emilio): We reuse this set for both longhands and shorthands
       // with subtly different meaning. For longhands, only longhands that
       // have actually been serialized (either by themselves, or as part of a
       // shorthand) appear here. For shorthands, all the shorthands that we've
       // attempted to serialize appear here.
       let mut already_serialized = NonCustomPropertyIdSet::new();

       // Step 3
       'declaration_loop: for (declaration, importance) in self.declaration_importance_iter() {
           // Step 3.1
           let property = declaration.id();
           let longhand_id = match property {
               PropertyDeclarationId::Longhand(id) => id,
               PropertyDeclarationId::Custom(..) => {
                   // Given the invariants that there are no duplicate
                   // properties in a declaration block, and that custom
                   // properties can't be part of a shorthand, we can just care
                   // about them here.
                   append_serialization(
                       dest,
                       &property,
                       AppendableValue::Declaration(declaration),
                       importance,
                       &mut is_first_serialization,
                   )?;
                   continue;
               },
           };

           // Step 3.2
           if already_serialized.contains(longhand_id.into()) {
               continue;
           }

           // Steps 3.3 & 3.4
           for shorthand in longhand_id.shorthands() {
               // We already attempted to serialize this shorthand before.
               if already_serialized.contains(shorthand.into()) {
                   continue;
               }
               already_serialized.insert(shorthand.into());

               if shorthand.is_legacy_shorthand() {
                   continue;
               }

               // Step 3.3.1:
               //     Let longhands be an array consisting of all CSS
               //     declarations in declaration block’s declarations that
               //     that are not in already serialized and have a property
               //     name that maps to one of the shorthand properties in
               //     shorthands.
               let longhands = {
                   // TODO(emilio): This could just index in an array if we
                   // remove pref-controlled longhands.
                   let mut ids = LonghandIdSet::new();
                   for longhand in shorthand.longhands() {
                       ids.insert(longhand);
                   }
                   ids
               };

               // Step 3.4.2
               //     If all properties that map to shorthand are not present
               //     in longhands, continue with the steps labeled shorthand
               //     loop.
               if !self.property_ids.contains_all_longhands(&longhands) {
                   continue;
               }

               // Step 3.4.3:
               //     Let current longhands be an empty array.
               let mut current_longhands = SmallVec::<[&_; 10]>::new();
               let mut logical_groups = LogicalGroupSet::new();
               let mut saw_one = false;
               let mut logical_mismatch = false;
               let mut seen = LonghandIdSet::new();
               let mut important_count = 0;

               // Step 3.4.4:
               //    Append all CSS declarations in longhands that have a
               //    property name that maps to shorthand to current longhands.
               for (declaration, importance) in self.declaration_importance_iter() {
                   let longhand = match declaration.id() {
                       PropertyDeclarationId::Longhand(id) => id,
                       PropertyDeclarationId::Custom(..) => continue,
                   };

                   if longhands.contains(longhand) {
                       saw_one = true;
                       if importance.important() {
                           important_count += 1;
                       }
                       current_longhands.push(declaration);
                       if shorthand != ShorthandId::All {
                           // All is special because it contains both physical
                           // and logical longhands.
                           if let Some(g) = longhand.logical_group() {
                               logical_groups.insert(g);
                           }
                           seen.insert(longhand);
                           if seen == longhands {
                               break;
                           }
                       }
                   } else if saw_one {
                       if let Some(g) = longhand.logical_group() {
                           if logical_groups.contains(g) {
                               logical_mismatch = true;
                               break;
                           }
                       }
                   }
               }

               // 3.4.5:
               //     If there is one or more CSS declarations in current
               //     longhands have their important flag set and one or more
               //     with it unset, continue with the steps labeled shorthand
               //     loop.
               let is_important = important_count > 0;
               if is_important && important_count != current_longhands.len() {
                   continue;
               }

               // 3.4.6:
               //    If there’s any declaration in declaration block in between
               //    the first and the last longhand in current longhands which
               //    belongs to the same logical property group, but has a
               //    different mapping logic as any of the longhands in current
               //    longhands, and is not in current longhands, continue with
               //    the steps labeled shorthand loop.
               if logical_mismatch {
                   continue;
               }

               let importance = if is_important {
                   Importance::Important
               } else {
                   Importance::Normal
               };

               // 3.4.7:
               //    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) {
                       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 {
                   AppendableValue::Css(css) => {
                       debug_assert!(!css.is_empty());
                       appendable_value
                   },
                   other => {
                       append_declaration_value(&mut v, other)?;

                       // 3.4.8:
                       //     If value is the empty string, continue with the
                       //     steps labeled shorthand loop.
                       if v.is_empty() {
                           continue;
                       }

                       AppendableValue::Css({
                           // Safety: serialization only generates valid utf-8.
                           #[cfg(feature = "gecko")]
                           unsafe {
                               v.as_str_unchecked()
                           }
                           #[cfg(feature = "servo")]
                           &v
                       })
                   },
               };

               // 3.4.9:
               //     Let serialized declaration be the result of invoking
               //     serialize a CSS declaration with property name shorthand,
               //     value value, and the important flag set if the CSS
               //     declarations in current longhands have their important
               //     flag set.
               //
               // 3.4.10:
               //     Append serialized declaration to list.
               append_serialization(
                   dest,
                   &shorthand,
                   value,
                   importance,
                   &mut is_first_serialization,
               )?;

               // 3.4.11:
               //     Append the property names of all items of current
               //     longhands to already serialized.
               for current_longhand in &current_longhands {
                   let longhand_id = match current_longhand.id() {
                       PropertyDeclarationId::Longhand(id) => id,
                       PropertyDeclarationId::Custom(..) => unreachable!(),
                   };

                   // Substep 9
                   already_serialized.insert(longhand_id.into());
               }

               // 3.4.12:
               //     Continue with the steps labeled declaration loop.
               continue 'declaration_loop;
           }

           // Steps 3.5, 3.6 & 3.7:
           //     Let value be the result of invoking serialize a CSS value of
           //     declaration.
           //
           //     Let serialized declaration be the result of invoking
           //     serialize a CSS declaration with property name property,
           //     value value, and the important flag set if declaration has
           //     its important flag set.
           //
           //     Append serialized declaration to list.
           append_serialization(
               dest,
               &property,
               AppendableValue::Declaration(declaration),
               importance,
               &mut is_first_serialization,
           )?;

           // Step 3.8:
           //     Append property to already serialized.
           already_serialized.insert(longhand_id.into());
       }

       // Step 4
       Ok(())
   }
}

/// 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, 'b: 'a> {
   /// A given declaration, of which we'll serialize just the value.
   Declaration(&'a PropertyDeclaration),
   /// A set of declarations for a given shorthand.
   ///
   /// FIXME: This needs more docs, where are the shorthands expanded? We print
   /// the property name before-hand, don't we?
   DeclarationsForShorthand(ShorthandId, &'a [&'b PropertyDeclaration]),
   /// A raw CSS string, coming for example from a property with CSS variables,
   /// or when storing a serialized shorthand value before appending directly.
   Css(&'a str),
}

/// Potentially appends whitespace after the first (property: value;) pair.
fn handle_first_serialization<W>(dest: &mut W, is_first_serialization: &mut bool) -> fmt::Result
where
   W: Write,
{
   if !*is_first_serialization {
       dest.write_char(' ')
   } else {
       *is_first_serialization = false;
       Ok(())
   }
}

/// Append a given kind of appendable value to a serialization.
pub fn append_declaration_value<'a, 'b: 'a>(
   dest: &mut CssStringWriter,
   appendable_value: AppendableValue<'a, 'b>,
) -> fmt::Result {
   match appendable_value {
       AppendableValue::Css(css) => dest.write_str(css),
       AppendableValue::Declaration(decl) => decl.to_css(dest),
       AppendableValue::DeclarationsForShorthand(shorthand, decls) => {
           shorthand.longhands_to_css(decls, dest)
       },
   }
}

/// Append a given property and value pair to a serialization.
pub fn append_serialization<'a, 'b: 'a, N>(
   dest: &mut CssStringWriter,
   property_name: &N,
   appendable_value: AppendableValue<'a, 'b>,
   importance: Importance,
   is_first_serialization: &mut bool,
) -> fmt::Result
where
   N: ToCss,
{
   handle_first_serialization(dest, is_first_serialization)?;

   property_name.to_css(&mut CssWriter::new(dest))?;
   dest.write_str(": ")?;

   append_declaration_value(dest, appendable_value)?;

   if importance.important() {
       dest.write_str(" !important")?;
   }

   dest.write_char(';')
}

/// A helper to parse the style attribute of an element, in order for this to be
/// shared between Servo and Gecko.
///
/// Inline because we call this cross-crate.
#[inline]
pub fn parse_style_attribute(
   input: &str,
   url_data: &UrlExtraData,
   error_reporter: Option<&dyn ParseErrorReporter>,
   quirks_mode: QuirksMode,
   rule_type: CssRuleType,
) -> PropertyDeclarationBlock {
   let context = ParserContext::new(
       Origin::Author,
       url_data,
       Some(rule_type),
       ParsingMode::DEFAULT,
       quirks_mode,
       /* namespaces = */ Default::default(),
       error_reporter,
       None,
   );

   let mut input = ParserInput::new(input);
   parse_property_declaration_list(&context, &mut Parser::new(&mut input), &[])
}

/// Parse a given property declaration. Can result in multiple
/// `PropertyDeclaration`s when expanding a shorthand, for example.
///
/// This does not attempt to parse !important at all.
#[inline]
pub fn parse_one_declaration_into(
   declarations: &mut SourcePropertyDeclaration,
   id: PropertyId,
   input: &str,
   origin: Origin,
   url_data: &UrlExtraData,
   error_reporter: Option<&dyn ParseErrorReporter>,
   parsing_mode: ParsingMode,
   quirks_mode: QuirksMode,
   rule_type: CssRuleType,
) -> Result<(), ()> {
   let context = ParserContext::new(
       origin,
       url_data,
       Some(rule_type),
       parsing_mode,
       quirks_mode,
       /* namespaces = */ Default::default(),
       error_reporter,
       None,
   );

   let property_id_for_error_reporting = if context.error_reporting_enabled() {
       Some(id.clone())
   } else {
       None
   };

   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,
                   &[],
                   err,
                   parser.slice_from(start_position),
                   property_id_for_error_reporting,
               )
           }
       })
}

/// A struct to parse property declarations.
struct PropertyDeclarationParser<'a, 'b: 'a, 'i> {
   context: &'a ParserContext<'b>,
   state: &'a mut DeclarationParserState<'i>,
}

/// The state needed to parse a declaration block.
///
/// It stores declarations in output_block.
#[derive(Default)]
pub struct DeclarationParserState<'i> {
   /// The output block where results are stored.
   output_block: PropertyDeclarationBlock,
   /// Declarations from the last declaration parsed. (note that a shorthand might expand to
   /// multiple declarations).
   declarations: SourcePropertyDeclaration,
   /// The importance from the last declaration parsed.
   importance: Importance,
   /// A list of errors that have happened so far. Not all of them might be reported.
   errors: SmallParseErrorVec<'i>,
   /// The start of the first declaration
   first_declaration_start: SourceLocation,
   /// The last parsed property id, if any.
   last_parsed_property_id: Option<PropertyId>,
}

impl<'i> DeclarationParserState<'i> {
   /// Getter for first_declaration_start.
   pub fn first_declaration_start(&self) -> SourceLocation {
       self.first_declaration_start
   }

   /// Returns whether any parsed declarations have been parsed so far.
   pub fn has_parsed_declarations(&self) -> bool {
       !self.output_block.is_empty()
   }

   /// Takes the parsed declarations.
   pub fn take_declarations(&mut self) -> PropertyDeclarationBlock {
       std::mem::take(&mut self.output_block)
   }

   /// Parse a single declaration value.
   pub fn parse_value<'t>(
       &mut self,
       context: &ParserContext,
       name: CowRcStr<'i>,
       input: &mut Parser<'i, 't>,
       declaration_start: &ParserState,
   ) -> Result<(), ParseError<'i>> {
       let id = match PropertyId::parse(&name, context) {
           Ok(id) => id,
           Err(..) => {
               return Err(input.new_custom_error(StyleParseErrorKind::UnknownProperty(name)));
           },
       };
       if context.error_reporting_enabled() {
           self.last_parsed_property_id = Some(id.clone());
       }
       input.parse_until_before(Delimiter::Bang, |input| {
           PropertyDeclaration::parse_into(&mut self.declarations, id, context, input)
       })?;
       self.importance = match input.try_parse(parse_important) {
           Ok(()) => {
               if !context.allows_important_declarations() {
                   return Err(
                       input.new_custom_error(StyleParseErrorKind::UnexpectedImportantDeclaration)
                   );
               }
               Importance::Important
           },
           Err(_) => Importance::Normal,
       };
       // In case there is still unparsed text in the declaration, we should roll back.
       input.expect_exhausted()?;
       let has_parsed_declarations = self.has_parsed_declarations();
       self.output_block
           .extend(self.declarations.drain(), self.importance);
       // We've successfully parsed a declaration, so forget about
       // `last_parsed_property_id`. It'd be wrong to associate any
       // following error with this property.
       self.last_parsed_property_id = None;

       if !has_parsed_declarations {
           self.first_declaration_start = declaration_start.source_location();
       }

       Ok(())
   }

   /// Reports any CSS errors that have ocurred if needed.
   #[inline]
   pub fn report_errors_if_needed(
       &mut self,
       context: &ParserContext,
       selectors: &[SelectorList<SelectorImpl>],
   ) {
       if self.errors.is_empty() {
           return;
       }
       self.do_report_css_errors(context, selectors);
   }

   #[cold]
   fn do_report_css_errors(
       &mut self,
       context: &ParserContext,
       selectors: &[SelectorList<SelectorImpl>],
   ) {
       for (error, slice, property) in self.errors.drain(..) {
           report_one_css_error(
               context,
               Some(&self.output_block),
               selectors,
               error,
               slice,
               property,
           )
       }
   }

   /// Resets the declaration parser state, and reports the error if needed.
   #[inline]
   pub fn did_error(&mut self, context: &ParserContext, error: ParseError<'i>, slice: &'i str) {
       self.declarations.clear();
       if !context.error_reporting_enabled() {
           return;
       }
       let property = self.last_parsed_property_id.take();
       self.errors.push((error, slice, property));
   }
}

/// Default methods reject all at rules.
impl<'a, 'b, 'i> AtRuleParser<'i> for PropertyDeclarationParser<'a, 'b, 'i> {
   type Prelude = ();
   type AtRule = ();
   type Error = StyleParseErrorKind<'i>;
}

/// Default methods reject all rules.
impl<'a, 'b, 'i> QualifiedRuleParser<'i> for PropertyDeclarationParser<'a, 'b, 'i> {
   type Prelude = ();
   type QualifiedRule = ();
   type Error = StyleParseErrorKind<'i>;
}

/// 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("_")
}

impl<'a, 'b, 'i> DeclarationParser<'i> for PropertyDeclarationParser<'a, 'b, 'i> {
   type Declaration = ();
   type Error = StyleParseErrorKind<'i>;

   fn parse_value<'t>(
       &mut self,
       name: CowRcStr<'i>,
       input: &mut Parser<'i, 't>,
       declaration_start: &ParserState,
   ) -> Result<(), ParseError<'i>> {
       self.state
           .parse_value(self.context, name, input, declaration_start)
   }
}

impl<'a, 'b, 'i> RuleBodyItemParser<'i, (), StyleParseErrorKind<'i>>
   for PropertyDeclarationParser<'a, 'b, 'i>
{
   fn parse_declarations(&self) -> bool {
       true
   }
   // TODO(emilio): Nesting.
   fn parse_qualified(&self) -> bool {
       false
   }
}

type SmallParseErrorVec<'i> = SmallVec<[(ParseError<'i>, &'i str, Option<PropertyId>); 2]>;

fn alias_of_known_property(name: &str) -> Option<PropertyId> {
   let mut prefixed = String::with_capacity(name.len() + 5);
   prefixed.push_str("-moz-");
   prefixed.push_str(name);
   PropertyId::parse_enabled_for_all_content(&prefixed).ok()
}

#[cold]
fn report_one_css_error<'i>(
   context: &ParserContext,
   block: Option<&PropertyDeclarationBlock>,
   selectors: &[SelectorList<SelectorImpl>],
   mut error: ParseError<'i>,
   slice: &str,
   property: Option<PropertyId>,
) {
   debug_assert!(context.error_reporting_enabled());

   fn all_properties_in_block(block: &PropertyDeclarationBlock, property: &PropertyId) -> bool {
       match property.as_shorthand() {
           Ok(id) => id
               .longhands()
               .all(|longhand| block.contains(PropertyDeclarationId::Longhand(longhand))),
           Err(longhand_or_custom) => block.contains(longhand_or_custom),
       }
   }

   if let ParseErrorKind::Custom(StyleParseErrorKind::UnknownProperty(ref name)) = error.kind {
       if is_non_mozilla_vendor_identifier(name) {
           // If the unrecognized property looks like a vendor-specific property,
           // silently ignore it instead of polluting the error output.
           return;
       }
       if let Some(alias) = alias_of_known_property(name) {
           // This is an unknown property, but its -moz-* version is known.
           // We don't want to report error if the -moz-* version is already
           // specified.
           if let Some(block) = block {
               if all_properties_in_block(block, &alias) {
                   return;
               }
           }
       }
   }

   if let Some(ref property) = property {
       if let Some(block) = block {
           if all_properties_in_block(block, property) {
               return;
           }
       }
       // Was able to parse property ID - Either an invalid value, or is constrained
       // by the rule block it's in to be invalid. In the former case, we need to unwrap
       // the error to be more specific.
       if !matches!(
           error.kind,
           ParseErrorKind::Custom(StyleParseErrorKind::UnexpectedImportantDeclaration)
       ) {
           error = match *property {
               PropertyId::Custom(ref c) => {
                   StyleParseErrorKind::new_invalid(format!("--{}", c), error)
               },
               _ => StyleParseErrorKind::new_invalid(
                   property.non_custom_id().unwrap().name(),
                   error,
               ),
           };
       }
   }

   let location = error.location;
   let error = ContextualParseError::UnsupportedPropertyDeclaration(slice, error, selectors);
   context.log_css_error(location, error);
}

/// Parse a list of property declarations and return a property declaration
/// block.
pub fn parse_property_declaration_list(
   context: &ParserContext,
   input: &mut Parser,
   selectors: &[SelectorList<SelectorImpl>],
) -> PropertyDeclarationBlock {
   let mut state = DeclarationParserState::default();
   let mut parser = PropertyDeclarationParser {
       context,
       state: &mut state,
   };
   let mut iter = RuleBodyParser::new(input, &mut parser);
   while let Some(declaration) = iter.next() {
       match declaration {
           Ok(()) => {},
           Err((error, slice)) => iter.parser.state.did_error(context, error, slice),
       }
   }
   parser.state.report_errors_if_needed(context, selectors);
   state.output_block
}