Bug 1954142 - Fix StyleResolver to account for element-backed pseudo elements. r=keithamus

This allows for proper parsing of nested pseudo elements such as
`::before::marker`, `::details-content::before`,
`::details-content::first-letter`, and so on.

Co-authored-by: Luke Warlow <[email protected]>
Co-authored-by: Keith Cirkel <[email protected]>

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

Author: emilio

selectors/parser.rs

@@ -938,6 +938,32 @@ impl<Impl: SelectorImpl> Selector<Impl> {
         None
     }
 
+    #[inline]
+    pub fn pseudo_elements(&self) -> SmallVec<[&Impl::PseudoElement; 3]> {
+        let mut pseudos = SmallVec::new();
+
+        if !self.has_pseudo_element() {
+            return pseudos;
+        }
+
+        let mut iter = self.iter();
+        loop {
+            for component in &mut iter {
+                if let Component::PseudoElement(ref pseudo) = *component {
+                    pseudos.push(pseudo);
+                }
+            }
+            match iter.next_sequence() {
+                Some(Combinator::PseudoElement) => {},
+                _ => break,
+            }
+        }
+
+        debug_assert!(!pseudos.is_empty(), "has_pseudo_element lied!");
+
+        pseudos
+    }
+
     /// Whether this selector (pseudo-element part excluded) matches every element.
     ///
     /// Used for "pre-computed" pseudo-elements in components/style/stylist.rs
@@ -3717,6 +3743,7 @@ pub mod tests {
         Before,
         After,
         Marker,
+        DetailsContent,
         Highlight(String),
     }
 
@@ -3740,7 +3767,7 @@ pub mod tests {
         }
 
         fn is_element_backed(&self) -> bool {
-            false
+            matches!(self, Self::DetailsContent)
         }
     }
 
