style: Improve #[derive(Parse)].

I want to do this so that I can get rid of Either<>. The reasons for getting rid
of either are multiple:

 * It doesn't generate as nice C++ code using cbindgen.
 * It isn't that nice to use either from Rust.
 * cbindgen has bugs with zero-sized types.

I started using this for ColorOrAuto and a few others, for now.

Differential Revision: https://phabricator.services.mozilla.com/D19844

components/style/values/specified/color.rs

@@ -11,7 +11,7 @@ use crate::parser::{Parse, ParserContext};
 #[cfg(feature = "gecko")]
 use crate::properties::longhands::system_colors::SystemColor;
 use crate::values::computed::{Color as ComputedColor, Context, ToComputedValue};
-use crate::values::generics::color::Color as GenericColor;
+use crate::values::generics::color::{Color as GenericColor, ColorOrAuto as GenericColorOrAuto};
 use crate::values::specified::calc::CalcNode;
 use cssparser::{AngleOrNumber, Color as CSSParserColor, Parser, Token, RGBA};
 use cssparser::{BasicParseErrorKind, NumberOrPercentage, ParseErrorKind};
@@ -469,3 +469,6 @@ impl Parse for ColorPropertyValue {
         Color::parse_quirky(context, input, AllowQuirks::Yes).map(ColorPropertyValue)
     }
 }
+
+/// auto | <color>
+pub type ColorOrAuto = GenericColorOrAuto<Color>;

components/style/values/specified/column.rs

@@ -4,25 +4,8 @@
 
 //! Specified types for the column properties.
 
-use crate::parser::{Parse, ParserContext};
 use crate::values::generics::column::ColumnCount as GenericColumnCount;
 use crate::values::specified::PositiveInteger;
-use cssparser::Parser;
-use style_traits::ParseError;
 
 /// A specified type for `column-count` values.
 pub type ColumnCount = GenericColumnCount<PositiveInteger>;
-
-impl Parse for ColumnCount {
-    fn parse<'i, 't>(
-        context: &ParserContext,
-        input: &mut Parser<'i, 't>,
-    ) -> Result<Self, ParseError<'i>> {
-        if input.try(|i| i.expect_ident_matching("auto")).is_ok() {
-            return Ok(GenericColumnCount::Auto);
-        }
-        Ok(GenericColumnCount::Integer(PositiveInteger::parse(
-            context, input,
-        )?))
-    }
-}

components/style/values/specified/flex.rs

@@ -4,29 +4,12 @@
 
 //! Specified types for CSS values related to flexbox.
 
-use crate::parser::{Parse, ParserContext};
 use crate::values::generics::flex::FlexBasis as GenericFlexBasis;
 use crate::values::specified::Size;
-use cssparser::Parser;
-use style_traits::ParseError;
 
 /// A specified value for the `flex-basis` property.
 pub type FlexBasis = GenericFlexBasis<Size>;
 
