Inline NumericValue struct into Token::Dimension enum fields…

… to require less alignment and reduce the size of Token

Author: SimonSapin

src/color.rs

@@ -502,7 +502,7 @@ fn parse_rgb_components_hsl<'i, 't>(arguments: &mut Parser<'i, 't>) -> Result<(u
     let token = try!(arguments.next());
     let hue_degrees = match token {
         Token::Number(NumericValue { value: v, .. }) => Ok(v),
-        Token::Dimension(NumericValue { value: v, .. }, ref unit) => {
+        Token::Dimension { value: v, ref unit, .. } => {
             match_ignore_ascii_case! { &*unit,
                 "deg" => Ok(v),
                 "grad" => Ok(v * 360. / 400.),

src/nth.rs

@@ -20,20 +20,14 @@ pub fn parse_nth<'i, 't>(input: &mut Parser<'i, 't>) -> Result<(i32, i32), Basic
                 None => Err(()),
             }
         }
-        Token::Dimension(value, ref unit) => {
-            match value.int_value {
-                Some(v) => {
-                    let a = v as i32;
-                    match_ignore_ascii_case! {
-                        &unit,
-                        "n" => Ok(try!(parse_b(input, a))),
-                        "n-" => Ok(try!(parse_signless_b(input, a, -1))),
-                        _ => {
-                            parse_n_dash_digits(&*unit).map(|val| (a, val))
-                        }
-                    }
+        Token::Dimension { int_value: Some(a), ref unit, .. } => {
+            match_ignore_ascii_case! {
+                &unit,
+                "n" => Ok(try!(parse_b(input, a))),
+                "n-" => Ok(try!(parse_signless_b(input, a, -1))),
+                _ => {
+                    parse_n_dash_digits(&*unit).map(|val| (a, val))
                 }
-                None => Err(()),
             }
         }
         Token::Ident(ref value) => {

src/serializer.rs

@@ -97,8 +97,12 @@ impl<'a> ToCss for Token<'a> {
                 try!(write_numeric(value, dest));
                 try!(dest.write_str("%"));
             },
-            Token::Dimension(value, ref unit) => {
-                try!(write_numeric(value, dest));
+            Token::Dimension { value, int_value, has_sign, ref unit } => {
+                try!(write_numeric(NumericValue {
+                    value: value,
+                    int_value: int_value,
+                    has_sign: has_sign,
+                }, dest));
                 // Disambiguate with scientific notation.
                 let unit = &**unit;
                 if unit == "e" || unit == "E" || unit.starts_with("e-") || unit.starts_with("E-") {
@@ -391,7 +395,7 @@ impl<'a> Token<'a> {
             Token::Delim('*') => DelimAsterisk,
             Token::Number(_) => Number,
             Token::Percentage(_) => Percentage,
-            Token::Dimension(..) => Dimension,
+            Token::Dimension { .. } => Dimension,
             Token::WhiteSpace(_) => WhiteSpace,
             Token::Comment(_) => DelimSlash,
             Token::DashMatch => DashMatch,

src/size_of_tests.rs

@@ -32,7 +32,7 @@ macro_rules! size_of_test {
 }
 
 // These assume 64-bit
-size_of_test!(token, Token, 40);
+size_of_test!(token, Token, 32);
 size_of_test!(numeric_value, NumericValue, 16);
 size_of_test!(percentage_value, PercentageValue, 16);
 size_of_test!(std_cow_str, Cow<'static, str>, 32);

src/tests.rs

@@ -807,9 +807,13 @@ fn one_component_value_to_json(token: Token, input: &mut Parser) -> Json {
             }));
             v
         }),
-        Token::Dimension(value, unit) => Json::Array({
+        Token::Dimension { value, int_value, has_sign, unit } => Json::Array({
             let mut v = vec!["dimension".to_json()];
-            v.extend(numeric(value));
+            v.extend(numeric(NumericValue {
+                value: value,
+                int_value: int_value,
+                has_sign: has_sign,
+            }));
             v.push(unit.to_json());
             v
         }),

src/tokenizer.rs

@@ -59,7 +59,21 @@ pub enum Token<'a> {
     Percentage(PercentageValue),
 
     /// A [`<dimension-token>`](https://drafts.csswg.org/css-syntax/#dimension-token-diagram)
-    Dimension(NumericValue, CompactCowStr<'a>),
+    Dimension {
+        /// The value as a float
+        value: f32,
+
+        /// If the origin source did not include a fractional part, the value as an integer.
+        int_value: Option<i32>,
+
+        /// Whether the number had a `+` or `-` sign.
+        ///
+        /// This is used is some cases like the <An+B> micro syntax. (See the `parse_nth` function.)
+        has_sign: bool,
+
+        /// The unit, e.g. "px" in `12px`
+        unit: CompactCowStr<'a>
+    },
 
     /// A [`<whitespace-token>`](https://drafts.csswg.org/css-syntax/#whitespace-token-diagram)
     WhiteSpace(&'a str),
@@ -861,24 +875,29 @@ fn consume_numeric<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> {
             has_sign: has_sign,
         })
     }
-    let value = NumericValue {
-        value: value as f32,
-        int_value: int_value,
-        has_sign: has_sign,
-    };
+    let value = value as f32;
     if is_ident_start(tokenizer) {
-        let name = consume_name(tokenizer);
+        let unit = consume_name(tokenizer);
         if tokenizer.viewport_percentages == SeenStatus::LookingForThem {
-            if name.eq_ignore_ascii_case("vh") ||
-               name.eq_ignore_ascii_case("vw") ||
-               name.eq_ignore_ascii_case("vmin") ||
-               name.eq_ignore_ascii_case("vmax") {
+            if unit.eq_ignore_ascii_case("vh") ||
+               unit.eq_ignore_ascii_case("vw") ||
+               unit.eq_ignore_ascii_case("vmin") ||
+               unit.eq_ignore_ascii_case("vmax") {
                    tokenizer.viewport_percentages = SeenStatus::SeenAtLeastOne;
            }
         }
-        Dimension(value, name)
+        Dimension {
+            value: value,
+            int_value: int_value,
+            has_sign: has_sign,
+            unit: unit,
+        }
     } else {
-        Number(value)
+        Number(NumericValue {
+            value: value,
+            int_value: int_value,
+            has_sign: has_sign,
+        })
     }
 }
 

src/unicode_range.rs

@@ -64,14 +64,14 @@ fn parse_tokens<'i, 't>(input: &mut Parser<'i, 't>) -> Result<(), BasicParseErro
             }
             parse_question_marks(input)
         }
-        Token::Dimension(..) => {
+        Token::Dimension { .. } => {
             parse_question_marks(input)
         }
         Token::Number(_) => {
             let after_number = input.position();
             match input.next_including_whitespace() {
                 Ok(Token::Delim('?')) => parse_question_marks(input),
-                Ok(Token::Dimension(..)) => {}
+                Ok(Token::Dimension { .. }) => {}
                 Ok(Token::Number(_)) => {}
                 _ => input.reset(after_number)
             }