Fix calc in @media

Fixes parcel-bundler#195.

Adds a new AddInternal trait used for performing addition within a calc(). This doesn't wrap sums in calc() functions, because that's not necessary for nested sums within math functions. The result is wrapped in calc() if necessary during parsing. Later, if the calc() needs to be modified, we need to unwrap this calc, perform the addition, and re-wrap if necessary. That's now done by the public std::ops::Add implementation.

Author: devongovett

src/lib.rs

@@ -5881,6 +5881,10 @@ mod tests {
       ".foo { left: calc(50% - 100px + clamp(0px, calc(50vw - 50px), 100px)) }",
       ".foo{left:calc(50% - 100px + clamp(0px,50vw - 50px,100px))}",
     );
+    minify_test(
+      ".foo { left: calc(10px + min(10px, 1rem) + max(2px, 1vw)) }",
+      ".foo{left:calc(10px + min(10px,1rem) + max(2px,1vw))}",
+    );
   }
 
   #[test]
@@ -6337,6 +6341,43 @@ mod tests {
       "#,
       "\n",
     );
+
+    prefix_test(
+      r#"
+      @media (width > calc(1px + 1rem)) {
+        .foo { color: yellow; }
+      }
+      "#,
+      indoc! { r#"
+        @media (min-width: calc(1.001px + 1rem)) {
+          .foo {
+            color: #ff0;
+          }
+        }
+      "#},
+      Browsers {
+        chrome: Some(85 << 16),
+        ..Browsers::default()
+      },
+    );
+    prefix_test(
+      r#"
+      @media (width > max(10px, 1rem)) {
+        .foo { color: yellow; }
+      }
+      "#,
+      indoc! { r#"
+        @media (min-width: calc(max(10px, 1rem) + .001px)) {
+          .foo {
+            color: #ff0;
+          }
+        }
+      "#},
+      Browsers {
+        chrome: Some(85 << 16),
+        ..Browsers::default()
+      },
+    );
   }
 
   #[test]

src/traits.rs

@@ -89,6 +89,10 @@ pub(crate) mod private {
   pub trait TryAdd<T> {
     fn try_add(&self, other: &T) -> Option<T>;
   }
+
+  pub trait AddInternal {
+    fn add(self, other: Self) -> Self;
+  }
 }
 
 pub(crate) trait FromStandard<T>: Sized {

src/values/angle.rs

@@ -6,7 +6,10 @@ use super::number::CSSNumber;
 use super::percentage::DimensionPercentage;
 use crate::error::{ParserError, PrinterError};
 use crate::printer::Printer;
-use crate::traits::{private::TryAdd, Parse, ToCss};
+use crate::traits::{
+  private::{AddInternal, TryAdd},
+  Parse, ToCss,
+};
 use cssparser::*;
 use std::f32::consts::PI;
 
@@ -150,6 +153,12 @@ impl std::ops::Add<Angle> for Angle {
   }
 }
 
+impl AddInternal for Angle {
+  fn add(self, other: Self) -> Self {
+    self + other
+  }
+}
+
 impl TryAdd<Angle> for Angle {
   fn try_add(&self, other: &Angle) -> Option<Angle> {
     Some(Angle::Deg(self.to_degrees() + other.to_degrees()))

src/values/calc.rs

@@ -3,6 +3,7 @@
 use crate::compat::Feature;
 use crate::error::{ParserError, PrinterError};
 use crate::printer::Printer;
+use crate::traits::private::AddInternal;
 use crate::traits::{Parse, ToCss};
 use cssparser::*;
 
@@ -123,7 +124,7 @@ impl<
     'i,
     V: Parse<'i>
       + std::ops::Mul<f32, Output = V>
-      + std::ops::Add<V, Output = V>
+      + AddInternal
       + std::cmp::PartialOrd<V>
       + std::convert::Into<Calc<V>>
       + std::convert::From<Calc<V>>
@@ -221,7 +222,7 @@ impl<
     'i,
     V: Parse<'i>
       + std::ops::Mul<f32, Output = V>
-      + std::ops::Add<V, Output = V>
+      + AddInternal
       + std::cmp::PartialOrd<V>
       + std::convert::Into<Calc<V>>
       + std::convert::From<Calc<V>>
@@ -240,12 +241,12 @@ impl<
           match *input.next()? {
             Token::Delim('+') => {
               let next = Calc::parse_product(input)?;
-              cur = cur + next;
+              cur = cur.add(next);
             }
             Token::Delim('-') => {
               let mut rhs = Calc::parse_product(input)?;
               rhs = rhs * -1.0;
-              cur = cur + rhs;
+              cur = cur.add(rhs);
             }
             ref t => {
               let t = t.clone();
@@ -392,21 +393,18 @@ impl<V: std::ops::Mul<f32, Output = V>> std::ops::Mul<f32> for Calc<V> {
   }
 }
 
-impl<
-    V: std::ops::Add<V, Output = V> + std::convert::Into<Calc<V>> + std::convert::From<Calc<V>> + std::fmt::Debug,
-  > std::ops::Add<Calc<V>> for Calc<V>
+impl<V: AddInternal + std::convert::Into<Calc<V>> + std::convert::From<Calc<V>> + std::fmt::Debug> AddInternal
+  for Calc<V>
 {
-  type Output = Self;
-
   fn add(self, other: Calc<V>) -> Calc<V> {
     match (self, other) {
-      (Calc::Value(a), Calc::Value(b)) => (*a + *b).into(),
+      (Calc::Value(a), Calc::Value(b)) => (a.add(*b)).into(),
       (Calc::Number(a), Calc::Number(b)) => Calc::Number(a + b),
-      (Calc::Value(a), b) => (*a + V::from(b)).into(),
-      (a, Calc::Value(b)) => (V::from(a) + *b).into(),
+      (Calc::Value(a), b) => (a.add(V::from(b))).into(),
+      (a, Calc::Value(b)) => (V::from(a).add(*b)).into(),
       (Calc::Function(a), b) => Calc::Sum(Box::new(Calc::Function(a)), Box::new(b)),
       (a, Calc::Function(b)) => Calc::Sum(Box::new(a), Box::new(Calc::Function(b))),
-      (a, b) => (V::from(a) + V::from(b)).into(),
+      (a, b) => V::from(a).add(V::from(b)).into(),
     }
   }
 }

src/values/length.rs

@@ -1,11 +1,14 @@
 //! CSS length values.
 
-use super::calc::Calc;
+use super::calc::{Calc, MathFunction};
 use super::number::CSSNumber;
 use super::percentage::DimensionPercentage;
 use crate::error::{ParserError, PrinterError};
 use crate::printer::Printer;
-use crate::traits::{private::TryAdd, Parse, ToCss};
+use crate::traits::{
+  private::{AddInternal, TryAdd},
+  Parse, ToCss,
+};
 use const_str;
 use cssparser::*;
 
@@ -444,6 +447,37 @@ impl std::ops::Add<Length> for Length {
   type Output = Self;
 
   fn add(self, other: Length) -> Length {
+    // Unwrap calc(...) functions so we can add inside.
+    // Then wrap the result in a calc(...) again if necessary.
+    let a = unwrap_calc(self);
+    let b = unwrap_calc(other);
+    let res = AddInternal::add(a, b);
+    match res {
+      Length::Calc(c) => match *c {
+        Calc::Value(l) => *l,
+        Calc::Function(f) if !matches!(*f, MathFunction::Calc(_)) => Length::Calc(Box::new(Calc::Function(f))),
+        c => Length::Calc(Box::new(Calc::Function(Box::new(MathFunction::Calc(c))))),
+      },
+      _ => res,
+    }
+  }
+}
+
+fn unwrap_calc(length: Length) -> Length {
+  match length {
+    Length::Calc(c) => match *c {
+      Calc::Function(f) => match *f {
+        MathFunction::Calc(c) => Length::Calc(Box::new(c)),
+        c => Length::Calc(Box::new(Calc::Function(Box::new(c)))),
+      },
+      _ => Length::Calc(c),
+    },
+    _ => length,
+  }
+}
+
+impl AddInternal for Length {
+  fn add(self, other: Self) -> Self {
     match self.try_add(&other) {
       Some(r) => r,
       None => self.add(other),
@@ -488,7 +522,7 @@ impl Length {
     }
 
     match (a, b) {
-      (Length::Calc(a), Length::Calc(b)) => return Length::Calc(Box::new(*a + *b)),
+      (Length::Calc(a), Length::Calc(b)) => return Length::Calc(Box::new(a.add(*b))),
       (Length::Calc(calc), b) => {
         if let Calc::Value(a) = *calc {
           a.add(b)

src/values/number.rs

@@ -3,6 +3,7 @@
 use super::calc::Calc;
 use crate::error::{ParserError, PrinterError};
 use crate::printer::Printer;
+use crate::traits::private::AddInternal;
 use crate::traits::{Parse, ToCss};
 use cssparser::*;
 
@@ -64,6 +65,12 @@ impl std::convert::From<Calc<CSSNumber>> for CSSNumber {
   }
 }
 
+impl AddInternal for CSSNumber {
+  fn add(self, other: Self) -> Self {
+    self + other
+  }
+}
+
 /// A CSS [`<integer>`](https://www.w3.org/TR/css-values-4/#integers) value.
 pub type CSSInteger = i32;
 

src/values/percentage.rs

@@ -1,9 +1,10 @@
 //! CSS percentage values.
 
-use super::calc::Calc;
+use super::calc::{Calc, MathFunction};
 use super::number::CSSNumber;
 use crate::error::{ParserError, PrinterError};
 use crate::printer::Printer;
+use crate::traits::private::AddInternal;
 use crate::traits::{private::TryAdd, Parse, ToCss};
 use cssparser::*;
 
@@ -92,6 +93,12 @@ impl std::ops::Add<Percentage> for Percentage {
   }
 }
 
+impl AddInternal for Percentage {
+  fn add(self, other: Self) -> Self {
+    self + other
+  }
+}
+
 impl std::cmp::PartialEq<CSSNumber> for Percentage {
   fn eq(&self, other: &CSSNumber) -> bool {
     self.0 == *other
@@ -233,9 +240,44 @@ impl<D: std::ops::Mul<CSSNumber, Output = D>> std::ops::Mul<CSSNumber> for Dimen
 impl<D: TryAdd<D> + Clone + std::cmp::PartialEq<CSSNumber> + std::cmp::PartialOrd<CSSNumber> + std::fmt::Debug>
   std::ops::Add<DimensionPercentage<D>> for DimensionPercentage<D>
 {
-  type Output = Self;
+  type Output = DimensionPercentage<D>;
 
   fn add(self, other: DimensionPercentage<D>) -> DimensionPercentage<D> {
+    // Unwrap calc(...) functions so we can add inside.
+    // Then wrap the result in a calc(...) again if necessary.
+    let a = unwrap_calc(self);
+    let b = unwrap_calc(other);
+    let res = AddInternal::add(a, b);
+    match res {
+      DimensionPercentage::Calc(c) => match *c {
+        Calc::Value(l) => *l,
+        Calc::Function(f) if !matches!(*f, MathFunction::Calc(_)) => {
+          DimensionPercentage::Calc(Box::new(Calc::Function(f)))
+        }
+        c => DimensionPercentage::Calc(Box::new(Calc::Function(Box::new(MathFunction::Calc(c))))),
+      },
+      _ => res,
+    }
+  }
+}
+
+fn unwrap_calc<D>(v: DimensionPercentage<D>) -> DimensionPercentage<D> {
+  match v {
+    DimensionPercentage::Calc(c) => match *c {
+      Calc::Function(f) => match *f {
+        MathFunction::Calc(c) => DimensionPercentage::Calc(Box::new(c)),
+        c => DimensionPercentage::Calc(Box::new(Calc::Function(Box::new(c)))),
+      },
+      _ => DimensionPercentage::Calc(c),
+    },
+    _ => v,
+  }
+}
+
+impl<D: TryAdd<D> + Clone + std::cmp::PartialEq<CSSNumber> + std::cmp::PartialOrd<CSSNumber> + std::fmt::Debug>
+  AddInternal for DimensionPercentage<D>
+{
+  fn add(self, other: Self) -> Self {
     match self.add_recursive(&other) {
       Some(r) => r,
       None => self.add(other),
@@ -309,7 +351,9 @@ impl<D: TryAdd<D> + Clone + std::cmp::PartialEq<CSSNumber> + std::cmp::PartialOr
     }
 
     match (a, b) {
-      (DimensionPercentage::Calc(a), DimensionPercentage::Calc(b)) => DimensionPercentage::Calc(Box::new(*a + *b)),
+      (DimensionPercentage::Calc(a), DimensionPercentage::Calc(b)) => {
+        DimensionPercentage::Calc(Box::new(a.add(*b)))
+      }
       (DimensionPercentage::Calc(calc), b) => {
         if let Calc::Value(a) = *calc {
           a.add(b)

src/values/time.rs

@@ -4,6 +4,7 @@ use super::calc::Calc;
 use super::number::CSSNumber;
 use crate::error::{ParserError, PrinterError};
 use crate::printer::Printer;
+use crate::traits::private::AddInternal;
 use crate::traits::{Parse, ToCss};
 use cssparser::*;
 
@@ -127,6 +128,12 @@ impl std::ops::Add<Time> for Time {
   }
 }
 
+impl AddInternal for Time {
+  fn add(self, other: Self) -> Self {
+    self + other
+  }
+}
+
 impl std::cmp::PartialEq<f32> for Time {
   fn eq(&self, other: &f32) -> bool {
     match self {