servo/components/selectors/tree.rs

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
   4
   5 //! Traits that nodes must implement. Breaks the otherwise-cyclic dependency
   6 //! between layout and style.
   7
   8 use crate::attr::{AttrSelectorOperation, CaseSensitivity, NamespaceConstraint};
   9 use crate::bloom::BloomFilter;
  10 use crate::matching::{ElementSelectorFlags, MatchingContext};
  11 use crate::parser::SelectorImpl;
  12 use std::fmt::Debug;
  13 use std::ptr::NonNull;
  14
  15 /// Opaque representation of an Element, for identity comparisons.
  16 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
  17 pub struct OpaqueElement(NonNull<()>);
  18
  19 unsafe impl Send for OpaqueElement {}
  20
  21 impl OpaqueElement {
  22     /// Creates a new OpaqueElement from an arbitrarily-typed pointer.
  23     pub fn new<T>(ptr: &T) -> Self {
  24         unsafe {
  25             OpaqueElement(NonNull::new_unchecked(
  26                 ptr as *const T as *const () as *mut (),
  27             ))
  28         }
  29     }
  30 }
  31
  32 pub trait Element: Sized + Clone + Debug {
  33     type Impl: SelectorImpl;
  34
  35     /// Converts self into an opaque representation.
  36     fn opaque(&self) -> OpaqueElement;
  37
  38     fn parent_element(&self) -> Option<Self>;
  39
  40     /// Whether the parent node of this element is a shadow root.
  41     fn parent_node_is_shadow_root(&self) -> bool;
  42
  43     /// The host of the containing shadow root, if any.
  44     fn containing_shadow_host(&self) -> Option<Self>;
  45
  46     /// The parent of a given pseudo-element, after matching a pseudo-element
  47     /// selector.
  48     ///
  49     /// This is guaranteed to be called in a pseudo-element.
  50     fn pseudo_element_originating_element(&self) -> Option<Self> {
  51         debug_assert!(self.is_pseudo_element());
  52         self.parent_element()
  53     }
  54
  55     /// Whether we're matching on a pseudo-element.
  56     fn is_pseudo_element(&self) -> bool;
  57
  58     /// Skips non-element nodes
  59     fn prev_sibling_element(&self) -> Option<Self>;
  60
  61     /// Skips non-element nodes
  62     fn next_sibling_element(&self) -> Option<Self>;
  63
  64     /// Skips non-element nodes
  65     fn first_element_child(&self) -> Option<Self>;
  66
  67     fn is_html_element_in_html_document(&self) -> bool;
  68
  69     fn has_local_name(&self, local_name: &<Self::Impl as SelectorImpl>::BorrowedLocalName) -> bool;
  70
  71     /// Empty string for no namespace
  72     fn has_namespace(&self, ns: &<Self::Impl as SelectorImpl>::BorrowedNamespaceUrl) -> bool;
  73
  74     /// Whether this element and the `other` element have the same local name and namespace.
  75     fn is_same_type(&self, other: &Self) -> bool;
  76
  77     fn attr_matches(
  78         &self,
  79         ns: &NamespaceConstraint<&<Self::Impl as SelectorImpl>::NamespaceUrl>,
  80         local_name: &<Self::Impl as SelectorImpl>::LocalName,
  81         operation: &AttrSelectorOperation<&<Self::Impl as SelectorImpl>::AttrValue>,
  82     ) -> bool;
  83
  84     fn has_attr_in_no_namespace(
  85         &self,
  86         local_name: &<Self::Impl as SelectorImpl>::LocalName,
  87     ) -> bool {
  88         self.attr_matches(
  89             &NamespaceConstraint::Specific(&crate::parser::namespace_empty_string::<Self::Impl>()),
  90             local_name,
  91             &AttrSelectorOperation::Exists,
  92         )
  93     }
  94
  95     fn match_non_ts_pseudo_class(
  96         &self,
  97         pc: &<Self::Impl as SelectorImpl>::NonTSPseudoClass,
  98         context: &mut MatchingContext<Self::Impl>,
  99     ) -> bool;
 100
 101     fn match_pseudo_element(
 102         &self,
 103         pe: &<Self::Impl as SelectorImpl>::PseudoElement,
 104         context: &mut MatchingContext<Self::Impl>,
 105     ) -> bool;
 106
 107     /// Sets selector flags on the elemnt itself or the parent, depending on the
 108     /// flags, which indicate what kind of work may need to be performed when
 109     /// DOM state changes.
 110     fn apply_selector_flags(&self, flags: ElementSelectorFlags);
 111
 112     /// Whether this element is a `link`.
 113     fn is_link(&self) -> bool;
 114
 115     /// Returns whether the element is an HTML <slot> element.
 116     fn is_html_slot_element(&self) -> bool;
 117
 118     /// Returns the assigned <slot> element this element is assigned to.
 119     ///
 120     /// Necessary for the `::slotted` pseudo-class.
 121     fn assigned_slot(&self) -> Option<Self> {
 122         None
 123     }
 124
 125     fn has_id(
 126         &self,
 127         id: &<Self::Impl as SelectorImpl>::Identifier,
 128         case_sensitivity: CaseSensitivity,
 129     ) -> bool;
 130
 131     fn has_class(
 132         &self,
 133         name: &<Self::Impl as SelectorImpl>::Identifier,
 134         case_sensitivity: CaseSensitivity,
 135     ) -> bool;
 136
 137     fn has_custom_state(
 138         &self,
 139         name: &<Self::Impl as SelectorImpl>::Identifier,
 140     ) -> bool;
 141
 142     /// Returns the mapping from the `exportparts` attribute in the reverse
 143     /// direction, that is, in an outer-tree -> inner-tree direction.
 144     fn imported_part(
 145         &self,
 146         name: &<Self::Impl as SelectorImpl>::Identifier,
 147     ) -> Option<<Self::Impl as SelectorImpl>::Identifier>;
 148
 149     fn is_part(&self, name: &<Self::Impl as SelectorImpl>::Identifier) -> bool;
 150
 151     /// Returns whether this element matches `:empty`.
 152     ///
 153     /// That is, whether it does not contain any child element or any non-zero-length text node.
 154     /// See http://dev.w3.org/csswg/selectors-3/#empty-pseudo
 155     fn is_empty(&self) -> bool;
 156
 157     /// Returns whether this element matches `:root`,
 158     /// i.e. whether it is the root element of a document.
 159     ///
 160     /// Note: this can be false even if `.parent_element()` is `None`
 161     /// if the parent node is a `DocumentFragment`.
 162     fn is_root(&self) -> bool;
 163
 164     /// Returns whether this element should ignore matching nth child
 165     /// selector.
 166     fn ignores_nth_child_selectors(&self) -> bool {
 167         false
 168     }
 169
 170     /// Add hashes unique to this element to the given filter, returning true
 171     /// if any got added.
 172     fn add_element_unique_hashes(&self, filter: &mut BloomFilter) -> bool;
 173 }