-impl Parse for FlexBasis {
-    fn parse<'i, 't>(
-        context: &ParserContext,
-        input: &mut Parser<'i, 't>,
-    ) -> Result<Self, ParseError<'i>> {
-        if let Ok(size) = input.try(|i| Size::parse(context, i)) {
-            return Ok(GenericFlexBasis::Size(size));
-        }
-        try_match_ident_ignore_ascii_case! { input,
-            "content" => Ok(GenericFlexBasis::Content),
-        }
-    }
-}
-
 impl FlexBasis {
     /// `auto`
     #[inline]

components/style/values/specified/font.rs

@@ -17,7 +17,7 @@ use crate::values::generics::font::{KeywordSize, VariationValue};
 use crate::values::generics::NonNegative;
 use crate::values::specified::length::{FontBaseSize, AU_PER_PT, AU_PER_PX};
 use crate::values::specified::{AllowQuirks, Angle, Integer, LengthPercentage};
-use crate::values::specified::{NoCalcLength, Number, Percentage};
+use crate::values::specified::{NoCalcLength, Number, NonNegativeNumber, Percentage};
 use crate::values::CustomIdent;
 use crate::Atom;
 use app_units::Au;
@@ -81,7 +81,7 @@ pub const MAX_FONT_WEIGHT: f32 = 1000.;
 /// A specified font-weight value.
 ///
 /// https://drafts.csswg.org/css-fonts-4/#propdef-font-weight
-#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToCss)]
+#[derive(Clone, Copy, Debug, MallocSizeOf, Parse, PartialEq, SpecifiedValueInfo, ToCss)]
 pub enum FontWeight {
     /// `<font-weight-absolute>`
     Absolute(AbsoluteFontWeight),
@@ -111,22 +111,6 @@ impl FontWeight {
     }
 }
 
-impl Parse for FontWeight {
-    fn parse<'i, 't>(
-        context: &ParserContext,
-        input: &mut Parser<'i, 't>,
-    ) -> Result<FontWeight, ParseError<'i>> {
-        if let Ok(absolute) = input.try(|input| AbsoluteFontWeight::parse(context, input)) {
-            return Ok(FontWeight::Absolute(absolute));
-        }
-
-        Ok(try_match_ident_ignore_ascii_case! { input,
-            "bolder" => FontWeight::Bolder,
-            "lighter" => FontWeight::Lighter,
-        })
-    }
-}
-
 impl ToComputedValue for FontWeight {
     type ComputedValue = computed::FontWeight;
 
@@ -335,7 +319,7 @@ impl SpecifiedFontStyle {
 }
 
 /// The specified value of the `font-style` property.
-#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToCss)]
+#[derive(Clone, Copy, Debug, MallocSizeOf, Parse, PartialEq, SpecifiedValueInfo, ToCss)]
 #[allow(missing_docs)]
 pub enum FontStyle {
     Specified(SpecifiedFontStyle),
@@ -368,20 +352,11 @@ impl ToComputedValue for FontStyle {
     }
 }
 
-impl Parse for FontStyle {
-    fn parse<'i, 't>(
-        context: &ParserContext,
-        input: &mut Parser<'i, 't>,
-    ) -> Result<Self, ParseError<'i>> {
-        Ok(FontStyle::Specified(SpecifiedFontStyle::parse(
-            context, input,
-        )?))
-    }
-}
-
 /// A value for the `font-stretch` property.
 ///
 /// https://drafts.csswg.org/css-fonts-4/#font-stretch-prop
+///
+/// TODO(emilio): We could derive Parse if we had NonNegativePercentage.
 #[allow(missing_docs)]
 #[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToCss)]
 #[repr(u8)]
@@ -628,13 +603,13 @@ impl Parse for FamilyName {
     }
 }
 
