Bug 1980215 - Support parsing of ::before::marker,::after::marker r=emilio,firefox-style-system-reviewers

This supports parsing of pseudo elements after the `::before` and `::after`
pseudos. The only pseudo element allowed after these is `::marker`. This also
updates the UA stylesheet to include the newly updated `::before::marker,
`::after::marker` selector.

Differential Revision: https://phabricator.services.mozilla.com/D259290

Author: keithamus

selectors/parser.rs

@@ -47,12 +47,24 @@ pub trait PseudoElement: Sized + ToCss {
         false
     }
 
+    /// Whether this pseudo-element is valid when directly after a ::before/::after pseudo.
+    fn valid_after_before_or_after(&self) -> bool {
+        false
+    }
+
     /// Whether this pseudo-element is element-backed.
     /// https://drafts.csswg.org/css-pseudo-4/#element-like
     fn is_element_backed(&self) -> bool {
         false
     }
 
+    /// Whether this pseudo-element is ::before or ::after pseudo element,
+    /// which are treated specially when deciding what can come after them.
+    /// https://drafts.csswg.org/css-pseudo-4/#generated-content
+    fn is_before_or_after(&self) -> bool {
+        false
+    }
+
     /// The count we contribute to the specificity from this pseudo-element.
     fn specificity_count(&self) -> u32 {
         1
@@ -129,32 +141,30 @@ bitflags! {
         /// disallowed. If this flag is set, `AFTER_NON_ELEMENT_BACKED_PSEUDO` must be set
         /// as well.
         const AFTER_NON_STATEFUL_PSEUDO_ELEMENT = 1 << 4;
+        // Whether we've parsed a generated pseudo-element (as in ::before, ::after).
+        // If so then some other pseudo elements are disallowed (e.g. another generated pseudo)
+        // while others allowed (e.g. ::marker).
+        const AFTER_BEFORE_OR_AFTER_PSEUDO = 1 << 5;
 
         /// Whether we are after any of the pseudo-like things.
-        const AFTER_PSEUDO = Self::AFTER_PART_LIKE.bits() | Self::AFTER_SLOTTED.bits() | Self::AFTER_NON_ELEMENT_BACKED_PSEUDO.bits();
+        const AFTER_PSEUDO = Self::AFTER_PART_LIKE.bits() | Self::AFTER_SLOTTED.bits() | Self::AFTER_NON_ELEMENT_BACKED_PSEUDO.bits() | Self::AFTER_BEFORE_OR_AFTER_PSEUDO.bits();
 
         /// Whether we explicitly disallow combinators.
-        const DISALLOW_COMBINATORS = 1 << 5;
+        const DISALLOW_COMBINATORS = 1 << 6;
 
         /// Whether we explicitly disallow pseudo-element-like things.
-        const DISALLOW_PSEUDOS = 1 << 6;
+        const DISALLOW_PSEUDOS = 1 << 7;
 
         /// Whether we explicitly disallow relative selectors (i.e. `:has()`).
-        const DISALLOW_RELATIVE_SELECTOR = 1 << 7;
+        const DISALLOW_RELATIVE_SELECTOR = 1 << 8;
 
         /// Whether we've parsed a pseudo-element which is in a pseudo-element tree (i.e. it is a
         /// descendant pseudo of a pseudo-element root).
-        const IN_PSEUDO_ELEMENT_TREE = 1 << 8;
+        const IN_PSEUDO_ELEMENT_TREE = 1 << 9;
     }
 }
 
 impl SelectorParsingState {
-    #[inline]
-    fn allows_pseudos(self) -> bool {
-        // NOTE(emilio): We allow pseudos after ::part and such.
-        !self.intersects(Self::AFTER_NON_ELEMENT_BACKED_PSEUDO | Self::DISALLOW_PSEUDOS)
-    }
-
     #[inline]
     fn allows_slotted(self) -> bool {
         !self.intersects(Self::AFTER_PSEUDO | Self::DISALLOW_PSEUDOS)
@@ -2772,6 +2782,7 @@ where
         if state.intersects(SelectorParsingState::AFTER_PSEUDO) {
             debug_assert!(state.intersects(
                 SelectorParsingState::AFTER_NON_ELEMENT_BACKED_PSEUDO |
+                SelectorParsingState::AFTER_BEFORE_OR_AFTER_PSEUDO |
                     SelectorParsingState::AFTER_SLOTTED |
                     SelectorParsingState::AFTER_PART_LIKE
             ));
@@ -3310,6 +3321,9 @@ where
                     state.insert(SelectorParsingState::AFTER_PART_LIKE);
                 } else {
                     state.insert(SelectorParsingState::AFTER_NON_ELEMENT_BACKED_PSEUDO);
+                    if p.is_before_or_after() {
+                        state.insert(SelectorParsingState::AFTER_BEFORE_OR_AFTER_PSEUDO);
+                    }
                 }
                 if !p.accepts_state_pseudo_classes() {
                     state.insert(SelectorParsingState::AFTER_NON_STATEFUL_PSEUDO_ELEMENT);
@@ -3552,7 +3566,15 @@ where
             };
             let is_pseudo_element = !is_single_colon || is_css2_pseudo_element(&name);
             if is_pseudo_element {
-                if !state.allows_pseudos() {
+                // Pseudos after pseudo elements are not allowed in some cases:
+                // - Some states will disallow pseudos, such as the interiors of
+                // :has/:is/:where/:not (DISALLOW_PSEUDOS).
+                // - Non-element backed pseudos do not allow other pseudos to follow (AFTER_NON_ELEMENT_BACKED_PSEUDO)...
+                // - ... except ::before and ::after, which allow _some_ pseudos.
+                if state.intersects(SelectorParsingState::DISALLOW_PSEUDOS)
+                    || (state.intersects(SelectorParsingState::AFTER_NON_ELEMENT_BACKED_PSEUDO)
+                        && !state.intersects(SelectorParsingState::AFTER_BEFORE_OR_AFTER_PSEUDO))
+                {
                     return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));
                 }
                 let pseudo_element = if is_functional {
@@ -3590,6 +3612,12 @@ where
                     P::parse_pseudo_element(parser, location, name)?
                 };
 
+                if state.intersects(SelectorParsingState::AFTER_BEFORE_OR_AFTER_PSEUDO) &&
+                    !pseudo_element.valid_after_before_or_after()
+                {
+                    return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));
+                }
+
                 if state.intersects(SelectorParsingState::AFTER_SLOTTED) &&
                     !pseudo_element.valid_after_slotted()
                 {
@@ -3688,6 +3716,7 @@ pub mod tests {
     pub enum PseudoElement {
         Before,
         After,
+        Marker,
         Highlight(String),
     }
 
@@ -3702,8 +3731,16 @@ pub mod tests {
             true
         }
 
+        fn valid_after_before_or_after(&self) -> bool {
+           matches!(self, Self::Marker)
+        }
+
+        fn is_before_or_after(&self) -> bool {
+            matches!(self, Self::Before | Self::After)
+        }
+
         fn is_element_backed(&self) -> bool {
-            true
+            false
         }
     }
 
@@ -3746,6 +3783,7 @@ pub mod tests {
             match *self {
                 PseudoElement::Before => dest.write_str("::before"),
                 PseudoElement::After => dest.write_str("::after"),
+                PseudoElement::Marker => dest.write_str("::marker"),
                 PseudoElement::Highlight(ref name) => {
                     dest.write_str("::highlight(")?;
                     serialize_identifier(&name, dest)?;
@@ -3915,6 +3953,7 @@ pub mod tests {
             match_ignore_ascii_case! { &name,
                 "before" => return Ok(PseudoElement::Before),
                 "after" => return Ok(PseudoElement::After),
+                "marker" => return Ok(PseudoElement::Marker),
                 _ => {}
             }
             Err(
@@ -4579,6 +4618,33 @@ pub mod tests {
         assert_eq!(iter.next_sequence(), None);
     }
 
+    #[test]
+    fn test_pseudo_before_marker() {
+        let list = parse("::before::marker").unwrap();
+        let selector = &list.slice()[0];
+        let mut iter = selector.iter();
+        assert_eq!(
+            iter.next(),
+            Some(&Component::PseudoElement(PseudoElement::Marker))
+        );
+        assert_eq!(iter.next(), None);
+        let combinator = iter.next_sequence();
+        assert_eq!(combinator, Some(Combinator::PseudoElement));
+        assert!(matches!(iter.next(), Some(&Component::PseudoElement(PseudoElement::Before))));
+        assert_eq!(iter.next(), None);
+        let combinator = iter.next_sequence();
+        assert_eq!(combinator, Some(Combinator::PseudoElement));
+        assert_eq!(iter.next(), None);
+        assert_eq!(iter.next_sequence(), None);
+    }
+
+    #[test]
+    fn test_pseudo_duplicate_before_after_or_marker() {
+        assert!(parse("::before::before").is_err());
+        assert!(parse("::after::after").is_err());
+        assert!(parse("::marker::marker").is_err());
+    }
+
     #[test]
     fn test_universal() {
         let list = parse_ns(

style/gecko/pseudo_element.rs

@@ -17,6 +17,7 @@ use crate::string_cache::Atom;
 use crate::values::serialize_atom_identifier;
 use crate::values::AtomIdent;
 use cssparser::{ToCss, Parser};
+use selectors::parser::PseudoElement as PseudoElementTrait;
 use static_prefs::pref;
 use std::fmt;
 use style_traits::ParseError;
@@ -170,7 +171,7 @@ impl ToCss for PtNameAndClassSelector {
     }
 }
 
-impl ::selectors::parser::PseudoElement for PseudoElement {
+impl PseudoElementTrait for PseudoElement {
     type Impl = SelectorImpl;
 
     // ::slotted() should support all tree-abiding pseudo-elements, see
@@ -189,6 +190,13 @@ impl ::selectors::parser::PseudoElement for PseudoElement {
         )
     }
 
+    // ::before/::after should support ::marker, but no others.
+    // https://drafts.csswg.org/css-pseudo-4/#marker-pseudo
+    #[inline]
+    fn valid_after_before_or_after(&self) -> bool {
+        matches!(*self, Self::Marker)
+    }
+
     #[inline]
     fn accepts_state_pseudo_classes(&self) -> bool {
         // Note: if the pseudo element is a descendants of a pseudo element, `only-child` should be
@@ -216,6 +224,12 @@ impl ::selectors::parser::PseudoElement for PseudoElement {
         // element, instead of the snapshot containing block.
         self.is_named_view_transition() || *self == PseudoElement::DetailsContent
     }
+
+    /// Whether the current pseudo element is ::before or ::after.
+    #[inline]
+    fn is_before_or_after(&self) -> bool {
+        matches!(*self, PseudoElement::Before | PseudoElement::After)
+    }
 }
 
 impl PseudoElement {
@@ -261,12 +275,6 @@ impl PseudoElement {
         matches!(*self, Self::Before | Self::After | Self::Marker)
     }
 
-    /// Whether the current pseudo element is ::before or ::after.
-    #[inline]
-    pub fn is_before_or_after(&self) -> bool {
-        matches!(*self, Self::Before | Self::After)
-    }
-
     /// Whether this pseudo-element is the ::before pseudo.
     #[inline]
     pub fn is_before(&self) -> bool {

style/style_resolver.rs

@@ -20,6 +20,7 @@ use selectors::matching::{
     IncludeStartingStyle, MatchingContext, MatchingForInvalidation, MatchingMode,
     NeedsSelectorFlags, VisitedHandlingMode,
 };
+use selectors::parser::PseudoElement as PseudoElementTrait;
 use servo_arc::Arc;
 
 /// Whether pseudo-elements should be resolved or not.

style/traversal.rs

@@ -15,6 +15,7 @@ use crate::style_resolver::{PseudoElementResolution, StyleResolverForElement};
 use crate::stylist::RuleInclusion;
 use crate::traversal_flags::TraversalFlags;
 use selectors::matching::SelectorCaches;
+use selectors::parser::PseudoElement as PseudoElementTrait;
 use smallvec::SmallVec;
 use std::collections::HashMap;
 

style/values/resolved/counters.rs

@@ -5,6 +5,7 @@
 //! Resolved values for counter properties
 
 use super::{Context, ToResolvedValue};
+use selectors::parser::PseudoElement;
 use crate::values::computed;
 
 /// https://drafts.csswg.org/css-content/#content-property