Inline fields of Token::Percentage to align with Number and Dimension

Author: SimonSapin

src/color.rs

@@ -432,8 +432,8 @@ fn parse_color_function<'i, 't>(name: &str, arguments: &mut Parser<'i, 't>) -> R
             Token::Number { value: v, .. } => {
                 clamp_unit_f32(v)
             }
-            Token::Percentage(ref v) => {
-                clamp_unit_f32(v.unit_value)
+            Token::Percentage { unit_value: v, .. } => {
+                clamp_unit_f32(v)
             }
             t => {
                 return Err(BasicParseError::UnexpectedToken(t))
@@ -473,10 +473,10 @@ fn parse_rgb_components_rgb<'i, 't>(arguments: &mut Parser<'i, 't>) -> Result<(u
             }
             blue = clamp_floor_256_f32(try!(arguments.expect_number()));
         }
-        Token::Percentage(ref v) => {
-            red = clamp_unit_f32(v.unit_value);
+        Token::Percentage { unit_value, .. } => {
+            red = clamp_unit_f32(unit_value);
             green = clamp_unit_f32(match try!(arguments.next()) {
-                Token::Percentage(ref v) => v.unit_value,
+                Token::Percentage { unit_value, .. } => unit_value,
                 Token::Comma => {
                     uses_commas = true;
                     try!(arguments.expect_percentage())
@@ -520,7 +520,7 @@ fn parse_rgb_components_hsl<'i, 't>(arguments: &mut Parser<'i, 't>) -> Result<(u
     // Saturation and lightness are clamped to 0% ... 100%
     // https://drafts.csswg.org/css-color/#the-hsl-notation
     let saturation = match try!(arguments.next()) {
-        Token::Percentage(ref v) => v.unit_value,
+        Token::Percentage { unit_value, .. } => unit_value,
         Token::Comma => {
             uses_commas = true;
             try!(arguments.expect_percentage())

src/lib.rs

@@ -80,7 +80,7 @@ fn parse_border_spacing(_context: &ParserContext, input: &mut Parser)
 
 pub use cssparser_macros::*;
 
-pub use tokenizer::{Token, PercentageValue, SourceLocation};
+pub use tokenizer::{Token, SourceLocation};
 pub use rules_and_declarations::{parse_important};
 pub use rules_and_declarations::{DeclarationParser, DeclarationListParser, parse_one_declaration};
 pub use rules_and_declarations::{RuleListParser, parse_one_rule};

src/parser.rs

@@ -6,7 +6,7 @@ use compact_cow_str::CompactCowStr;
 use std::ops::Range;
 use std::ascii::AsciiExt;
 use std::ops::BitOr;
-use tokenizer::{self, Token, PercentageValue, Tokenizer, SourceLocation};
+use tokenizer::{self, Token, Tokenizer, SourceLocation};
 
 
 /// A capture of the internal state of a `Parser` (including the position within the input),
@@ -529,7 +529,7 @@ impl<'i: 't, 't> Parser<'i, 't> {
     #[inline]
     pub fn expect_percentage(&mut self) -> Result<f32, BasicParseError<'i>> {
         match try!(self.next()) {
-            Token::Percentage(PercentageValue { unit_value, .. }) => Ok(unit_value),
+            Token::Percentage { unit_value, .. } => Ok(unit_value),
             t => Err(BasicParseError::UnexpectedToken(t))
         }
     }

src/serializer.rs

@@ -5,7 +5,7 @@
 use std::ascii::AsciiExt;
 use std::fmt::{self, Write};
 
-use super::{Token, PercentageValue};
+use super::Token;
 
 
 /// Trait for things the can serialize themselves in CSS syntax.
@@ -91,7 +91,7 @@ impl<'a> ToCss for Token<'a> {
             Token::Number { value, int_value, has_sign } => {
                 try!(write_numeric(value, int_value, has_sign, dest))
             }
-            Token::Percentage(PercentageValue { unit_value, int_value, has_sign }) => {
+            Token::Percentage { unit_value, int_value, has_sign } => {
                 try!(write_numeric(unit_value * 100., int_value, has_sign, dest));
                 try!(dest.write_str("%"));
             },
@@ -388,7 +388,7 @@ impl<'a> Token<'a> {
             Token::Delim('/') => DelimSlash,
             Token::Delim('*') => DelimAsterisk,
             Token::Number { .. } => Number,
-            Token::Percentage(_) => Percentage,
+            Token::Percentage { .. } => Percentage,
             Token::Dimension { .. } => Dimension,
             Token::WhiteSpace(_) => WhiteSpace,
             Token::Comment(_) => DelimSlash,

src/size_of_tests.rs

@@ -4,7 +4,7 @@
 
 use compact_cow_str::CompactCowStr;
 use std::borrow::Cow;
-use tokenizer::{Token, PercentageValue};
+use tokenizer::Token;
 
 #[macro_export]
 macro_rules! size_of_test {
@@ -33,6 +33,5 @@ macro_rules! size_of_test {
 
 // These assume 64-bit
 size_of_test!(token, Token, 32);
-size_of_test!(percentage_value, PercentageValue, 16);
 size_of_test!(std_cow_str, Cow<'static, str>, 32);
 size_of_test!(compact_cow_str, CompactCowStr, 16);

src/tests.rs

@@ -11,7 +11,7 @@ use rustc_serialize::json::{self, Json, ToJson};
 #[cfg(feature = "bench")]
 use self::test::Bencher;
 
-use super::{Parser, Delimiter, Token, PercentageValue, SourceLocation, ParseError,
+use super::{Parser, Delimiter, Token, SourceLocation, ParseError,
             DeclarationListParser, DeclarationParser, RuleListParser, BasicParseError,
             AtRuleType, AtRuleParser, QualifiedRuleParser, ParserInput,
             parse_one_declaration, parse_one_rule, parse_important,
@@ -802,7 +802,7 @@ fn one_component_value_to_json(token: Token, input: &mut Parser) -> Json {
             v.extend(numeric(value, int_value, has_sign));
             v
         }),
-        Token::Percentage(PercentageValue { unit_value, int_value, has_sign }) => Json::Array({
+        Token::Percentage { unit_value, int_value, has_sign } => Json::Array({
             let mut v = vec!["percentage".to_json()];
             v.extend(numeric(unit_value * 100., int_value, has_sign));
             v

src/tokenizer.rs

@@ -67,7 +67,17 @@ pub enum Token<'a> {
     },
 
     /// A [`<percentage-token>`](https://drafts.csswg.org/css-syntax/#percentage-token-diagram)
-    Percentage(PercentageValue),
+    Percentage {
+        /// Whether the number had a `+` or `-` sign.
+        has_sign: bool,
+
+        /// The value as a float, divided by 100 so that the nominal range is 0.0 to 1.0.
+        unit_value: f32,
+
+        /// If the origin source did not include a fractional part, the value as an integer.
+        /// It is **not** divided by 100.
+        int_value: Option<i32>,
+    },
 
     /// A [`<dimension-token>`](https://drafts.csswg.org/css-syntax/#dimension-token-diagram)
     Dimension {
@@ -190,20 +200,6 @@ impl<'a> Token<'a> {
 }
 
 
-/// The numeric value of `Percentage` tokens.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub struct PercentageValue {
-    /// The value as a float, divided by 100 so that the nominal range is 0.0 to 1.0.
-    pub unit_value: f32,
-
-    /// If the origin source did not include a fractional part, the value as an integer. It is **not** divided by 100.
-    pub int_value: Option<i32>,
-
-    /// Whether the number had a `+` or `-` sign.
-    pub has_sign: bool,
-}
-
-
 #[derive(Clone)]
 pub struct Tokenizer<'a> {
     input: &'a str,
@@ -864,11 +860,11 @@ fn consume_numeric<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> {
 
     if !tokenizer.is_eof() && tokenizer.next_byte_unchecked() == b'%' {
         tokenizer.advance(1);
-        return Percentage(PercentageValue {
+        return Percentage {
             unit_value: (value / 100.) as f32,
             int_value: int_value,
             has_sign: has_sign,
-        })
+        }
     }
     let value = value as f32;
     if is_ident_start(tokenizer) {