Merge branch 'master' of github.com:devongovett/rust-css-transformer into logical

# Conflicts:
#	src/declaration.rs
#	src/properties/border_radius.rs
#	src/stylesheet.rs

Author: devongovett

README.md

@@ -90,8 +90,8 @@ cssnano: 542.956ms
 esbuild: 17.411ms
 160332 bytes
 
-parcel-css: 4.74ms
-143985 bytes
+parcel-css: 4.602ms
+143154 bytes
 
 
 $ node bench.js animate.css
@@ -101,7 +101,7 @@ cssnano: 283.105ms
 esbuild: 11.858ms
 72183 bytes
 
-parcel-css: 1.989ms
+parcel-css: 1.973ms
 23666 bytes
 
 
@@ -112,6 +112,6 @@ cssnano: 2.198s
 esbuild: 107.668ms
 1961642 bytes
 
-parcel-css: 45.701ms
-1799209 bytes
+parcel-css: 43.368ms
+1824130 bytes
 ```

src/declaration.rs

@@ -28,21 +28,27 @@ use crate::logical::LogicalProperties;
 
 #[derive(Debug, PartialEq)]
 pub struct DeclarationBlock {
-  pub declarations: Vec<Declaration>
+  pub important_declarations: Vec<Property>,
+  pub declarations: Vec<Property>
 }
 
 impl DeclarationBlock {
   pub fn parse<'i, 't>(input: &mut Parser<'i, 't>, options: &ParserOptions) -> Result<Self, ParseError<'i, ParserError<'i>>> {
-    let mut parser = DeclarationListParser::new(input, PropertyDeclarationParser { options });
-    let mut declarations = vec![];
-    while let Some(decl) = parser.next() {
-      match decl {
-        Ok(decl) => declarations.push(decl),
-        Err((err, _)) => return Err(err)
+    let mut important_declarations = DeclarationList::new();
+    let mut declarations = DeclarationList::new();
+    let mut parser = DeclarationListParser::new(input, PropertyDeclarationParser {
+      important_declarations: &mut important_declarations,
+      declarations: &mut declarations,
+      options
+    });
+    while let Some(res) = parser.next() {
+      if let Err((err, _)) = res {
+        return Err(err)
       }
     }
 
     Ok(DeclarationBlock {
+      important_declarations,
       declarations
     })
   }
@@ -53,14 +59,26 @@ impl ToCss for DeclarationBlock {
     dest.whitespace()?;
     dest.write_char('{')?;
     dest.indent();
-    let len = self.declarations.len();
-    for (i, decl) in self.declarations.iter().enumerate() {
-      dest.newline()?;
-      decl.to_css(dest)?;
-      if i != len - 1 || !dest.minify {
-        dest.write_char(';')?;
-      }
+
+    let mut i = 0;
+    let len = self.declarations.len() + self.important_declarations.len();
+
+    macro_rules! write {
+      ($decls: expr, $important: literal) => {
+        for decl in &$decls {
+          dest.newline()?;
+          decl.to_css(dest, $important)?;
+          if i != len - 1 || !dest.minify {
+            dest.write_char(';')?;
+          }
+          i += 1;
+        }
+      };
     }
+
+    write!(self.declarations, false);
+    write!(self.important_declarations, true);
+    
     dest.dedent();
     dest.newline()?;
     dest.write_char('}')
@@ -74,94 +92,76 @@ impl DeclarationBlock {
     important_handler: &mut DeclarationHandler,
     logical_properties: &mut LogicalProperties
   ) {
-    let mut decls: Vec<Declaration> = vec![];
-    for decl in self.declarations.iter() {
-      let handled = 
-        (decl.important && important_handler.handle_property(decl, logical_properties)) ||
-        (!decl.important && handler.handle_property(decl, logical_properties));
-
-      if !handled {
-        decls.push(decl.clone());
-      }
+    macro_rules! handle {
+      ($decls: expr, $handler: expr) => {
+        for decl in $decls.iter() {
+          let handled = $handler.handle_property(decl, logical_properties);
+    
+          if !handled {
+            $handler.decls.push(decl.clone());
+          }
+        }
+      };
     }
 
-    decls.extend(handler.finalize(logical_properties));
-    decls.extend(important_handler.finalize(logical_properties));
-    self.declarations = decls;
+    handle!(self.important_declarations, important_handler);
+    handle!(self.declarations, handler);
+
+    handler.finalize(logical_properties);
+    important_handler.finalize(logical_properties);
+    self.important_declarations = std::mem::take(&mut important_handler.decls);
+    self.declarations = std::mem::take(&mut handler.decls);
   }
 }
 
 struct PropertyDeclarationParser<'a> {
+  important_declarations: &'a mut Vec<Property>,
+  declarations: &'a mut Vec<Property>,
   options: &'a ParserOptions
 }
 
 /// Parse a declaration within {} block: `color: blue`
 impl<'a, 'i> cssparser::DeclarationParser<'i> for PropertyDeclarationParser<'a> {
-  type Declaration = Declaration;
+  type Declaration = ();
   type Error = ParserError<'i>;
 
   fn parse_value<'t>(
     &mut self,
     name: CowRcStr<'i>,
     input: &mut cssparser::Parser<'i, 't>,
   ) -> Result<Self::Declaration, cssparser::ParseError<'i, Self::Error>> {
-    Declaration::parse(name, input, self.options)
+    parse_declaration(name, input, &mut self.declarations, &mut self.important_declarations, &self.options)
   }
 }
 
 /// Default methods reject all at rules.
 impl<'a, 'i> AtRuleParser<'i> for PropertyDeclarationParser<'a> {
   type Prelude = ();
-  type AtRule = Declaration;
+  type AtRule = ();
   type Error = ParserError<'i>;
 }
 
-#[derive(Debug, Clone, PartialEq)]
-pub struct Declaration {
-  pub property: Property,
-  pub important: bool
-}
-
-impl Declaration {
-  pub fn parse<'i, 't>(name: CowRcStr<'i>, input: &mut Parser<'i, 't>, options: &ParserOptions) -> Result<Self, ParseError<'i, ParserError<'i>>> {
-    let property = input.parse_until_before(Delimiter::Bang, |input| Property::parse(name, input, options))?;
-    let important = input.try_parse(|input| {
-      input.expect_delim('!')?;
-      input.expect_ident_matching("important")
-    }).is_ok();
-    Ok(Declaration { property, important })
-  }
-}
-
-impl ToCss for Declaration {
-  fn to_css<W>(&self, dest: &mut Printer<W>) -> Result<(), PrinterError> where W: std::fmt::Write {
-    self.property.to_css(dest, self.important)
+pub(crate) fn parse_declaration<'i, 't>(
+  name: CowRcStr<'i>,
+  input: &mut cssparser::Parser<'i, 't>,
+  declarations: &mut DeclarationList,
+  important_declarations: &mut DeclarationList,
+  options: &ParserOptions
+) -> Result<(), cssparser::ParseError<'i, ParserError<'i>>> {
+  let property = input.parse_until_before(Delimiter::Bang, |input| Property::parse(name, input, options))?;
+  let important = input.try_parse(|input| {
+    input.expect_delim('!')?;
+    input.expect_ident_matching("important")
+  }).is_ok();
+  if important {
+    important_declarations.push(property);
+  } else {
+    declarations.push(property);
   }
+  Ok(())
 }
 
-#[derive(Default)]
-pub(crate) struct DeclarationList {
-  important: bool,
-  pub declarations: Vec<Declaration>
-}
-
-impl DeclarationList {
-  pub fn new(important: bool) -> DeclarationList {
-    DeclarationList {
-      important,
-      declarations: Vec::new()
-    }
-  }
-
-  pub fn push(&mut self, property: Property) {
-    self.declarations.push(Declaration { property, important: self.important })
-  }
-
-  pub fn extend(&mut self, properties: &mut Vec<Property>) {
-    let important = self.important;
-    self.declarations.extend(properties.drain(..).map(|property| Declaration { property, important }))
-  }
-}
+pub(crate) type DeclarationList = Vec<Property>;
 
 pub(crate) struct DeclarationHandler {
   background: BackgroundHandler,
@@ -189,7 +189,7 @@ pub(crate) struct DeclarationHandler {
 }
 
 impl DeclarationHandler {
-  pub fn new(important: bool, targets: Option<Browsers>) -> Self {
+  pub fn new(targets: Option<Browsers>) -> Self {
     DeclarationHandler {
       background: BackgroundHandler::new(targets),
       border: BorderHandler::new(targets),
@@ -212,12 +212,11 @@ impl DeclarationHandler {
       overflow: OverflowHandler::new(targets),
       transform: TransformHandler::new(targets),
       prefix: PrefixHandler::new(targets),
-      decls: DeclarationList::new(important)
+      decls: DeclarationList::new()
     }
   }
 
-  pub fn handle_property(&mut self, decl: &Declaration, logical_properties: &mut LogicalProperties) -> bool {
-    let property = &decl.property;
+  pub fn handle_property(&mut self, property: &Property, logical_properties: &mut LogicalProperties) -> bool {
     self.background.handle_property(property, &mut self.decls, logical_properties) ||
     self.border.handle_property(property, &mut self.decls, logical_properties) ||
     self.outline.handle_property(property, &mut self.decls, logical_properties) ||
@@ -241,7 +240,7 @@ impl DeclarationHandler {
     self.prefix.handle_property(property, &mut self.decls, logical_properties)
   }
 
-  pub fn finalize(&mut self, logical_properties: &mut LogicalProperties) -> Vec<Declaration> {
+  pub fn finalize(&mut self, logical_properties: &mut LogicalProperties) {
     self.background.finalize(&mut self.decls, logical_properties);
     self.border.finalize(&mut self.decls, logical_properties);
     self.outline.finalize(&mut self.decls, logical_properties);
@@ -263,6 +262,5 @@ impl DeclarationHandler {
     self.overflow.finalize(&mut self.decls, logical_properties);
     self.transform.finalize(&mut self.decls, logical_properties);
     self.prefix.finalize(&mut self.decls, logical_properties);
-    std::mem::take(&mut self.decls.declarations)
   }
 }

src/logical.rs

@@ -2,7 +2,7 @@ use cssparser::SourceLocation;
 use crate::rules::{CssRule, CssRuleList, style::StyleRule};
 use parcel_selectors::SelectorList;
 use crate::selector::{SelectorIdent, SelectorString};
-use crate::declaration::{Declaration, DeclarationBlock};
+use crate::declaration::DeclarationBlock;
 use crate::css_modules::hash;
 use crate::vendor_prefix::VendorPrefix;
 use crate::compat::Feature;
@@ -69,21 +69,16 @@ impl LogicalProperties {
           rules: CssRuleList(vec![]),
           vendor_prefix: VendorPrefix::empty(),
           declarations: DeclarationBlock {
+            important_declarations: vec![],
             declarations: vec![
-              Declaration {
-                property: Property::Custom(CustomProperty {
-                  name: "--ltr".into(),
-                  value: $ltr.into()
-                }),
-                important: false
-              },
-              Declaration {
-                property: Property::Custom(CustomProperty {
-                  name: "--rtl".into(),
-                  value: $rtl.into()
-                }),
-                important: false
-              }
+              Property::Custom(CustomProperty {
+                name: "--ltr".into(),
+                value: $ltr.into()
+              }),
+              Property::Custom(CustomProperty {
+                name: "--rtl".into(),
+                value: $rtl.into()
+              })
             ]
           },
           loc: SourceLocation {