Handle unused rules with nesting

Author: devongovett

src/lib.rs

@@ -8308,15 +8308,15 @@ mod tests {
           }
 
           &* {
-            color: red;
+            color: green;
           }
 
           &|x {
             color: red;
           }
 
           &*|x {
-            color: red;
+            color: green;
           }
 
           &toto|x {
@@ -8333,15 +8333,15 @@ mod tests {
         }
 
         *.foo {
-          color: red;
+          color: green;
         }
 
         |x.foo {
           color: red;
         }
 
         *|x.foo {
-          color: red;
+          color: green;
         }
 
         toto|x.foo {
@@ -9057,5 +9057,52 @@ mod tests {
     });
     let res = stylesheet.to_css(PrinterOptions::default()).unwrap();
     assert_eq!(res.code, expected);
+
+    let source = r#"
+      .foo {
+        color: red;
+
+        &.bar {
+          color: purple;
+        }
+
+        @nest &.bar {
+          color: orange;
+        }
+
+        @nest :not(&) {
+          color: green;
+        }
+
+        @media (orientation: portrait) {
+          color: brown;
+        }
+      }
+
+      .x {
+        color: purple;
+        
+        &.y {
+          color: green;
+        }
+      }
+    "#;
+
+    let expected = indoc!{r#"
+      :not(.foo) {
+        color: green;
+      }
+    "#};
+
+    let mut stylesheet = StyleSheet::parse("test.css".into(), source, ParserOptions { nesting: true, ..ParserOptions::default() }).unwrap();
+    stylesheet.minify(MinifyOptions {
+      unused_symbols: vec!["foo", "x"].iter().map(|s| String::from(*s)).collect(),
+      ..MinifyOptions::default()
+    });
+    let res = stylesheet.to_css(PrinterOptions {
+      targets: Some(Browsers { chrome: Some(95 << 16), ..Browsers::default() }),
+      ..PrinterOptions::default()
+    }).unwrap();
+    assert_eq!(res.code, expected);
   }
 }

src/rules/document.rs

