Bug 1850974 - Make :is(:host) work. r=zrhoffman

This should work per spec, see
w3c/csswg-drafts#9509.

Tweak a bit the selector flags set up so that checking for :host
selectors during CascadeData rebuilds is cheap.

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

Author: emilio

selectors/builder.rs

@@ -176,10 +176,24 @@ bitflags! {
         const HAS_SLOTTED = 1 << 1;
         const HAS_PART = 1 << 2;
         const HAS_PARENT = 1 << 3;
+        const HAS_NON_FEATURELESS_COMPONENT = 1 << 4;
+        const HAS_HOST = 1 << 5;
     }
 }
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq, ToShmem)]
+impl SelectorFlags {
+    /// When you nest a pseudo-element with something like:
+    ///
+    ///   ::before { & { .. } }
+    ///
+    /// It is not supposed to work, because :is(::before) is invalid. We can't propagate the
+    /// pseudo-flags from inner to outer selectors, to avoid breaking our invariants.
+    pub (crate) fn for_nesting() -> Self {
+        Self::all() - (Self::HAS_PSEUDO | Self::HAS_SLOTTED | Self::HAS_PART)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, ToShmem)]
 pub struct SpecificityAndFlags {
     /// There are two free bits here, since we use ten bits for each specificity
     /// kind (id, class, element).
@@ -188,33 +202,6 @@ pub struct SpecificityAndFlags {
     pub(crate) flags: SelectorFlags,
 }
 
-impl SpecificityAndFlags {
-    #[inline]
-    pub fn specificity(&self) -> u32 {
-        self.specificity
-    }
-
-    #[inline]
-    pub fn has_pseudo_element(&self) -> bool {
-        self.flags.intersects(SelectorFlags::HAS_PSEUDO)
-    }
-
-    #[inline]
-    pub fn has_parent_selector(&self) -> bool {
-        self.flags.intersects(SelectorFlags::HAS_PARENT)
-    }
-
-    #[inline]
-    pub fn is_slotted(&self) -> bool {
-        self.flags.intersects(SelectorFlags::HAS_SLOTTED)
-    }
-
-    #[inline]
-    pub fn is_part(&self) -> bool {
-        self.flags.intersects(SelectorFlags::HAS_PART)
-    }
-}
-
 const MAX_10BIT: u32 = (1u32 << 10) - 1;
 
 #[derive(Add, AddAssign, Clone, Copy, Default, Eq, Ord, PartialEq, PartialOrd)]
@@ -276,9 +263,12 @@ where
                 flags.insert(SelectorFlags::HAS_PSEUDO);
                 specificity.element_selectors += 1
             },
-            Component::LocalName(..) => specificity.element_selectors += 1,
+            Component::LocalName(..) => {
+                flags.insert(SelectorFlags::HAS_NON_FEATURELESS_COMPONENT);
+                specificity.element_selectors += 1
+            },
             Component::Slotted(ref selector) => {
-                flags.insert(SelectorFlags::HAS_SLOTTED);
+                flags.insert(SelectorFlags::HAS_SLOTTED | SelectorFlags::HAS_NON_FEATURELESS_COMPONENT);
                 specificity.element_selectors += 1;
                 // Note that due to the way ::slotted works we only compete with
                 // other ::slotted rules, so the above rule doesn't really
@@ -287,21 +277,19 @@ where
                 //
                 // See: https://github.com/w3c/csswg-drafts/issues/1915
                 *specificity += Specificity::from(selector.specificity());
-                if selector.has_parent_selector() {
-                    flags.insert(SelectorFlags::HAS_PARENT);
-                }
+                flags.insert(selector.flags());
             },
             Component::Host(ref selector) => {
+                flags.insert(SelectorFlags::HAS_HOST);
                 specificity.class_like_selectors += 1;
                 if let Some(ref selector) = *selector {
                     // See: https://github.com/w3c/csswg-drafts/issues/1915
                     *specificity += Specificity::from(selector.specificity());
-                    if selector.has_parent_selector() {
-                        flags.insert(SelectorFlags::HAS_PARENT);
-                    }
+                    flags.insert(selector.flags() - SelectorFlags::HAS_NON_FEATURELESS_COMPONENT);
                 }
             },
             Component::ID(..) => {
+                flags.insert(SelectorFlags::HAS_NON_FEATURELESS_COMPONENT);
                 specificity.id_selectors += 1;
             },
             Component::Class(..) |
@@ -313,6 +301,7 @@ where
             Component::Scope |
             Component::Nth(..) |
             Component::NonTSPseudoClass(..) => {
+                flags.insert(SelectorFlags::HAS_NON_FEATURELESS_COMPONENT);
                 specificity.class_like_selectors += 1;
             },
             Component::NthOf(ref nth_of_data) => {
@@ -325,7 +314,7 @@ where
                 specificity.class_like_selectors += 1;
                 let sf = selector_list_specificity_and_flags(nth_of_data.selectors().iter());
                 *specificity += Specificity::from(sf.specificity);
-                flags.insert(sf.flags);
+                flags.insert(sf.flags | SelectorFlags::HAS_NON_FEATURELESS_COMPONENT);
             },
             // https://drafts.csswg.org/selectors/#specificity-rules:
             //
@@ -344,7 +333,7 @@ where
             Component::Has(ref relative_selectors) => {
                 let sf = relative_selector_list_specificity_and_flags(relative_selectors);
                 *specificity += Specificity::from(sf.specificity);
-                flags.insert(sf.flags);
+                flags.insert(sf.flags | SelectorFlags::HAS_NON_FEATURELESS_COMPONENT);
             },
             Component::ExplicitUniversalType |
             Component::ExplicitAnyNamespace |
@@ -354,6 +343,7 @@ where
             Component::RelativeSelectorAnchor |
             Component::Invalid(..) => {
                 // Does not affect specificity
+                flags.insert(SelectorFlags::HAS_NON_FEATURELESS_COMPONENT);
             },
         }
     }
@@ -377,9 +367,7 @@ pub(crate) fn selector_list_specificity_and_flags<'a, Impl: SelectorImpl>(
     let mut flags = SelectorFlags::empty();
     for selector in itr {
         specificity = std::cmp::max(specificity, selector.specificity());
-        if selector.has_parent_selector() {
-            flags.insert(SelectorFlags::HAS_PARENT);
-        }
+        flags.insert(selector.flags());
     }
     SpecificityAndFlags { specificity, flags }
 }