-#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToCss)]
+#[derive(Clone, Copy, Debug, MallocSizeOf, Parse, PartialEq, SpecifiedValueInfo, ToCss)]
 /// Preserve the readability of text when font fallback occurs
 pub enum FontSizeAdjust {
     /// None variant
     None,
     /// Number variant
-    Number(Number),
+    Number(NonNegativeNumber),
     /// system font
     #[css(skip)]
     System(SystemFont),
@@ -657,7 +632,9 @@ impl ToComputedValue for FontSizeAdjust {
         match *self {
             FontSizeAdjust::None => computed::FontSizeAdjust::None,
             FontSizeAdjust::Number(ref n) => {
-                computed::FontSizeAdjust::Number(n.to_computed_value(context))
+                // The computed version handles clamping of animated values
+                // itself.
+                computed::FontSizeAdjust::Number(n.to_computed_value(context).0)
             },
             FontSizeAdjust::System(_) => self.compute_system(context),
         }
@@ -666,32 +643,13 @@ impl ToComputedValue for FontSizeAdjust {
     fn from_computed_value(computed: &computed::FontSizeAdjust) -> Self {
         match *computed {
             computed::FontSizeAdjust::None => FontSizeAdjust::None,
-            computed::FontSizeAdjust::Number(ref v) => {
-                FontSizeAdjust::Number(Number::from_computed_value(v))
+            computed::FontSizeAdjust::Number(v) => {
+                FontSizeAdjust::Number(NonNegativeNumber::from_computed_value(&v.into()))
             },
         }
     }
 }
 
-impl Parse for FontSizeAdjust {
-    /// none | <number>
-    fn parse<'i, 't>(
-        context: &ParserContext,
-        input: &mut Parser<'i, 't>,
-    ) -> Result<FontSizeAdjust, ParseError<'i>> {
-        if input
-            .try(|input| input.expect_ident_matching("none"))
-            .is_ok()
-        {
-            return Ok(FontSizeAdjust::None);
-        }
-
-        Ok(FontSizeAdjust::Number(Number::parse_non_negative(
-            context, input,
-        )?))
-    }
-}
-
 /// Additional information for specified keyword-derived font sizes.
 pub type KeywordInfo = generics::KeywordInfo<NonNegativeLength>;
 

components/style/values/specified/image.rs

@@ -305,7 +305,7 @@ impl Gradient {
     ) -> Result<Self, ParseError<'i>> {
         type Point = GenericPosition<Component<X>, Component<Y>>;
 
-        #[derive(Clone, Copy)]
+        #[derive(Clone, Copy, Parse)]
         enum Component<S> {
             Center,
             Number(NumberOrPercentage),
@@ -408,22 +408,6 @@ impl Gradient {
             }
         }
 
-        impl<S: Parse> Parse for Component<S> {
-            fn parse<'i, 't>(
-                context: &ParserContext,
-                input: &mut Parser<'i, 't>,
-            ) -> Result<Self, ParseError<'i>> {
-                if let Ok(side) = input.try(|i| S::parse(context, i)) {
-                    return Ok(Component::Side(side));
-                }
-                if let Ok(number) = input.try(|i| NumberOrPercentage::parse(context, i)) {
-                    return Ok(Component::Number(number));
-                }
-                input.try(|i| i.expect_ident_matching("center"))?;
-                Ok(Component::Center)
-            }
-        }
-
         let ident = input.expect_ident_cloned()?;
         input.expect_comma()?;
 

components/style/values/specified/mod.rs

@@ -42,7 +42,7 @@ pub use self::box_::{Clear, Float, Overflow, OverflowAnchor};
 pub use self::box_::{OverflowClipBox, OverscrollBehavior, Perspective, Resize};
 pub use self::box_::{ScrollSnapAlign, ScrollSnapType};
 pub use self::box_::{TouchAction, TransitionProperty, VerticalAlign, WillChange};
-pub use self::color::{Color, ColorPropertyValue, RGBAColor};
+pub use self::color::{Color, ColorOrAuto, ColorPropertyValue, RGBAColor};
 pub use self::column::ColumnCount;
 pub use self::counters::{Content, ContentItem, CounterIncrement, CounterReset};
 pub use self::easing::TimingFunction;
@@ -87,7 +87,7 @@ pub use self::transform::{Rotate, Scale, Transform};
 pub use self::transform::{TransformOrigin, TransformStyle, Translate};
 #[cfg(feature = "gecko")]
 pub use self::ui::CursorImage;
-pub use self::ui::{ColorOrAuto, Cursor, MozForceBrokenImageIcon, UserSelect};
+pub use self::ui::{Cursor, MozForceBrokenImageIcon, UserSelect};
 pub use super::generics::grid::GridTemplateComponent as GenericGridTemplateComponent;
 
 #[cfg(feature = "gecko")]

components/style/values/specified/svg.rs

@@ -23,31 +23,6 @@ pub type SVGPaint = generic::SVGPaint<Color, SpecifiedUrl>;
 /// Specified SVG Paint Kind value
 pub type SVGPaintKind = generic::SVGPaintKind<Color, SpecifiedUrl>;
 
-#[cfg(feature = "gecko")]
-fn is_context_value_enabled() -> bool {
-    // The prefs can only be mutated on the main thread, so it is safe
-    // to read whenever we are on the main thread or the main thread is
-    // blocked.
-    use crate::gecko_bindings::structs::mozilla;
-    unsafe { mozilla::StaticPrefs_sVarCache_gfx_font_rendering_opentype_svg_enabled }
-}
-#[cfg(not(feature = "gecko"))]
-fn is_context_value_enabled() -> bool {
-    false
-}
-
-fn parse_context_value<'i, 't, T>(
-    input: &mut Parser<'i, 't>,
-    value: T,
-) -> Result<T, ParseError<'i>> {
-    if !is_context_value_enabled() {
-        return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));
-    }
-
-    input.expect_ident_matching("context-value")?;
-    Ok(value)
-}
-
 /// A value of <length> | <percentage> | <number> for stroke-dashoffset.
 /// <https://www.w3.org/TR/SVG11/painting.html#StrokeProperties>
 pub type SvgLengthPercentageOrNumber =