@@ -12,7 +12,7 @@ pub struct MozDocumentRule {
 
 impl MozDocumentRule {
   pub(crate) fn minify(&mut self, context: &mut MinifyContext) {
-    self.rules.minify(context)
+    self.rules.minify(context, false)
   }
 }
 

src/rules/media.rs

@@ -14,8 +14,8 @@ pub struct MediaRule {
 }
 
 impl MediaRule {
-  pub(crate) fn minify(&mut self, context: &mut MinifyContext) {
-    self.rules.minify(context)
+  pub(crate) fn minify(&mut self, context: &mut MinifyContext, parent_is_unused: bool) {
+    self.rules.minify(context, parent_is_unused);
   }
 }
 

src/rules/mod.rs

@@ -94,7 +94,7 @@ pub(crate) struct MinifyContext<'a> {
 }
 
 impl CssRuleList {
-  pub(crate) fn minify(&mut self, context: &mut MinifyContext) {
+  pub(crate) fn minify(&mut self, context: &mut MinifyContext, parent_is_unused: bool) {
     let mut keyframe_rules = HashMap::new();
     let mut rules = Vec::new();
     for mut rule in self.0.drain(..) {
@@ -130,16 +130,24 @@ impl CssRuleList {
           set_prefix!(keyframes);
           keyframe_rules.insert(keyframes.name.clone(), rules.len());
         },
-        CssRule::Media(media) => media.minify(context),
-        CssRule::Supports(supports) => supports.minify(context),
+        CssRule::Media(media) => {
+          media.minify(context, parent_is_unused);
+          if media.rules.0.is_empty() {
+            continue
+          }
+        },
+        CssRule::Supports(supports) => {
+          supports.minify(context, parent_is_unused);
+          if supports.rules.0.is_empty() {
+            continue
+          }
+        },
         CssRule::MozDocument(document) => document.minify(context),
         CssRule::Style(style) => {
-          if is_unused(&mut style.selectors.0.iter(), &context.unused_symbols) {
+          if parent_is_unused || style.minify(context, parent_is_unused) {
             continue
           }
 
-          style.minify(context);
-
           if let Some(targets) = context.targets {
             style.vendor_prefix = get_prefix(&style.selectors);
             if style.vendor_prefix.contains(VendorPrefix::None) {
@@ -183,7 +191,11 @@ impl CssRuleList {
             continue
           }
         }
-        CssRule::Nesting(nesting) => nesting.minify(context),
+        CssRule::Nesting(nesting) => {
+          if nesting.minify(context, parent_is_unused) {
+            continue
+          }
+        }
         _ => {}
       }
 

src/rules/nesting.rs

@@ -12,8 +12,8 @@ pub struct NestingRule {
 }
 
 impl NestingRule {
-  pub(crate) fn minify(&mut self, context: &mut MinifyContext) {
-    self.style.minify(context)
+  pub(crate) fn minify(&mut self, context: &mut MinifyContext, parent_is_unused: bool) -> bool {
+    self.style.minify(context, parent_is_unused)
   }
 }
 

src/rules/style.rs

@@ -6,7 +6,7 @@ use crate::printer::Printer;
 use crate::declaration::DeclarationBlock;
 use crate::vendor_prefix::VendorPrefix;
 use crate::targets::Browsers;
-use crate::rules::{CssRuleList, CssRule, ToCssWithContext, StyleContext};
+use crate::rules::{CssRuleList, ToCssWithContext, StyleContext};
 use crate::compat::Feature;
 use crate::error::PrinterError;
 use super::MinifyContext;
@@ -21,17 +21,30 @@ pub struct StyleRule {
 }
 
 impl StyleRule {
-  pub(crate) fn minify(&mut self, context: &mut MinifyContext) {
-    self.declarations.minify(context.handler, context.important_handler, context.logical_properties);
-
+  pub(crate) fn minify(&mut self, context: &mut MinifyContext, parent_is_unused: bool) -> bool {
+    let mut unused = false;
     if !context.unused_symbols.is_empty() {
-      self.rules.0.retain(|rule| {
-        match rule {
-          CssRule::Style(style) => !is_unused(&mut style.selectors.0.iter(), &context.unused_symbols),
-          _ => true
+      if is_unused(&mut self.selectors.0.iter(), &context.unused_symbols, parent_is_unused) {
+        if self.rules.0.is_empty() {
+          return true
         }
-      });
+
+        self.declarations.declarations.clear();
+        self.declarations.important_declarations.clear();
+        unused = true;
+      }
+    }
+
+    self.declarations.minify(context.handler, context.important_handler, context.logical_properties);
+
+    if !self.rules.0.is_empty() {
+      self.rules.minify(context, unused);
+      if unused && self.rules.0.is_empty() {
+        return true
+      }
     }
+
+    false
   }
 
   pub fn is_compatible(&self, targets: Option<Browsers>) -> bool {

src/rules/supports.rs

@@ -13,8 +13,8 @@ pub struct SupportsRule {
 }
 
 impl SupportsRule {
-  pub(crate) fn minify(&mut self, context: &mut MinifyContext) {
-    self.rules.minify(context)
+  pub(crate) fn minify(&mut self, context: &mut MinifyContext, parent_is_unused: bool) {
+    self.rules.minify(context, parent_is_unused)
   }
 }
 

src/selector.rs

@@ -1212,11 +1212,11 @@ pub fn get_necessary_prefixes(selectors: &SelectorList<Selectors>, targets: Brow
 
 /// Determines whether a selector list contains only unused selectors.
 /// A selector is considered unused if it contains a class or id component that exists in the set of unsed symbols.
-pub fn is_unused(selectors: &mut std::slice::Iter<Selector<Selectors>>, unused_symbols: &HashSet<String>) -> bool {
+pub fn is_unused(selectors: &mut std::slice::Iter<Selector<Selectors>>, unused_symbols: &HashSet<String>, parent_is_unused: bool) -> bool {
   if unused_symbols.is_empty() {
     return false
   }
-  
+
   selectors.all(|selector| {
     for component in selector.iter_raw_match_order() {
       match component {
@@ -1226,10 +1226,15 @@ pub fn is_unused(selectors: &mut std::slice::Iter<Selector<Selectors>>, unused_s
           }
         }
         Component::Is(is) | Component::Where(is) => {
-          if is_unused(&mut is.iter(), unused_symbols) {
+          if is_unused(&mut is.iter(), unused_symbols, parent_is_unused) {
             return true
           }
         }
+        Component::Nesting => {
+          if parent_is_unused {
+            return true
+          }
+        },
         _ => {}
       }
     }

src/stylesheet.rs

@@ -77,7 +77,7 @@ impl StyleSheet {
       important_handler: &mut important_handler,
       logical_properties: &mut logical_properties,
       unused_symbols: &options.unused_symbols
-    });
+    }, false);
     logical_properties.to_rules(&mut self.rules);
   }