Angles and times don't need to store calcs

Author: devongovett

src/values/angle.rs

@@ -10,15 +10,15 @@ pub enum Angle {
   Deg(f32),
   Grad(f32),
   Rad(f32),
-  Turn(f32),
-  Calc(Calc<Angle>)
+  Turn(f32)
 }
 
 impl Parse for Angle {
   fn parse<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ()>> {
     match input.try_parse(Calc::parse) {
       Ok(Calc::Value(v)) => return Ok(*v),
-      Ok(calc) => return Ok(Angle::Calc(calc)),
+      // Angles are always compatible, so they will always compute to a value.
+      Ok(_) => unreachable!(),
       _ => {}
     }
 
@@ -45,20 +45,16 @@ impl ToCss for Angle {
       Angle::Deg(val) => (*val, "deg"),
       Angle::Grad(val) => (*val, "grad"),
       Angle::Rad(val) => {
-        if let Some(deg) = self.to_degrees() {
-          // We print 5 digits of precision by default.
-          // Switch to degrees if there are an even number of them.
-          if (deg * 100000.0).round().fract() == 0.0 {
-            (deg, "deg")
-          } else {
-            (*val, "rad")
-          }
+        let deg = self.to_degrees();
+        // We print 5 digits of precision by default.
+        // Switch to degrees if there are an even number of them.
+        if (deg * 100000.0).round().fract() == 0.0 {
+          (deg, "deg")
         } else {
           (*val, "rad")
         }
       },
-      Angle::Turn(val) => (*val, "turn"),
-      Angle::Calc(calc) => return calc.to_css(dest)
+      Angle::Turn(val) => (*val, "turn")
     };
 
     use cssparser::ToCss;
@@ -93,47 +89,42 @@ impl Angle {
     use Angle::*;
     match self {
       Deg(v) | Rad(v) | Grad(v) | Turn(v) => *v == 0.0,
-      Calc(_) => false
     }
   }
 
-  pub fn to_radians(&self) -> Option<f32> {
+  pub fn to_radians(&self) -> f32 {
     const RAD_PER_DEG: f32 = PI / 180.0;
-    let r = match self {
+    match self {
       Angle::Deg(deg) => deg * RAD_PER_DEG,
       Angle::Rad(rad) => *rad,
       Angle::Grad(grad) => grad * 180.0 / 200.0 * RAD_PER_DEG,
       Angle::Turn(turn) => turn * 360.0 * RAD_PER_DEG,
-      Angle::Calc(_) => return None
-    };
-    Some(r)
+    }
   }
 
-  pub fn to_degrees(&self) -> Option<f32> {
+  pub fn to_degrees(&self) -> f32 {
     const DEG_PER_RAD: f32 = 180.0 / PI;
-    let d = match self {
+    match self {
       Angle::Deg(deg) => *deg,
       Angle::Rad(rad) => rad * DEG_PER_RAD,
       Angle::Grad(grad) => grad * 180.0 / 200.0,
       Angle::Turn(turn) => turn * 360.0,
-      Angle::Calc(_) => return None
-    };
-    Some(d)
+    }
   }
 }
 
 impl std::convert::Into<Calc<Angle>> for Angle {
   fn into(self) -> Calc<Angle> {
-    match self {
-      Angle::Calc(c) => c,
-      b => Calc::Value(Box::new(b))
-    }
+    Calc::Value(Box::new(self))
   }
 }
 
 impl std::convert::From<Calc<Angle>> for Angle {
   fn from(calc: Calc<Angle>) -> Angle {
-    Angle::Calc(calc)
+    match calc {
+      Calc::Value(v) => *v,
+      _ => unreachable!()
+    }
   }
 }
 
@@ -146,7 +137,6 @@ impl std::ops::Mul<f32> for Angle {
       Angle::Rad(v) => Angle::Deg(v * other),
       Angle::Grad(v) => Angle::Deg(v * other),
       Angle::Turn(v) => Angle::Deg(v * other),
-      Angle::Calc(c) => Angle::Calc(c * other)
     }
   }
 }
@@ -155,20 +145,14 @@ impl std::ops::Add<Angle> for Angle {
   type Output = Self;
 
   fn add(self, other: Angle) -> Angle {
-    match (self, other) {
-      (Angle::Calc(a), Angle::Calc(b)) => Angle::Calc(a + b),
-      (Angle::Calc(a), b) => Angle::Calc(a + Calc::Value(Box::new(b))),
-      (a, Angle::Calc(b)) => Angle::Calc(Calc::Value(Box::new(a)) + b),
-      (a, b) => Angle::Deg(a.to_degrees().unwrap() + b.to_degrees().unwrap())
-    }
+    Angle::Deg(self.to_degrees() + other.to_degrees())
   }
 }
 
 impl std::cmp::PartialEq<f32> for Angle {
   fn eq(&self, other: &f32) -> bool {
     match self {
       Angle::Deg(a) | Angle::Rad(a) | Angle::Grad(a) | Angle::Turn(a) => a == other,
-      Angle::Calc(_) => false
     }
   }
 }
@@ -177,7 +161,6 @@ impl std::cmp::PartialOrd<f32> for Angle {
   fn partial_cmp(&self, other: &f32) -> Option<std::cmp::Ordering> {
     match self {
       Angle::Deg(a) | Angle::Rad(a) | Angle::Grad(a) | Angle::Turn(a) => a.partial_cmp(other),
-      Angle::Calc(_) => None
     }
   }
 }

src/values/time.rs

@@ -1,22 +1,21 @@
 use cssparser::*;
 use crate::traits::{Parse, ToCss};
 use crate::printer::Printer;
-use std::fmt::Write;
 use super::calc::Calc;
 
 /// https://www.w3.org/TR/css3-values/#time-value
 #[derive(Debug, Clone, PartialEq)]
 pub enum Time {
   Seconds(f32),
-  Milliseconds(f32),
-  Calc(Calc<Time>)
+  Milliseconds(f32)
 }
 
 impl Parse for Time {
   fn parse<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ()>> {
     match input.try_parse(Calc::parse) {
       Ok(Calc::Value(v)) => return Ok(*v),
-      Ok(calc) => return Ok(Time::Calc(calc)),
+      // Time is always compatible, so they will always compute to a value.
+      Ok(_) => unreachable!(),
       _ => {}
     }
 
@@ -57,23 +56,22 @@ impl ToCss for Time {
           dest.write_str("ms")
         }
       }
-      Time::Calc(calc) => calc.to_css(dest)
     }
   }
 }
 
 impl std::convert::Into<Calc<Time>> for Time {
   fn into(self) -> Calc<Time> {
-    match self {
-      Time::Calc(c) => c,
-      b => Calc::Value(Box::new(b))
-    }
+    Calc::Value(Box::new(self))
   }
 }
 
 impl std::convert::From<Calc<Time>> for Time {
   fn from(calc: Calc<Time>) -> Time {
-    Time::Calc(calc)
+    match calc {
+      Calc::Value(v) => *v,
+      _ => unreachable!()
+    }
   }
 }
 