@@ -56,18 +31,6 @@ pub type SvgLengthPercentageOrNumber =
 /// <length> | <percentage> | <number> | context-value
 pub type SVGLength = generic::SVGLength<SvgLengthPercentageOrNumber>;
 
-impl Parse for SVGLength {
-    fn parse<'i, 't>(
-        context: &ParserContext,
-        input: &mut Parser<'i, 't>,
-    ) -> Result<Self, ParseError<'i>> {
-        input
-            .try(|i| SvgLengthPercentageOrNumber::parse(context, i))
-            .map(Into::into)
-            .or_else(|_| parse_context_value(input, generic::SVGLength::ContextValue))
-    }
-}
-
 impl From<SvgLengthPercentageOrNumber> for SVGLength {
     fn from(length: SvgLengthPercentageOrNumber) -> Self {
         generic::SVGLength::Length(length)
@@ -82,18 +45,6 @@ pub type NonNegativeSvgLengthPercentageOrNumber =
 /// A non-negative version of SVGLength.
 pub type SVGWidth = generic::SVGLength<NonNegativeSvgLengthPercentageOrNumber>;
 
-impl Parse for SVGWidth {
-    fn parse<'i, 't>(
-        context: &ParserContext,
-        input: &mut Parser<'i, 't>,
-    ) -> Result<Self, ParseError<'i>> {
-        input
-            .try(|i| NonNegativeSvgLengthPercentageOrNumber::parse(context, i))
-            .map(Into::into)
-            .or_else(|_| parse_context_value(input, generic::SVGLength::ContextValue))
-    }
-}
-
 impl From<NonNegativeSvgLengthPercentageOrNumber> for SVGWidth {
     fn from(length: NonNegativeSvgLengthPercentageOrNumber) -> Self {
         generic::SVGLength::Length(length)
@@ -113,11 +64,14 @@ impl Parse for SVGStrokeDashArray {
                 NonNegativeSvgLengthPercentageOrNumber::parse(context, i)
             })
         }) {
-            Ok(generic::SVGStrokeDashArray::Values(values))
-        } else if let Ok(_) = input.try(|i| i.expect_ident_matching("none")) {
-            Ok(generic::SVGStrokeDashArray::Values(vec![]))
-        } else {
-            parse_context_value(input, generic::SVGStrokeDashArray::ContextValue)
+            return Ok(generic::SVGStrokeDashArray::Values(values))
+        }
+
+        try_match_ident_ignore_ascii_case! { input,
+            "context-value" if generic::is_context_value_enabled(context) => {
+                Ok(generic::SVGStrokeDashArray::ContextValue)
+            },
+            "none" => Ok(generic::SVGStrokeDashArray::Values(vec![])),
         }
     }
 }
