perf: Avoid some String allocations during parsing

Author: Stranger6667

src/lib.rs

@@ -136,13 +136,16 @@ pub use error::InlineError;
 use std::collections::HashMap;
 
 #[derive(Debug)]
-struct Rule {
+struct Rule<'i> {
     selectors: Selectors,
-    declarations: Vec<parser::Declaration>,
+    declarations: Vec<parser::Declaration<'i>>,
 }
 
-impl Rule {
-    pub fn new(selectors: &str, declarations: Vec<parser::Declaration>) -> Result<Rule, ()> {
+impl<'i> Rule<'i> {
+    pub fn new(
+        selectors: &str,
+        declarations: Vec<parser::Declaration<'i>>,
+    ) -> Result<Rule<'i>, ()> {
         Ok(Rule {
             selectors: Selectors::compile(selectors)?,
             declarations,
@@ -213,7 +216,7 @@ impl CSSInliner {
                     let mut parser = parser::CSSParser::new(&mut parse_input);
                     for parsed in parser.parse() {
                         if let Ok((selector, declarations)) = parsed {
-                            let rule = Rule::new(&selector, declarations).map_err(|_| {
+                            let rule = Rule::new(selector, declarations).map_err(|_| {
                                 error::InlineError::ParseError("Unknown error".to_string())
                             })?;
                             let matching_elements = document
@@ -227,7 +230,7 @@ impl CSSInliner {
                                 } else {
                                     rule.declarations
                                         .iter()
-                                        .map(|&(ref key, ref value)| format!("{}:{};", key, value))
+                                        .map(|&(ref key, value)| format!("{}:{};", key, value))
                                         .collect()
                                 };
                                 attributes.insert("style", style);
@@ -272,18 +275,18 @@ fn merge_styles(
         cssparser::DeclarationListParser::new(&mut parser, parser::CSSDeclarationListParser);
     // Merge existing with the new ones
     // We know that at least one rule already exists, so we add 1
-    let mut styles: HashMap<String, String> =
+    let mut styles: HashMap<String, &str> =
         HashMap::with_capacity(new_styles.len().saturating_add(1));
-    for declaration in declarations.into_iter() {
+    for declaration in declarations {
         let (property, value) = declaration?;
-        styles.insert(property, value);
+        styles.insert(property.to_string(), value);
     }
-    for (property, value) in new_styles.iter() {
-        styles.insert(property.to_string(), value.to_string());
+    for (property, value) in new_styles {
+        styles.insert(property.to_string(), value);
     }
     // Create a new declarations list
     Ok(styles
-        .iter()
+        .into_iter()
         .map(|(key, value)| format!("{}:{};", key, value))
         .collect::<String>())
 }

src/parser.rs

@@ -1,21 +1,21 @@
 pub struct CSSRuleListParser;
 pub(crate) struct CSSDeclarationListParser;
 
-pub type Declaration = (String, String);
-pub type QualifiedRule = (String, Vec<Declaration>);
+pub type Declaration<'i> = (cssparser::CowRcStr<'i>, &'i str);
+pub type QualifiedRule<'i> = (&'i str, Vec<Declaration<'i>>);
 
-fn exhaust(input: &mut cssparser::Parser) -> String {
+fn exhaust<'i>(input: &mut cssparser::Parser<'i, '_>) -> &'i str {
     let start = input.position();
     while input.next().is_ok() {}
-    input.slice_from(start).to_string()
+    input.slice_from(start)
 }
 
 /// Parser for qualified rules - a prelude + a simple {} block.
 ///
 /// Usually these rules are a selector + list of declarations: `p { color: blue; font-size: 2px }`
 impl<'i> cssparser::QualifiedRuleParser<'i> for CSSRuleListParser {
-    type Prelude = String;
-    type QualifiedRule = QualifiedRule;
+    type Prelude = &'i str;
+    type QualifiedRule = QualifiedRule<'i>;
     type Error = ();
 
     fn parse_prelude<'t>(
@@ -48,31 +48,31 @@ impl<'i> cssparser::QualifiedRuleParser<'i> for CSSRuleListParser {
 
 /// Parse a declaration within {} block: `color: blue`
 impl<'i> cssparser::DeclarationParser<'i> for CSSDeclarationListParser {
-    type Declaration = Declaration;
+    type Declaration = Declaration<'i>;
     type Error = ();
 
     fn parse_value<'t>(
         &mut self,
         name: cssparser::CowRcStr<'i>,
         input: &mut cssparser::Parser<'i, 't>,
     ) -> Result<Self::Declaration, cssparser::ParseError<'i, Self::Error>> {
-        Ok((name.to_string(), exhaust(input)))
+        Ok((name, exhaust(input)))
     }
 }
 
-impl cssparser::AtRuleParser<'_> for CSSRuleListParser {
+impl<'i> cssparser::AtRuleParser<'i> for CSSRuleListParser {
     type PreludeNoBlock = String;
     type PreludeBlock = String;
-    type AtRule = QualifiedRule;
+    type AtRule = QualifiedRule<'i>;
     type Error = ();
 }
 
 /// Parsing for at-rules, e.g: `@charset "utf-8";`
 /// Since they are can not be inlined we use the default implementation, that rejects all at-rules.
-impl cssparser::AtRuleParser<'_> for CSSDeclarationListParser {
+impl<'i> cssparser::AtRuleParser<'i> for CSSDeclarationListParser {
     type PreludeNoBlock = String;
     type PreludeBlock = String;
-    type AtRule = Declaration;
+    type AtRule = Declaration<'i>;
     type Error = ();
 }
 
@@ -81,12 +81,14 @@ pub struct CSSParser<'i, 't> {
 }
 
 impl<'i: 't, 't> CSSParser<'i, 't> {
+    #[inline]
     pub fn new(css: &'t mut cssparser::ParserInput<'i>) -> CSSParser<'i, 't> {
         CSSParser {
             input: cssparser::Parser::new(css),
         }
     }
 
+    #[inline]
     pub fn parse<'a>(&'a mut self) -> cssparser::RuleListParser<'i, 't, 'a, CSSRuleListParser> {
         cssparser::RuleListParser::new_for_stylesheet(&mut self.input, CSSRuleListParser)
     }