Implement zero copy parsing

Author: devongovett

Cargo.lock

@@ -28,7 +28,7 @@ parcel_selectors = { version = "0.24.0", path = "./selectors" }
 itertools = "0.10.1"
 smallvec = { version = "1.7.0", features = ["union"] }
 bitflags = "1.3.2"
-parcel_sourcemap = "2.0.0"
+parcel_sourcemap = "2.0.2"
 data-encoding = "2.3.2"
 lazy_static = "1.4.0"
 clap = { version = "3.0.6", features = ["derive"] }

Cargo.toml

@@ -142,14 +142,14 @@ console.log(new TextDecoder().decode(code));
 
 ```
 $ node bench.js bootstrap-4.css 
-cssnano: 542.956ms
+cssnano: 542.879ms
 159636 bytes
 
-esbuild: 17.411ms
+esbuild: 16.839ms
 160332 bytes
 
-parcel-css: 4.602ms
-143154 bytes
+parcel-css: 4.345ms
+143121 bytes
 
 
 $ node bench.js animate.css

README.md

@@ -14,7 +14,7 @@ serde_bytes = "0.11.5"
 serde_json = "*"
 cssparser = "0.29.1"
 parcel_css = { path = "../" }
-parcel_sourcemap = "2.0.0"
+parcel_sourcemap = "2.0.2"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 jemallocator = { version = "0.3.2", features = ["disable_initial_exec_tls"] }

node/Cargo.toml

@@ -333,7 +333,7 @@ impl<'i> From<parcel_sourcemap::SourceMapError> for CompileError<'i> {
 impl<'i> From<CompileError<'i>> for napi::Error {
   fn from(e: CompileError) -> napi::Error {
     match e {
-      CompileError::SourceMapError(e) => e.into(),
+      CompileError::SourceMapError(e) => napi::Error::from_reason(e.to_string()),
       _ => napi::Error::new(napi::Status::GenericFailure, e.reason())
     }
   }

node/src/lib.rs

@@ -25,7 +25,6 @@ fxhash = "0.2"
 log = "0.4"
 phf = "0.8"
 precomputed-hash = "0.1"
-servo_arc = "0.1"
 smallvec = "1.0"
 
 [build-dependencies]

selectors/Cargo.toml

@@ -7,15 +7,15 @@ use cssparser::ToCss;
 use std::fmt;
 
 #[derive(Clone, Eq, PartialEq)]
-pub struct AttrSelectorWithOptionalNamespace<Impl: SelectorImpl> {
+pub struct AttrSelectorWithOptionalNamespace<'i, Impl: SelectorImpl<'i>> {
     pub namespace: Option<NamespaceConstraint<(Impl::NamespacePrefix, Impl::NamespaceUrl)>>,
     pub local_name: Impl::LocalName,
     pub local_name_lower: Impl::LocalName,
     pub operation: ParsedAttrSelectorOperation<Impl::AttrValue>,
     pub never_matches: bool,
 }
 
-impl<Impl: SelectorImpl> AttrSelectorWithOptionalNamespace<Impl> {
+impl<'i, Impl: SelectorImpl<'i>> AttrSelectorWithOptionalNamespace<'i, Impl> {
     pub fn namespace(&self) -> Option<NamespaceConstraint<&Impl::NamespaceUrl>> {
         self.namespace.as_ref().map(|ns| match ns {
             NamespaceConstraint::Any => NamespaceConstraint::Any,

selectors/attr.rs

@@ -19,7 +19,7 @@
 
 use crate::parser::{Combinator, Component, SelectorImpl};
 use crate::sink::Push;
-use servo_arc::{Arc, HeaderWithLength, ThinArc};
+// use servo_arc::{Arc, HeaderWithLength, ThinArc};
 use smallvec::{self, SmallVec};
 use std::cmp;
 use std::iter;
@@ -36,21 +36,21 @@ use std::slice;
 /// build(), which transforms the contents of the SelectorBuilder into a heap-
 /// allocated Selector and leaves the builder in a drained state.
 #[derive(Debug)]
-pub struct SelectorBuilder<Impl: SelectorImpl> {
+pub struct SelectorBuilder<'i, Impl: SelectorImpl<'i>> {
     /// The entire sequence of simple selectors, from left to right, without combinators.
     ///
     /// We make this large because the result of parsing a selector is fed into a new
     /// Arc-ed allocation, so any spilled vec would be a wasted allocation. Also,
     /// Components are large enough that we don't have much cache locality benefit
     /// from reserving stack space for fewer of them.
-    simple_selectors: SmallVec<[Component<Impl>; 32]>,
+    simple_selectors: SmallVec<[Component<'i, Impl>; 32]>,
     /// The combinators, and the length of the compound selector to their left.
     combinators: SmallVec<[(Combinator, usize); 16]>,
     /// The length of the current compount selector.
     current_len: usize,
 }
 
-impl<Impl: SelectorImpl> Default for SelectorBuilder<Impl> {
+impl<'i, Impl: SelectorImpl<'i>> Default for SelectorBuilder<'i, Impl> {
     #[inline(always)]
     fn default() -> Self {
         SelectorBuilder {
@@ -61,16 +61,16 @@ impl<Impl: SelectorImpl> Default for SelectorBuilder<Impl> {
     }
 }
 
-impl<Impl: SelectorImpl> Push<Component<Impl>> for SelectorBuilder<Impl> {
-    fn push(&mut self, value: Component<Impl>) {
+impl<'i, Impl: SelectorImpl<'i>> Push<Component<'i, Impl>> for SelectorBuilder<'i, Impl> {
+    fn push(&mut self, value: Component<'i, Impl>) {
         self.push_simple_selector(value);
     }
 }
 
-impl<Impl: SelectorImpl> SelectorBuilder<Impl> {
+impl<'i, Impl: SelectorImpl<'i>> SelectorBuilder<'i, Impl> {
     /// Pushes a simple selector onto the current compound selector.
     #[inline(always)]
-    pub fn push_simple_selector(&mut self, ss: Component<Impl>) {
+    pub fn push_simple_selector(&mut self, ss: Component<'i, Impl>) {
         assert!(!ss.is_combinator());
         self.simple_selectors.push(ss);
         self.current_len += 1;
@@ -97,7 +97,7 @@ impl<Impl: SelectorImpl> SelectorBuilder<Impl> {
         parsed_pseudo: bool,
         parsed_slotted: bool,
         parsed_part: bool,
-    ) -> ThinArc<SpecificityAndFlags, Component<Impl>> {
+    ) -> (SpecificityAndFlags, Vec<Component<'i, Impl>>) {
         // Compute the specificity and flags.
         let specificity = specificity(self.simple_selectors.iter());
         let mut flags = SelectorFlags::empty();
@@ -119,16 +119,7 @@ impl<Impl: SelectorImpl> SelectorBuilder<Impl> {
     pub fn build_with_specificity_and_flags(
         &mut self,
         spec: SpecificityAndFlags,
-    ) -> ThinArc<SpecificityAndFlags, Component<Impl>> {
-        // First, compute the total number of Components we'll need to allocate
-        // space for.
-        let full_len = self.simple_selectors.len() + self.combinators.len();
-
-        // Create the header.
-        let header = HeaderWithLength::new(spec, full_len);
-
-        // Create the Arc using an iterator that drains our buffers.
-
+    ) -> (SpecificityAndFlags, Vec<Component<'i, Impl>>) {
         // Use a raw pointer to be able to call set_len despite "borrowing" the slice.
         // This is similar to SmallVec::drain, but we use a slice here because
         // we’re gonna traverse it non-linearly.
@@ -145,26 +136,26 @@ impl<Impl: SelectorImpl> SelectorBuilder<Impl> {
             combinators: self.combinators.drain(..).rev(),
         };
 
-        Arc::into_thin(Arc::from_header_and_iter(header, iter))
+        (spec, iter.collect())
     }
 }
 
-struct SelectorBuilderIter<'a, Impl: SelectorImpl> {
-    current_simple_selectors: slice::Iter<'a, Component<Impl>>,
-    rest_of_simple_selectors: &'a [Component<Impl>],
+struct SelectorBuilderIter<'a, 'i, Impl: SelectorImpl<'i>> {
+    current_simple_selectors: slice::Iter<'a, Component<'i, Impl>>,
+    rest_of_simple_selectors: &'a [Component<'i, Impl>],
     combinators: iter::Rev<smallvec::Drain<'a, [(Combinator, usize); 16]>>,
 }
 
-impl<'a, Impl: SelectorImpl> ExactSizeIterator for SelectorBuilderIter<'a, Impl> {
+impl<'a, 'i, Impl: SelectorImpl<'i>> ExactSizeIterator for SelectorBuilderIter<'a, 'i, Impl> {
     fn len(&self) -> usize {
         self.current_simple_selectors.len() +
             self.rest_of_simple_selectors.len() +
             self.combinators.len()
     }
 }
 
-impl<'a, Impl: SelectorImpl> Iterator for SelectorBuilderIter<'a, Impl> {
-    type Item = Component<Impl>;
+impl<'a, 'i, Impl: SelectorImpl<'i>> Iterator for SelectorBuilderIter<'a, 'i, Impl> {
+    type Item = Component<'i, Impl>;
     #[inline(always)]
     fn next(&mut self) -> Option<Self::Item> {
         if let Some(simple_selector_ref) = self.current_simple_selectors.next() {
@@ -262,22 +253,22 @@ impl From<Specificity> for u32 {
     }
 }
 
-fn specificity<Impl>(iter: slice::Iter<Component<Impl>>) -> u32
+fn specificity<'i, Impl>(iter: slice::Iter<Component<'i, Impl>>) -> u32
 where
-    Impl: SelectorImpl,
+    Impl: SelectorImpl<'i>,
 {
     complex_selector_specificity(iter).into()
 }
 
-fn complex_selector_specificity<Impl>(iter: slice::Iter<Component<Impl>>) -> Specificity
+fn complex_selector_specificity<'i, Impl>(iter: slice::Iter<Component<'i, Impl>>) -> Specificity
 where
-    Impl: SelectorImpl,
+    Impl: SelectorImpl<'i>,
 {
-    fn simple_selector_specificity<Impl>(
-        simple_selector: &Component<Impl>,
+    fn simple_selector_specificity<'i, Impl>(
+        simple_selector: &Component<'i, Impl>,
         specificity: &mut Specificity,
     ) where
-        Impl: SelectorImpl,
+        Impl: SelectorImpl<'i>,
     {
         match *simple_selector {
             Component::Combinator(..) => {

selectors/builder.rs

@@ -94,9 +94,9 @@ impl QuirksMode {
 /// Data associated with the matching process for a element.  This context is
 /// used across many selectors for an element, so it's not appropriate for
 /// transient data that applies to only a single selector.
-pub struct MatchingContext<'a, Impl>
+pub struct MatchingContext<'a, 'i, Impl>
 where
-    Impl: SelectorImpl,
+    Impl: SelectorImpl<'i>,
 {
     /// Input with the matching mode we should use when matching selectors.
     matching_mode: MatchingMode,
@@ -144,9 +144,9 @@ where
     _impl: ::std::marker::PhantomData<Impl>,
 }
 
-impl<'a, Impl> MatchingContext<'a, Impl>
+impl<'a, 'i, Impl> MatchingContext<'a, 'i, Impl>
 where
-    Impl: SelectorImpl,
+    Impl: SelectorImpl<'i>,
 {
     /// Constructs a new `MatchingContext`.
     pub fn new(
@@ -272,7 +272,7 @@ where
     #[inline]
     pub fn with_shadow_host<F, E, R>(&mut self, host: Option<E>, f: F) -> R
     where
-        E: Element,
+        E: Element<'i>,
         F: FnOnce(&mut Self) -> R,
     {
         let original_host = self.current_host.take();

selectors/context.rs

@@ -16,7 +16,6 @@ extern crate fxhash;
 extern crate log;
 extern crate phf;
 extern crate precomputed_hash;
-extern crate servo_arc;
 extern crate smallvec;
 
 pub mod attr;