perf: Avoid using RefCell for nth index caches

Author: Stranger6667

css-inline/src/html/document.rs

@@ -9,7 +9,7 @@ use super::{
 use crate::{html::DocumentStyleMap, InlineError};
 use html5ever::local_name;
 use selectors::NthIndexCache;
-use std::{cell::RefCell, fmt, fmt::Formatter, io::Write, iter::successors};
+use std::{fmt, fmt::Formatter, io::Write, iter::successors};
 
 /// HTML document representation.
 ///
@@ -39,7 +39,7 @@ use std::{cell::RefCell, fmt, fmt::Formatter, io::Write, iter::successors};
 pub(crate) struct Document {
     pub(crate) nodes: Vec<Node>,
     /// Ids of Element nodes & caches for their nth index selectors.
-    pub(crate) elements: Vec<(NodeId, RefCell<NthIndexCache>)>,
+    pub(crate) elements: Vec<NodeId>,
     /// Ids of `style` nodes.
     styles: Vec<NodeId>,
     /// Ids of `link` nodes, specifically those with the `rel` attribute value set as `stylesheet`.
@@ -122,7 +122,7 @@ impl Document {
 
     #[inline]
     pub(super) fn push_element_id(&mut self, node: NodeId) {
-        self.elements.push((node, RefCell::default()));
+        self.elements.push(node);
     }
 
     /// Detach a node from its siblings and its parent.
@@ -279,11 +279,18 @@ impl Document {
     }
 
     /// Filter this node iterator to elements matching the given selectors.
-    pub(crate) fn select<'a, 'b>(
+    pub(crate) fn select<'a, 'b, 'c>(
         &'a self,
         selectors: &'b str,
-    ) -> Result<Select<'a>, ParseError<'b>> {
-        select(self, selectors)
+        caches: &'c mut [NthIndexCache],
+    ) -> Result<Select<'a, 'c>, ParseError<'b>> {
+        select(self, selectors, caches)
+    }
+
+    pub(crate) fn build_caches(&self) -> Vec<NthIndexCache> {
+        (0..self.elements.len())
+            .map(|_| NthIndexCache::default())
+            .collect()
     }
 }
 

css-inline/src/html/iter.rs

@@ -6,38 +6,39 @@ use super::{
     Specificity,
 };
 use selectors::NthIndexCache;
-use std::cell::RefCell;
+use std::iter::Zip;
 
 /// Compile selectors from a string and create an element iterator that yields elements matching these selectors.
 #[inline]
-pub(crate) fn select<'a, 'b>(
+pub(crate) fn select<'a, 'b, 'c>(
     document: &'a Document,
     selectors: &'b str,
-) -> Result<Select<'a>, ParseError<'b>> {
+    caches: &'c mut [NthIndexCache],
+) -> Result<Select<'a, 'c>, ParseError<'b>> {
     Selectors::compile(selectors).map(|selectors| Select {
         document,
-        iter: document.elements.iter(),
+        iter: document.elements.iter().zip(caches.iter_mut()),
         selectors,
     })
 }
 
 /// An element iterator adaptor that yields elements matching given selectors.
-pub(crate) struct Select<'a> {
+pub(crate) struct Select<'a, 'c> {
     document: &'a Document,
-    iter: std::slice::Iter<'a, (NodeId, RefCell<NthIndexCache>)>,
+    iter: Zip<std::slice::Iter<'a, NodeId>, std::slice::IterMut<'c, NthIndexCache>>,
     /// The selectors to be matched.
     selectors: Selectors,
 }
 
-impl<'a> Select<'a> {
+impl<'a, 'c> Select<'a, 'c> {
     /// Specificity of the first selector in the list of selectors.
     #[inline]
     pub(crate) fn specificity(&self) -> Specificity {
         Specificity::new(self.selectors.0[0].specificity())
     }
 }
 
-impl<'a> Iterator for Select<'a> {
+impl<'a, 'c> Iterator for Select<'a, 'c> {
     type Item = Element<'a>;
 
     #[inline]
@@ -47,9 +48,8 @@ impl<'a> Iterator for Select<'a> {
                 unreachable!("Element ids always point to element nodes")
             };
             let element = Element::new(self.document, *element_id, element);
-            let mut cache = cache.borrow_mut();
             for selector in self.selectors.iter() {
-                if element.matches(selector, &mut cache) {
+                if element.matches(selector, cache) {
                     return Some(element);
                 }
             }

css-inline/src/lib.rs

@@ -295,11 +295,12 @@ impl<'a> CSSInliner<'a> {
         {
             rule_list.push(rule);
         }
+        let mut caches = document.build_caches();
         for (selectors, (start, end)) in &rule_list {
             // Only CSS Syntax Level 3 is supported, therefore it is OK to split by `,`
             // With `is` or `where` selectors (Level 4) this split should be done on the parser level
             for selector in selectors.split(',') {
-                if let Ok(matching_elements) = document.select(selector) {
+                if let Ok(matching_elements) = document.select(selector, &mut caches) {
                     let specificity = matching_elements.specificity();
                     for matching_element in matching_elements {
                         let element_styles =