@@ -3784,6 +3811,7 @@ pub mod tests {
                 PseudoElement::Before => dest.write_str("::before"),
                 PseudoElement::After => dest.write_str("::after"),
                 PseudoElement::Marker => dest.write_str("::marker"),
+                PseudoElement::DetailsContent => dest.write_str("::details-content"),
                 PseudoElement::Highlight(ref name) => {
                     dest.write_str("::highlight(")?;
                     serialize_identifier(&name, dest)?;
@@ -3954,6 +3982,7 @@ pub mod tests {
                 "before" => return Ok(PseudoElement::Before),
                 "after" => return Ok(PseudoElement::After),
                 "marker" => return Ok(PseudoElement::Marker),
+                "details-content" => return Ok(PseudoElement::DetailsContent),
                 _ => {}
             }
             Err(
@@ -4645,6 +4674,26 @@ pub mod tests {
         assert!(parse("::marker::marker").is_err());
     }
 
+    #[test]
+    fn test_pseudo_on_element_backed_pseudo() {
+        let list = parse("::details-content::before").unwrap();
+        let selector = &list.slice()[0];
+        let mut iter = selector.iter();
+        assert_eq!(
+            iter.next(),
+            Some(&Component::PseudoElement(PseudoElement::Before))
+        );
+        assert_eq!(iter.next(), None);
+        let combinator = iter.next_sequence();
+        assert_eq!(combinator, Some(Combinator::PseudoElement));
+        assert!(matches!(iter.next(), Some(&Component::PseudoElement(PseudoElement::DetailsContent))));
+        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_universal() {
         let list = parse_ns(

style/dom.rs

@@ -751,12 +751,12 @@ pub trait TElement:
     /// element-backed pseudo-element, in which case we return the originating
     /// element.
     fn rule_hash_target(&self) -> Self {
-        if self.is_pseudo_element() {
-            self.pseudo_element_originating_element()
+        let mut cur = *self;
+        while cur.is_pseudo_element() {
+            cur = cur.pseudo_element_originating_element()
                 .expect("Trying to collect rules for a detached pseudo-element")
-        } else {
-            *self
         }
+        cur
     }
 
     /// Executes the callback for each applicable style rule data which isn't

style/gecko/pseudo_element.rs

@@ -220,7 +220,7 @@ impl PseudoElementTrait for PseudoElement {
     /// flat tree parent, which might not be the originating element.
     #[inline]
     fn is_element_backed(&self) -> bool {
-        // Note: We doen't include ::view-transition here because it inherits from the originating
+        // Note: We don't include ::view-transition here because it inherits from the originating
         // element, instead of the snapshot containing block.
         self.is_named_view_transition() || *self == PseudoElement::DetailsContent
     }

style/rule_collector.rs

@@ -13,7 +13,7 @@ use crate::selector_parser::PseudoElement;
 use crate::shared_lock::Locked;
 use crate::stylesheets::{layer_rule::LayerOrder, Origin};
 use crate::stylist::{AuthorStylesEnabled, CascadeData, Rule, RuleInclusion, Stylist};
-use selectors::matching::{MatchingContext, MatchingMode};
+use selectors::matching::MatchingContext;
 use servo_arc::ArcBorrow;
 use smallvec::SmallVec;
 
@@ -66,7 +66,7 @@ where
     element: E,
     rule_hash_target: E,
     stylist: &'a Stylist,
-    pseudo_element: Option<&'a PseudoElement>,
+    pseudo_elements: SmallVec<[PseudoElement; 1]>,
     style_attribute: Option<ArcBorrow<'a, Locked<PropertyDeclarationBlock>>>,
     smil_override: Option<ArcBorrow<'a, Locked<PropertyDeclarationBlock>>>,
     animation_declarations: AnimationDeclarations,
@@ -86,37 +86,30 @@ where
     pub fn new(
         stylist: &'a Stylist,
         element: E,
-        pseudo_element: Option<&'a PseudoElement>,
+        pseudo_elements: SmallVec<[PseudoElement; 1]>,
         style_attribute: Option<ArcBorrow<'a, Locked<PropertyDeclarationBlock>>>,
         smil_override: Option<ArcBorrow<'a, Locked<PropertyDeclarationBlock>>>,
         animation_declarations: AnimationDeclarations,
         rule_inclusion: RuleInclusion,
         rules: &'a mut ApplicableDeclarationList,
         context: &'a mut MatchingContext<'b, E::Impl>,
     ) -> Self {
-        // When we're matching with matching_mode =
-        // `ForStatelessPseudoeElement`, the "target" for the rule hash is the
-        // element itself, since it's what's generating the pseudo-element.
-        let rule_hash_target = match context.matching_mode() {
-            MatchingMode::ForStatelessPseudoElement => element,
-            MatchingMode::Normal => element.rule_hash_target(),
-        };
-
+        let rule_hash_target = element.rule_hash_target();
         let matches_user_and_content_rules = rule_hash_target.matches_user_and_content_rules();
 
         // Gecko definitely has pseudo-elements with style attributes, like
         // ::-moz-color-swatch.
         debug_assert!(
-            cfg!(feature = "gecko") || style_attribute.is_none() || pseudo_element.is_none(),
+            cfg!(feature = "gecko") || style_attribute.is_none() || pseudo_elements.is_empty(),
             "Style attributes do not apply to pseudo-elements"
         );
-        debug_assert!(pseudo_element.map_or(true, |p| !p.is_precomputed()));
+        debug_assert!(pseudo_elements.iter().all(|p| !p.is_precomputed()));
 
         Self {
             element,
             rule_hash_target,
             stylist,
-            pseudo_element,
+            pseudo_elements,
             style_attribute,
             smil_override,
             animation_declarations,
@@ -162,7 +155,7 @@ where
         };
 
         let cascade_data = self.stylist.cascade_data().borrow_for_origin(origin);
-        let map = match cascade_data.normal_rules(self.pseudo_element) {
+        let map = match cascade_data.normal_rules(&self.pseudo_elements) {
             Some(m) => m,
             None => return,
         };
@@ -180,7 +173,7 @@ where
 
     #[cfg(feature = "gecko")]
     fn collect_view_transition_dynamic_rules(&mut self) {
-        if !self.pseudo_element.is_some_and(|p| p.is_named_view_transition()) {
+        if !self.pseudo_elements.first().is_some_and(|p| p.is_named_view_transition()) {
             return;
         }
         let len_before_vt_rules = self.rules.len();
@@ -205,7 +198,7 @@ where
     /// These go before author rules, but after user rules, see:
     /// https://drafts.csswg.org/css-cascade/#preshint
     fn collect_presentational_hints(&mut self) {
-        if self.pseudo_element.is_some() {
+        if !self.pseudo_elements.is_empty() {
             return;
         }
 
@@ -289,7 +282,7 @@ where
                 Some(d) => d,
                 None => continue,
             };
-            let slotted_rules = match data.slotted_rules(self.pseudo_element) {
+            let slotted_rules = match data.slotted_rules(&self.pseudo_elements) {
                 Some(r) => r,
                 None => continue,
             };
@@ -323,7 +316,7 @@ where
 
         let cascade_level = CascadeLevel::same_tree_author_normal();
         self.in_shadow_tree(containing_shadow.host(), |collector| {
-            if let Some(map) = cascade_data.normal_rules(collector.pseudo_element) {
+            if let Some(map) = cascade_data.normal_rules(&collector.pseudo_elements) {
                 collector.collect_rules_in_map(map, cascade_level, cascade_data);
             }
 
@@ -333,7 +326,7 @@ where
                 return;
             }
 
-            let part_rules = match cascade_data.part_rules(collector.pseudo_element) {
+            let part_rules = match cascade_data.part_rules(&collector.pseudo_elements) {
                 Some(p) => p,
                 None => return,
             };
@@ -358,7 +351,7 @@ where
             None => return,
         };
 
-        let host_rules = match style_data.featureless_host_rules(self.pseudo_element) {
+        let host_rules = match style_data.featureless_host_rules(&self.pseudo_elements) {
             Some(rules) => rules,
             None => return,
         };
@@ -415,7 +408,7 @@ where
             };
 
             if let Some(cascade_data) = cascade_data {
-                if let Some(part_rules) = cascade_data.part_rules(self.pseudo_element) {
+                if let Some(part_rules) = cascade_data.part_rules(&self.pseudo_elements) {
                     let containing_host = outer_shadow.map(|s| s.host());
                     let cascade_level = CascadeLevel::AuthorNormal {
                         shadow_cascade_order,

style/style_resolver.rs

@@ -297,8 +297,7 @@ where
 
         let mut pseudo_styles = EagerPseudoStyles::default();
 
-        // FIXME(bug 1954142): This should account for element-backed pseudo elements.
-        if !self.element.is_pseudo_element() {
+        if !self.element.implemented_pseudo_element().is_some_and(|p| !PseudoElementTrait::is_element_backed(&p)) {
             let layout_parent_style_for_pseudo =
                 layout_parent_style_for_pseudo(&primary_style, layout_parent_style);
             SelectorImpl::each_eagerly_cascaded_pseudo_element(|pseudo| {
@@ -377,9 +376,6 @@ where
     ) -> ResolvedStyle {
         debug_assert!(pseudo.map_or(true, |p| p.is_eager()));
 
-        let implemented_pseudo = self.element.implemented_pseudo_element();
-        let pseudo = pseudo.or(implemented_pseudo.as_ref());
-
         let mut conditions = Default::default();
         let values = self.context.shared.stylist.cascade_style_and_visited(
             Some(self.element),
@@ -523,11 +519,10 @@ where
         );
 
         let stylist = &self.context.shared.stylist;
-        let implemented_pseudo = self.element.implemented_pseudo_element();
         // Compute the primary rule node.
         stylist.push_applicable_declarations(
             self.element,
-            implemented_pseudo.as_ref(),
+            None,
             self.element.style_attribute(),
             self.element.smil_override(),
             self.element.animation_declarations(self.context.shared),
@@ -571,10 +566,6 @@ where
             self.element, pseudo_element, visited_handling
         );
         debug_assert!(pseudo_element.is_eager());
-        debug_assert!(
-            !self.element.is_pseudo_element(),
-            "Element pseudos can't have any other eager pseudo."
-        );
 
         let mut applicable_declarations = ApplicableDeclarationList::new();