@@ -125,22 +79,6 @@ impl Parse for SVGStrokeDashArray {
 /// <opacity-value> | context-fill-opacity | context-stroke-opacity
 pub type SVGOpacity = generic::SVGOpacity<Opacity>;
 
-impl Parse for SVGOpacity {
-    fn parse<'i, 't>(
-        context: &ParserContext,
-        input: &mut Parser<'i, 't>,
-    ) -> Result<Self, ParseError<'i>> {
-        if let Ok(opacity) = input.try(|i| Opacity::parse(context, i)) {
-            return Ok(generic::SVGOpacity::Opacity(opacity));
-        }
-
-        try_match_ident_ignore_ascii_case! { input,
-            "context-fill-opacity" => Ok(generic::SVGOpacity::ContextFillOpacity),
-            "context-stroke-opacity" => Ok(generic::SVGOpacity::ContextStrokeOpacity),
-        }
-    }
-}
-
 /// The specified value for a single CSS paint-order property.
 #[repr(u8)]
 #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, ToCss)]

components/style/values/specified/text.rs

@@ -419,7 +419,7 @@ pub enum TextAlignKeyword {
 
 /// Specified value of text-align property.
 #[cfg_attr(feature = "gecko", derive(MallocSizeOf))]
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, SpecifiedValueInfo, ToCss)]
+#[derive(Clone, Copy, Debug, Eq, Hash, Parse, PartialEq, SpecifiedValueInfo, ToCss)]
 pub enum TextAlign {
     /// Keyword value of text-align property.
     Keyword(TextAlignKeyword),
@@ -435,27 +435,6 @@ pub enum TextAlign {
     MozCenterOrInherit,
 }
 
-impl Parse for TextAlign {
-    fn parse<'i, 't>(
-        _context: &ParserContext,
-        input: &mut Parser<'i, 't>,
-    ) -> Result<Self, ParseError<'i>> {
-        // MozCenterOrInherit cannot be parsed, only set directly on the elements
-        if let Ok(key) = input.try(TextAlignKeyword::parse) {
-            return Ok(TextAlign::Keyword(key));
-        }
-        #[cfg(feature = "gecko")]
-        {
-            input.expect_ident_matching("match-parent")?;
-            return Ok(TextAlign::MatchParent);
-        }
-        #[cfg(feature = "servo")]
-        {
-            return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));
-        }
-    }
-}
-
 impl TextAlign {
     /// Convert an enumerated value coming from Gecko to a `TextAlign`.
     #[cfg(feature = "gecko")]

components/style/values/specified/transform.rs

@@ -231,7 +231,7 @@ impl Parse for Transform {
 }
 
 /// The specified value of a component of a CSS `<transform-origin>`.
-#[derive(Clone, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToCss)]
+#[derive(Clone, Debug, MallocSizeOf, PartialEq, Parse, SpecifiedValueInfo, ToCss)]
 pub enum OriginComponent<S> {
     /// `center`
     Center,
@@ -295,25 +295,6 @@ impl Parse for TransformOrigin {
     }
 }
 
-impl<S> Parse for OriginComponent<S>
-where
-    S: Parse,
-{
-    fn parse<'i, 't>(
-        context: &ParserContext,
-        input: &mut Parser<'i, 't>,
-    ) -> Result<Self, ParseError<'i>> {
-        if input.try(|i| i.expect_ident_matching("center")).is_ok() {
-            return Ok(OriginComponent::Center);
-        }
-        if let Ok(lp) = input.try(|i| LengthPercentage::parse(context, i)) {
-            return Ok(OriginComponent::Length(lp));
-        }
-        let keyword = S::parse(context, input)?;
-        Ok(OriginComponent::Side(keyword))
-    }
-}
-
 impl<S> ToComputedValue for OriginComponent<S>
 where
     S: Side,

components/style/values/specified/ui.rs

@@ -9,14 +9,10 @@ use crate::values::generics::ui as generics;
 use crate::values::specified::color::Color;
 use crate::values::specified::url::SpecifiedImageUrl;
 use crate::values::specified::Number;
-use crate::values::{Auto, Either};
 use cssparser::Parser;
 use std::fmt::{self, Write};
 use style_traits::{CssWriter, ParseError, StyleParseErrorKind, ToCss};
 
-/// auto | <color>
-pub type ColorOrAuto = Either<Color, Auto>;
-
 /// A specified value for the `cursor` property.
 pub type Cursor = generics::Cursor<CursorImage>;