@@ -84,7 +82,6 @@ impl std::ops::Mul<f32> for Time {
     match self {
       Time::Seconds(t) => Time::Seconds(t * other),
       Time::Milliseconds(t) => Time::Milliseconds(t * other),
-      Time::Calc(c) => Time::Calc(c * other)
     }
   }
 }
@@ -98,9 +95,6 @@ impl std::ops::Add<Time> for Time {
       (Time::Milliseconds(a), Time::Milliseconds(b)) => Time::Milliseconds(a + b),
       (Time::Seconds(a), Time::Milliseconds(b)) => Time::Seconds(a + b / 1000.0),
       (Time::Milliseconds(a), Time::Seconds(b)) => Time::Seconds(a + b * 1000.0),
-      (Time::Calc(a), Time::Calc(b)) => Time::Calc(a + b),
-      (Time::Calc(a), b) => Time::Calc(a + Calc::Value(Box::new(b))),
-      (a, Time::Calc(b)) => Time::Calc(Calc::Value(Box::new(a)) + b),
     }
   }
 }
@@ -109,7 +103,6 @@ impl std::cmp::PartialEq<f32> for Time {
   fn eq(&self, other: &f32) -> bool {
     match self {
       Time::Seconds(a) | Time::Milliseconds(a) => a == other,
-      Time::Calc(_) => false
     }
   }
 }
@@ -118,7 +111,6 @@ impl std::cmp::PartialOrd<f32> for Time {
   fn partial_cmp(&self, other: &f32) -> Option<std::cmp::Ordering> {
     match self {
       Time::Seconds(a) | Time::Milliseconds(a) => a.partial_cmp(other),
-      Time::Calc(_) => None
     }
   }
 }