Detect @supports features from value, and apply exclusions during printing

Author: devongovett

selectors/parser.rs

@@ -3394,7 +3394,7 @@ pub mod tests {
     }
   }
 
-  fn parse<'i>(input: &'i str) -> Result<SelectorList<DummySelectorImpl>, SelectorParseError<'i>> {
+  fn parse<'i>(input: &'i str) -> Result<SelectorList<'i, DummySelectorImpl>, SelectorParseError<'i>> {
     parse_ns(input, &DummyParser::default())
   }
 

src/lib.rs

@@ -29404,6 +29404,69 @@ mod tests {
       },
     );
 
+    prefix_test(
+      r#"
+      @supports (color: lab(40% 56.6 39)) {
+        .foo {
+          color: lab(40% 56.6 39);
+        }
+      }
+      "#,
+      indoc! {r#"
+      @supports (color: lab(40% 56.6 39)) {
+        .foo {
+          color: lab(40% 56.6 39);
+        }
+      }
+      "#},
+      Browsers {
+        chrome: Some(4 << 16),
+        ..Browsers::default()
+      },
+    );
+
+    prefix_test(
+      r#"
+      @supports (background-color: lab(40% 56.6 39)) {
+        .foo {
+          background-color: lab(40% 56.6 39);
+        }
+      }
+      "#,
+      indoc! {r#"
+      @supports (background-color: lab(40% 56.6 39)) {
+        .foo {
+          background-color: lab(40% 56.6 39);
+        }
+      }
+      "#},
+      Browsers {
+        chrome: Some(4 << 16),
+        ..Browsers::default()
+      },
+    );
+
+    prefix_test(
+      r#"
+      @supports (color: light-dark(#f00, #00f)) {
+        .foo {
+          color: light-dark(#ff0, #0ff);
+        }
+      }
+      "#,
+      indoc! {r#"
+      @supports (color: light-dark(#f00, #00f)) {
+        .foo {
+          color: light-dark(#ff0, #0ff);
+        }
+      }
+      "#},
+      Browsers {
+        chrome: Some(4 << 16),
+        ..Browsers::default()
+      },
+    );
+
     // NOTE: fallback for lab is not necessary
     prefix_test(
       r#"

src/media_query.rs

@@ -754,12 +754,12 @@ where
 {
   let mut iter = conditions.iter();
   let first = iter.next().unwrap();
-  to_css_with_parens_if_needed(first, dest, first.needs_parens(Some(operator), &dest.targets))?;
+  to_css_with_parens_if_needed(first, dest, first.needs_parens(Some(operator), &dest.targets.current))?;
   for item in iter {
     dest.write_char(' ')?;
     operator.to_css(dest)?;
     dest.write_char(' ')?;
-    to_css_with_parens_if_needed(item, dest, item.needs_parens(Some(operator), &dest.targets))?;
+    to_css_with_parens_if_needed(item, dest, item.needs_parens(Some(operator), &dest.targets.current))?;
   }
 
   Ok(())
@@ -787,7 +787,7 @@ impl<'i> ToCss for MediaCondition<'i> {
           negated.to_css(dest)
         } else {
           dest.write_str("not ")?;
-          to_css_with_parens_if_needed(&**c, dest, c.needs_parens(None, &dest.targets))
+          to_css_with_parens_if_needed(&**c, dest, c.needs_parens(None, &dest.targets.current))
         }
       }
       MediaCondition::Operation {
@@ -1087,7 +1087,7 @@ impl<'i, FeatureId: FeatureToCss> ToCss for QueryFeature<'i, FeatureId> {
       }
       QueryFeature::Range { name, operator, value } => {
         // If range syntax is unsupported, use min/max prefix if possible.
-        if should_compile!(dest.targets, MediaRangeSyntax) {
+        if should_compile!(dest.targets.current, MediaRangeSyntax) {
           return write_min_max(operator, name, value, dest, false);
         }
 
@@ -1103,7 +1103,7 @@ impl<'i, FeatureId: FeatureToCss> ToCss for QueryFeature<'i, FeatureId> {
         end,
         end_operator,
       } => {
-        if should_compile!(dest.targets, MediaIntervalSyntax) {
+        if should_compile!(dest.targets.current, MediaIntervalSyntax) {
           write_min_max(&start_operator.opposite(), name, start, dest, true)?;
           dest.write_str(" and ")?;
           return write_min_max(end_operator, name, end, dest, true);

src/printer.rs

@@ -5,7 +5,7 @@ use crate::dependencies::{Dependency, DependencyOptions};
 use crate::error::{Error, ErrorLocation, PrinterError, PrinterErrorKind};
 use crate::rules::{Location, StyleContext};
 use crate::selector::SelectorList;
-use crate::targets::Targets;
+use crate::targets::{Targets, TargetsWithSupportsScope};
 use crate::vendor_prefix::VendorPrefix;
 use cssparser::{serialize_identifier, serialize_name};
 #[cfg(feature = "sourcemap")]
@@ -77,7 +77,7 @@ pub struct Printer<'a, 'b, 'c, W> {
   line: u32,
   col: u32,
   pub(crate) minify: bool,
-  pub(crate) targets: Targets,
+  pub(crate) targets: TargetsWithSupportsScope,
   /// Vendor prefix override. When non-empty, it overrides
   /// the vendor prefix of whatever is being printed.
   pub(crate) vendor_prefix: VendorPrefix,
@@ -108,7 +108,7 @@ impl<'a, 'b, 'c, W: std::fmt::Write + Sized> Printer<'a, 'b, 'c, W> {
       line: 0,
       col: 0,
       minify: options.minify,
-      targets: options.targets,
+      targets: TargetsWithSupportsScope::new(options.targets),
       vendor_prefix: VendorPrefix::empty(),
       in_calc: false,
       css_module: None,

src/properties/custom.rs

@@ -7,7 +7,7 @@ use crate::printer::Printer;
 use crate::properties::PropertyId;
 use crate::rules::supports::SupportsCondition;
 use crate::stylesheet::ParserOptions;
-use crate::targets::{should_compile, Targets};
+use crate::targets::{should_compile, Features, Targets};
 use crate::traits::{Parse, ParseWithOptions, ToCss};
 use crate::values::angle::Angle;
 use crate::values::color::{
@@ -1176,6 +1176,44 @@ impl<'i> TokenList<'i> {
     res
   }
 
+  pub(crate) fn get_features(&self) -> Features {
+    let mut features = Features::empty();
+    for token in &self.0 {
+      match token {
+        TokenOrValue::Color(color) => {
+          features |= color.get_features();
+        }
+        TokenOrValue::UnresolvedColor(unresolved_color) => {
+          features |= Features::SpaceSeparatedColorNotation;
+          match unresolved_color {
+            UnresolvedColor::LightDark { light, dark } => {
+              features |= Features::LightDark;
+              features |= light.get_features();
+              features |= dark.get_features();
+            }
+            _ => {}
+          }
+        }
+        TokenOrValue::Function(f) => {
+          features |= f.arguments.get_features();
+        }
+        TokenOrValue::Var(v) => {
+          if let Some(fallback) = &v.fallback {
+            features |= fallback.get_features();
+          }
+        }
+        TokenOrValue::Env(v) => {
+          if let Some(fallback) = &v.fallback {
+            features |= fallback.get_features();
+          }
+        }
+        _ => {}
+      }
+    }
+
+    features
+  }
+
   /// Substitutes variables with the provided values.
   #[cfg(feature = "substitute_variables")]
   #[cfg_attr(docsrs, doc(cfg(feature = "substitute_variables")))]
@@ -1605,7 +1643,7 @@ impl<'i> UnresolvedColor<'i> {
 
     match self {
       UnresolvedColor::RGB { r, g, b, alpha } => {
-        if should_compile!(dest.targets, SpaceSeparatedColorNotation) {
+        if should_compile!(dest.targets.current, SpaceSeparatedColorNotation) {
           dest.write_str("rgba(")?;
           c(r).to_css(dest)?;
           dest.delim(',', false)?;
@@ -1629,7 +1667,7 @@ impl<'i> UnresolvedColor<'i> {
         dest.write_char(')')
       }
       UnresolvedColor::HSL { h, s, l, alpha } => {
-        if should_compile!(dest.targets, SpaceSeparatedColorNotation) {
+        if should_compile!(dest.targets.current, SpaceSeparatedColorNotation) {
           dest.write_str("hsla(")?;
           h.to_css(dest)?;
           dest.delim(',', false)?;
@@ -1653,7 +1691,7 @@ impl<'i> UnresolvedColor<'i> {
         dest.write_char(')')
       }
       UnresolvedColor::LightDark { light, dark } => {
-        if should_compile!(dest.targets, LightDark) {
+        if should_compile!(dest.targets.current, LightDark) {
           dest.write_str("var(--lightningcss-light")?;
           dest.delim(',', false)?;
           light.to_css(dest, is_custom_property)?;

src/rules/container.rs

@@ -218,7 +218,7 @@ impl<'i> ToCss for ContainerCondition<'i> {
       ContainerCondition::Feature(ref f) => f.to_css(dest),
       ContainerCondition::Not(ref c) => {
         dest.write_str("not ")?;
-        to_css_with_parens_if_needed(&**c, dest, c.needs_parens(None, &dest.targets))
+        to_css_with_parens_if_needed(&**c, dest, c.needs_parens(None, &dest.targets.current))
       }
       ContainerCondition::Operation {
         ref conditions,
@@ -243,7 +243,7 @@ impl<'i> ToCss for StyleQuery<'i> {
       StyleQuery::Property(ref f) => f.to_css(dest),
       StyleQuery::Not(ref c) => {
         dest.write_str("not ")?;
-        to_css_with_parens_if_needed(&**c, dest, c.needs_parens(None, &dest.targets))
+        to_css_with_parens_if_needed(&**c, dest, c.needs_parens(None, &dest.targets.current))
       }
       StyleQuery::Operation {
         ref conditions,
@@ -313,10 +313,10 @@ impl<'a, 'i, T: ToCss> ToCss for ContainerRule<'i, T> {
     }
 
     // Don't downlevel range syntax in container queries.
-    let exclude = dest.targets.exclude;
-    dest.targets.exclude.insert(Features::MediaQueries);
+    let exclude = dest.targets.current.exclude;
+    dest.targets.current.exclude.insert(Features::MediaQueries);
     self.condition.to_css(dest)?;
-    dest.targets.exclude = exclude;
+    dest.targets.current.exclude = exclude;
 
     dest.whitespace()?;
     dest.write_char('{')?;

src/rules/style.rs

@@ -245,7 +245,7 @@ impl<'a, 'i, T: ToCss> StyleRule<'i, T> {
     W: std::fmt::Write,
   {
     // If supported, or there are no targets, preserve nesting. Otherwise, write nested rules after parent.
-    let supports_nesting = self.rules.0.is_empty() || !should_compile!(dest.targets, Nesting);
+    let supports_nesting = self.rules.0.is_empty() || !should_compile!(dest.targets.current, Nesting);
     let len = self.declarations.declarations.len() + self.declarations.important_declarations.len();
     let has_declarations = supports_nesting || len > 0 || self.rules.0.is_empty();
 

src/rules/supports.rs

@@ -7,10 +7,10 @@ use super::{CssRuleList, MinifyContext};
 use crate::error::{MinifyError, ParserError, PrinterError};
 use crate::parser::DefaultAtRule;
 use crate::printer::Printer;
+use crate::properties::custom::TokenList;
 use crate::properties::PropertyId;
 use crate::targets::{Features, FeaturesIterator, Targets};
 use crate::traits::{Parse, ToCss};
-use crate::values::color::ColorFallbackKind;
 use crate::values::string::CowArcStr;
 use crate::vendor_prefix::VendorPrefix;
 #[cfg(feature = "visitor")]
@@ -72,7 +72,13 @@ impl<'a, 'i, T: ToCss> ToCss for SupportsRule<'i, T> {
     dest.write_char('{')?;
     dest.indent();
     dest.newline()?;
+
+    let inserted = dest.targets.enter_supports(self.condition.get_supported_features());
     self.rules.to_css(dest)?;
+    if inserted {
+      dest.targets.exit_supports();
+    }
+
     dest.dedent();
     dest.newline()?;
     dest.write_char('}')
@@ -163,24 +169,21 @@ impl<'i> SupportsCondition<'i> {
   }
 
   fn get_supported_features(&self) -> Features {
-    const COLOR_P3_SUPPORTS_CONDITION: &str = ColorFallbackKind::P3.supports_condition_value();
-    const COLOR_LAB_SUPPORTS_CONDITION: &str = ColorFallbackKind::LAB.supports_condition_value();
     fn get_supported_features_internal(value: &SupportsCondition) -> Option<Features> {
       match value {
         SupportsCondition::And(list) => list.iter().map(|c| get_supported_features_internal(c)).try_union_all(),
-        SupportsCondition::Declaration { property_id, value } => match property_id {
-          PropertyId::Color => Some(match value.as_ref() {
-            COLOR_P3_SUPPORTS_CONDITION => Features::P3Colors | Features::ColorFunction,
-            COLOR_LAB_SUPPORTS_CONDITION => Features::LabColors,
-            _ => Features::empty(),
-          }),
-          _ => Some(Features::empty()),
-        },
+        SupportsCondition::Declaration { value, .. } => {
+          let mut input = ParserInput::new(&value);
+          let mut parser = Parser::new(&mut input);
+          if let Ok(tokens) = TokenList::parse(&mut parser, &Default::default(), 0) {
+            Some(tokens.get_features())
+          } else {
+            Some(Features::empty())
+          }
+        }
         // bail out if "not" or "or" exists for now
         SupportsCondition::Not(_) | SupportsCondition::Or(_) => None,
-        SupportsCondition::Selector(_) | SupportsCondition::Unknown(_) => {
-          Some(Features::empty())
-        }
+        SupportsCondition::Selector(_) | SupportsCondition::Unknown(_) => Some(Features::empty()),
       }
     }
 

src/selector.rs

@@ -1371,7 +1371,7 @@ where
 
   let mut combinators = selector.iter_raw_match_order().rev().filter_map(|x| x.as_combinator());
   let compound_selectors = selector.iter_raw_match_order().as_slice().split(|x| x.is_combinator()).rev();
-  let should_compile_nesting = should_compile!(dest.targets, Nesting);
+  let should_compile_nesting = should_compile!(dest.targets.current, Nesting);
 
   let mut first = true;
   let mut combinators_exhausted = false;
@@ -1681,7 +1681,7 @@ where
   } else {
     // If there is no context, we are at the root if nesting is supported. This is equivalent to :scope.
     // Otherwise, if nesting is supported, serialize the nesting selector directly.
-    if should_compile!(dest.targets, Nesting) {
+    if should_compile!(dest.targets.current, Nesting) {
       dest.write_str(":scope")
     } else {
       dest.write_char('&')

src/values/calc.rs

@@ -161,7 +161,7 @@ impl<V: ToCss + std::ops::Mul<f32, Output = V> + TrySign + Clone + std::fmt::Deb
       }
       MathFunction::Clamp(a, b, c) => {
         // If clamp() is unsupported by targets, output min()/max()
-        if should_compile!(dest.targets, ClampFunction) {
+        if should_compile!(dest.targets.current, ClampFunction) {
           dest.write_str("max(")?;
           a.to_css(dest)?;
           dest.delim(',', false)?;