Bug 1920496 - Track omitted alpha values for relative colors. r=layout-reviewers,emilio

When an alpha component is omitted, instead of defaulting to opaque,
colors with an origin color used the alpha from there.

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

servo/components/style/color/color_function.rs

@@ -373,105 +373,63 @@ impl style_traits::ToCss for ColorFunction {
             false
         };
 
+        macro_rules! serialize_alpha {
+            ($alpha_component:expr) => {{
+                if !is_opaque && !matches!($alpha_component, ColorComponent::AlphaOmitted) {
+                    dest.write_str(" / ")?;
+                    $alpha_component.to_css(dest)?;
+                }
+            }};
+        }
+
+        macro_rules! serialize_components {
+            ($c0:expr, $c1:expr, $c2:expr) => {{
+                debug_assert!(!matches!($c0, ColorComponent::AlphaOmitted));
+                debug_assert!(!matches!($c1, ColorComponent::AlphaOmitted));
+                debug_assert!(!matches!($c2, ColorComponent::AlphaOmitted));
+
+                $c0.to_css(dest)?;
+                dest.write_str(" ")?;
+                $c1.to_css(dest)?;
+                dest.write_str(" ")?;
+                $c2.to_css(dest)?;
+            }};
+        }
+
         match self {
-            Self::Rgb(_, r, g, b, alpha) => {
-                r.to_css(dest)?;
-                dest.write_str(" ")?;
-                g.to_css(dest)?;
-                dest.write_str(" ")?;
-                b.to_css(dest)?;
-
-                if !is_opaque {
-                    dest.write_str(" / ")?;
-                    alpha.to_css(dest)?;
-                }
+            Self::Rgb(_, c0, c1, c2, alpha) => {
+                serialize_components!(c0, c1, c2);
+                serialize_alpha!(alpha);
             },
-            Self::Hsl(_, h, s, l, alpha) => {
-                h.to_css(dest)?;
-                dest.write_str(" ")?;
-                s.to_css(dest)?;
-                dest.write_str(" ")?;
-                l.to_css(dest)?;
-
-                if !is_opaque {
-                    dest.write_str(" / ")?;
-                    alpha.to_css(dest)?;
-                }
+            Self::Hsl(_, c0, c1, c2, alpha) => {
+                serialize_components!(c0, c1, c2);
+                serialize_alpha!(alpha);
             },
-            Self::Hwb(_, h, w, b, alpha) => {
-                h.to_css(dest)?;
-                dest.write_str(" ")?;
-                w.to_css(dest)?;
-                dest.write_str(" ")?;
-                b.to_css(dest)?;
-
-                if !is_opaque {
-                    dest.write_str(" / ")?;
-                    alpha.to_css(dest)?;
-                }
+            Self::Hwb(_, c0, c1, c2, alpha) => {
+                serialize_components!(c0, c1, c2);
+                serialize_alpha!(alpha);
             },
-            Self::Lab(_, l, a, b, alpha) => {
-                l.to_css(dest)?;
-                dest.write_str(" ")?;
-                a.to_css(dest)?;
-                dest.write_str(" ")?;
-                b.to_css(dest)?;
-
-                if !is_opaque {
-                    dest.write_str(" / ")?;
-                    alpha.to_css(dest)?;
-                }
+            Self::Lab(_, c0, c1, c2, alpha) => {
+                serialize_components!(c0, c1, c2);
+                serialize_alpha!(alpha);
             },
-            Self::Lch(_, l, c, h, alpha) => {
-                l.to_css(dest)?;
-                dest.write_str(" ")?;
-                c.to_css(dest)?;
-                dest.write_str(" ")?;
-                h.to_css(dest)?;
-
-                if !is_opaque {
-                    dest.write_str(" / ")?;
-                    alpha.to_css(dest)?;
-                }
+            Self::Lch(_, c0, c1, c2, alpha) => {
+                serialize_components!(c0, c1, c2);
+                serialize_alpha!(alpha);
             },
-            Self::Oklab(_, l, a, b, alpha) => {
-                l.to_css(dest)?;
-                dest.write_str(" ")?;
-                a.to_css(dest)?;
-                dest.write_str(" ")?;
-                b.to_css(dest)?;
-
-                if !is_opaque {
-                    dest.write_str(" / ")?;
-                    alpha.to_css(dest)?;
-                }
+            Self::Oklab(_, c0, c1, c2, alpha) => {
+                serialize_components!(c0, c1, c2);
+                serialize_alpha!(alpha);
             },
-            Self::Oklch(_, l, c, h, alpha) => {
-                l.to_css(dest)?;
-                dest.write_str(" ")?;
-                c.to_css(dest)?;
-                dest.write_str(" ")?;
-                h.to_css(dest)?;
-
-                if !is_opaque {
-                    dest.write_str(" / ")?;
-                    alpha.to_css(dest)?;
-                }
+            Self::Oklch(_, c0, c1, c2, alpha) => {
+                serialize_components!(c0, c1, c2);
+                serialize_alpha!(alpha);
             },
-            Self::Color(_, r, g, b, alpha, color_space) => {
+            Self::Color(_, c0, c1, c2, alpha, color_space) => {
                 color_space.to_css(dest)?;
                 dest.write_str(" ")?;
-
-                r.to_css(dest)?;
-                dest.write_str(" ")?;
-                g.to_css(dest)?;
-                dest.write_str(" ")?;
-                b.to_css(dest)?;
-
-                if !is_opaque {
-                    dest.write_str(" / ")?;
-                    alpha.to_css(dest)?;
-                }
+                serialize_components!(c0, c1, c2);
+                serialize_alpha!(alpha);
             },
         }
 

servo/components/style/color/component.rs

@@ -17,7 +17,7 @@ use crate::{
         specified::calc::{CalcNode as SpecifiedCalcNode, Leaf as SpecifiedLeaf},
     },
 };
-use cssparser::{Parser, Token};
+use cssparser::{color::OPAQUE, Parser, Token};
 use style_traits::{ParseError, StyleParseErrorKind, ToCss};
 
 /// A single color component.
@@ -29,6 +29,8 @@ pub enum ColorComponent<ValueType> {
     Value(ValueType),
     /// A calc() value.
     Calc(Box<SpecifiedCalcNode>),
+    /// Used when alpha components are not specified.
+    AlphaOmitted,
 }
 
 impl<ValueType> ColorComponent<ValueType> {
@@ -65,6 +67,7 @@ impl<ValueType: ColorComponentType> ColorComponent<ValueType> {
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         allow_none: bool,
+        allowed_channel_keywords: &[ChannelKeyword],
     ) -> Result<Self, ParseError<'i>> {
         let location = input.current_source_location();
 
@@ -73,13 +76,16 @@ impl<ValueType: ColorComponentType> ColorComponent<ValueType> {
                 Ok(ColorComponent::None)
             },
             ref t @ Token::Ident(ref ident) => {
-                if let Ok(channel_keyword) = ChannelKeyword::from_ident(ident) {
-                    Ok(ColorComponent::Calc(Box::new(SpecifiedCalcNode::Leaf(
-                        SpecifiedLeaf::ColorComponent(channel_keyword),
-                    ))))
-                } else {
-                    Err(location.new_unexpected_token_error(t.clone()))
+                let Ok(channel_keyword) = ChannelKeyword::from_ident(ident) else {
+                    return Err(location.new_unexpected_token_error(t.clone()));
+                };
+
+                if !allowed_channel_keywords.contains(&channel_keyword) {
+                    return Err(location.new_unexpected_token_error(t.clone()));
                 }
+
+                let node = SpecifiedCalcNode::Leaf(SpecifiedLeaf::ColorComponent(channel_keyword));
+                Ok(ColorComponent::Calc(Box::new(node)))
             },
             Token::Function(ref name) => {
                 let function = SpecifiedCalcNode::math_function(context, name, location)?;
@@ -90,6 +96,31 @@ impl<ValueType: ColorComponentType> ColorComponent<ValueType> {
                 };
                 let mut node = SpecifiedCalcNode::parse(context, input, function, units)?;
 
+                if rcs_enabled() {
+                    // Check that we only have allowed channel_keywords.
+                    // TODO(tlouw): Optimize this to fail when we hit the first error, or even
+                    //              better, do the validation during parsing the calc node.
+                    let mut is_valid = true;
+                    node.visit_depth_first(|node| {
+                        let SpecifiedCalcNode::Leaf(leaf) = node else {
+                            return;
+                        };
+
+                        let SpecifiedLeaf::ColorComponent(channel_keyword) = leaf else {
+                            return;
+                        };
+
+                        if !allowed_channel_keywords.contains(channel_keyword) {
+                            is_valid = false;
+                        }
+                    });
+                    if !is_valid {
+                        return Err(
+                            location.new_custom_error(StyleParseErrorKind::UnspecifiedError)
+                        );
+                    }
+                }
+
                 // TODO(tlouw): We only have to simplify the node when we have to store it, but we
                 //              only know if we have to store it much later when the whole color
                 //              can't be resolved to absolute at which point the calc nodes are
@@ -133,6 +164,17 @@ impl<ValueType: ColorComponentType> ColorComponent<ValueType> {
 
                 Some(ValueType::try_from_leaf(&resolved_leaf)?)
             },
+            ColorComponent::AlphaOmitted => {
+                if let Some(origin_color) = origin_color {
+                    // <https://drafts.csswg.org/css-color-5/#rcs-intro>
+                    // If the alpha value of the relative color is omitted, it defaults to that of
+                    // the origin color (rather than defaulting to 100%, as it does in the absolute
+                    // syntax).
+                    origin_color.alpha().map(ValueType::from_value)
+                } else {
+                    Some(ValueType::from_value(OPAQUE))
+                }
+            },
         })
     }
 }
@@ -159,6 +201,9 @@ impl<ValueType: ToCss> ToCss for ColorComponent<ValueType> {
                     node.to_css(dest)?;
                 }
             },
+            ColorComponent::AlphaOmitted => {
+                debug_assert!(false, "can't serialize an omitted alpha component");
+            },
         }
 
         Ok(())

servo/components/style/color/parsing.rs

@@ -64,6 +64,48 @@ pub enum ChannelKeyword {
     Z,
 }
 
+const RGB_CHANNEL_KEYWORDS: &[ChannelKeyword] = &[
+    ChannelKeyword::R,
+    ChannelKeyword::G,
+    ChannelKeyword::B,
+    ChannelKeyword::Alpha,
+];
+
+const HSL_CHANNEL_KEYWORDS: &[ChannelKeyword] = &[
+    ChannelKeyword::H,
+    ChannelKeyword::S,
+    ChannelKeyword::L,
+    ChannelKeyword::Alpha,
+];
+
+const HWB_CHANNEL_KEYWORDS: &[ChannelKeyword] = &[
+    ChannelKeyword::H,
+    ChannelKeyword::W,
+    ChannelKeyword::B,
+    ChannelKeyword::Alpha,
+];
+
+const LAB_CHANNEL_KEYWORDS: &[ChannelKeyword] = &[
+    ChannelKeyword::L,
+    ChannelKeyword::A,
+    ChannelKeyword::B,
+    ChannelKeyword::Alpha,
+];
+
+const LCH_CHANNEL_KEYWORDS: &[ChannelKeyword] = &[
+    ChannelKeyword::L,
+    ChannelKeyword::C,
+    ChannelKeyword::H,
+    ChannelKeyword::Alpha,
+];
+
+const XYZ_CHANNEL_KEYWORDS: &[ChannelKeyword] = &[
+    ChannelKeyword::X,
+    ChannelKeyword::Y,
+    ChannelKeyword::Z,
+    ChannelKeyword::Alpha,
+];
+
 /// Return the named color with the given name.
 ///
 /// Matching is case-insensitive in the ASCII range.
@@ -174,7 +216,7 @@ fn parse_rgb<'i, 't>(
     arguments: &mut Parser<'i, 't>,
     origin_color: Option<SpecifiedColor>,
 ) -> Result<ColorFunction, ParseError<'i>> {
-    let maybe_red = parse_number_or_percentage(context, arguments, true)?;
+    let maybe_red = parse_number_or_percentage(context, arguments, true, RGB_CHANNEL_KEYWORDS)?;
 
     // If the first component is not "none" and is followed by a comma, then we
     // are parsing the legacy syntax.  Legacy syntax also doesn't support an
@@ -184,26 +226,26 @@ fn parse_rgb<'i, 't>(
         arguments.try_parse(|p| p.expect_comma()).is_ok();
 
     Ok(if is_legacy_syntax {
-        let (green, blue) = if maybe_red.is_percentage() {
-            let green = parse_percentage(context, arguments, false)?;
+        let (green, blue) = if maybe_red.could_be_percentage() {
+            let green = parse_percentage(context, arguments, false, RGB_CHANNEL_KEYWORDS)?;
             arguments.expect_comma()?;
-            let blue = parse_percentage(context, arguments, false)?;
+            let blue = parse_percentage(context, arguments, false, RGB_CHANNEL_KEYWORDS)?;
             (green, blue)
         } else {
-            let green = parse_number(context, arguments, false)?;
+            let green = parse_number(context, arguments, false, RGB_CHANNEL_KEYWORDS)?;
             arguments.expect_comma()?;
-            let blue = parse_number(context, arguments, false)?;
+            let blue = parse_number(context, arguments, false, RGB_CHANNEL_KEYWORDS)?;
             (green, blue)
         };
 
-        let alpha = parse_legacy_alpha(context, arguments)?;
+        let alpha = parse_legacy_alpha(context, arguments, RGB_CHANNEL_KEYWORDS)?;
 
         ColorFunction::Rgb(origin_color, maybe_red, green, blue, alpha)
     } else {
-        let green = parse_number_or_percentage(context, arguments, true)?;
-        let blue = parse_number_or_percentage(context, arguments, true)?;
+        let green = parse_number_or_percentage(context, arguments, true, RGB_CHANNEL_KEYWORDS)?;
+        let blue = parse_number_or_percentage(context, arguments, true, RGB_CHANNEL_KEYWORDS)?;
 
-        let alpha = parse_modern_alpha(context, arguments)?;
+        let alpha = parse_modern_alpha(context, arguments, RGB_CHANNEL_KEYWORDS)?;
 
         ColorFunction::Rgb(origin_color, maybe_red, green, blue, alpha)
     })
@@ -218,7 +260,7 @@ fn parse_hsl<'i, 't>(
     arguments: &mut Parser<'i, 't>,
     origin_color: Option<SpecifiedColor>,
 ) -> Result<ColorFunction, ParseError<'i>> {
-    let hue = parse_number_or_angle(context, arguments, true)?;
+    let hue = parse_number_or_angle(context, arguments, true, HSL_CHANNEL_KEYWORDS)?;
 
     // If the hue is not "none" and is followed by a comma, then we are parsing
     // the legacy syntax. Legacy syntax also doesn't support an origin color.
@@ -227,15 +269,16 @@ fn parse_hsl<'i, 't>(
         arguments.try_parse(|p| p.expect_comma()).is_ok();
 
     let (saturation, lightness, alpha) = if is_legacy_syntax {
-        let saturation = parse_percentage(context, arguments, false)?;
+        let saturation = parse_percentage(context, arguments, false, HSL_CHANNEL_KEYWORDS)?;
         arguments.expect_comma()?;
-        let lightness = parse_percentage(context, arguments, false)?;
-        let alpha = parse_legacy_alpha(context, arguments)?;
+        let lightness = parse_percentage(context, arguments, false, HSL_CHANNEL_KEYWORDS)?;
+        let alpha = parse_legacy_alpha(context, arguments, HSL_CHANNEL_KEYWORDS)?;
         (saturation, lightness, alpha)
     } else {
-        let saturation = parse_number_or_percentage(context, arguments, true)?;
-        let lightness = parse_number_or_percentage(context, arguments, true)?;
-        let alpha = parse_modern_alpha(context, arguments)?;
+        let saturation =
+            parse_number_or_percentage(context, arguments, true, HSL_CHANNEL_KEYWORDS)?;
+        let lightness = parse_number_or_percentage(context, arguments, true, HSL_CHANNEL_KEYWORDS)?;
+        let alpha = parse_modern_alpha(context, arguments, HSL_CHANNEL_KEYWORDS)?;
         (saturation, lightness, alpha)
     };
 
@@ -257,11 +300,11 @@ fn parse_hwb<'i, 't>(
     arguments: &mut Parser<'i, 't>,
     origin_color: Option<SpecifiedColor>,
 ) -> Result<ColorFunction, ParseError<'i>> {
-    let hue = parse_number_or_angle(context, arguments, true)?;
-    let whiteness = parse_number_or_percentage(context, arguments, true)?;
-    let blackness = parse_number_or_percentage(context, arguments, true)?;
+    let hue = parse_number_or_angle(context, arguments, true, HWB_CHANNEL_KEYWORDS)?;
+    let whiteness = parse_number_or_percentage(context, arguments, true, HWB_CHANNEL_KEYWORDS)?;
+    let blackness = parse_number_or_percentage(context, arguments, true, HWB_CHANNEL_KEYWORDS)?;
 
-    let alpha = parse_modern_alpha(context, arguments)?;
+    let alpha = parse_modern_alpha(context, arguments, HWB_CHANNEL_KEYWORDS)?;
 
     Ok(ColorFunction::Hwb(
         origin_color,
@@ -287,11 +330,11 @@ fn parse_lab_like<'i, 't>(
     origin_color: Option<SpecifiedColor>,
     into_color: IntoLabFn<ColorFunction>,
 ) -> Result<ColorFunction, ParseError<'i>> {
-    let lightness = parse_number_or_percentage(context, arguments, true)?;
-    let a = parse_number_or_percentage(context, arguments, true)?;
-    let b = parse_number_or_percentage(context, arguments, true)?;
+    let lightness = parse_number_or_percentage(context, arguments, true, LAB_CHANNEL_KEYWORDS)?;
+    let a = parse_number_or_percentage(context, arguments, true, LAB_CHANNEL_KEYWORDS)?;
+    let b = parse_number_or_percentage(context, arguments, true, LAB_CHANNEL_KEYWORDS)?;
 
-    let alpha = parse_modern_alpha(context, arguments)?;
+    let alpha = parse_modern_alpha(context, arguments, LAB_CHANNEL_KEYWORDS)?;
 
     Ok(into_color(origin_color, lightness, a, b, alpha))
 }
@@ -311,11 +354,11 @@ fn parse_lch_like<'i, 't>(
     origin_color: Option<SpecifiedColor>,
     into_color: IntoLchFn<ColorFunction>,
 ) -> Result<ColorFunction, ParseError<'i>> {
-    let lightness = parse_number_or_percentage(context, arguments, true)?;
-    let chroma = parse_number_or_percentage(context, arguments, true)?;
-    let hue = parse_number_or_angle(context, arguments, true)?;
+    let lightness = parse_number_or_percentage(context, arguments, true, LCH_CHANNEL_KEYWORDS)?;
+    let chroma = parse_number_or_percentage(context, arguments, true, LCH_CHANNEL_KEYWORDS)?;
+    let hue = parse_number_or_angle(context, arguments, true, LCH_CHANNEL_KEYWORDS)?;
 
-    let alpha = parse_modern_alpha(context, arguments)?;
+    let alpha = parse_modern_alpha(context, arguments, LCH_CHANNEL_KEYWORDS)?;
 
     Ok(into_color(origin_color, lightness, chroma, hue, alpha))
 }
@@ -329,11 +372,21 @@ fn parse_color_with_color_space<'i, 't>(
 ) -> Result<ColorFunction, ParseError<'i>> {
     let color_space = PredefinedColorSpace::parse(arguments)?;
 
-    let c1 = parse_number_or_percentage(context, arguments, true)?;
-    let c2 = parse_number_or_percentage(context, arguments, true)?;
-    let c3 = parse_number_or_percentage(context, arguments, true)?;
+    let allowed_channel_keywords = match color_space {
+        PredefinedColorSpace::Srgb |
+        PredefinedColorSpace::SrgbLinear |
+        PredefinedColorSpace::DisplayP3 |
+        PredefinedColorSpace::A98Rgb |
+        PredefinedColorSpace::ProphotoRgb |
+        PredefinedColorSpace::Rec2020 => RGB_CHANNEL_KEYWORDS,
+        PredefinedColorSpace::XyzD50 | PredefinedColorSpace::XyzD65 => XYZ_CHANNEL_KEYWORDS,
+    };
 
-    let alpha = parse_modern_alpha(context, arguments)?;
+    let c1 = parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)?;
+    let c2 = parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)?;
+    let c3 = parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)?;
+
+    let alpha = parse_modern_alpha(context, arguments, allowed_channel_keywords)?;
 
     Ok(ColorFunction::Color(
         origin_color,
@@ -483,8 +536,9 @@ fn parse_number_or_angle<'i, 't>(
     context: &ParserContext,
     input: &mut Parser<'i, 't>,
     allow_none: bool,
+    allowed_channel_keywords: &[ChannelKeyword],
 ) -> Result<ColorComponent<NumberOrAngle>, ParseError<'i>> {
-    ColorComponent::parse(context, input, allow_none)
+    ColorComponent::parse(context, input, allow_none, allowed_channel_keywords)
 }
 
 /// Parse a `<percentage>` value.
@@ -492,12 +546,18 @@ fn parse_percentage<'i, 't>(
     context: &ParserContext,
     input: &mut Parser<'i, 't>,
     allow_none: bool,
+    allowed_channel_keywords: &[ChannelKeyword],
 ) -> Result<ColorComponent<NumberOrPercentage>, ParseError<'i>> {
     let location = input.current_source_location();
 
-    let value = ColorComponent::<NumberOrPercentage>::parse(context, input, allow_none)?;
+    let value = ColorComponent::<NumberOrPercentage>::parse(
+        context,
+        input,
+        allow_none,
+        allowed_channel_keywords,
+    )?;
 
-    if !value.is_percentage() {
+    if !value.could_be_percentage() {
         return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError));
     }
 
@@ -509,12 +569,18 @@ fn parse_number<'i, 't>(
     context: &ParserContext,
     input: &mut Parser<'i, 't>,
     allow_none: bool,
+    allowed_channel_keywords: &[ChannelKeyword],
 ) -> Result<ColorComponent<NumberOrPercentage>, ParseError<'i>> {
     let location = input.current_source_location();
 
-    let value = ColorComponent::<NumberOrPercentage>::parse(context, input, allow_none)?;
+    let value = ColorComponent::<NumberOrPercentage>::parse(
+        context,
+        input,
+        allow_none,
+        allowed_channel_keywords,
+    )?;
 
-    if !value.is_number() {
+    if !value.could_be_number() {
         return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError));
     }
 
@@ -526,40 +592,43 @@ fn parse_number_or_percentage<'i, 't>(
     context: &ParserContext,
     input: &mut Parser<'i, 't>,
     allow_none: bool,
+    allowed_channel_keywords: &[ChannelKeyword],
 ) -> Result<ColorComponent<NumberOrPercentage>, ParseError<'i>> {
-    ColorComponent::parse(context, input, allow_none)
+    ColorComponent::parse(context, input, allow_none, allowed_channel_keywords)
 }
 
 fn parse_legacy_alpha<'i, 't>(
     context: &ParserContext,
     arguments: &mut Parser<'i, 't>,
+    allowed_channel_keywords: &[ChannelKeyword],
 ) -> Result<ColorComponent<NumberOrPercentage>, ParseError<'i>> {
     if !arguments.is_exhausted() {
         arguments.expect_comma()?;
-        parse_number_or_percentage(context, arguments, false)
+        parse_number_or_percentage(context, arguments, false, allowed_channel_keywords)
     } else {
-        Ok(ColorComponent::Value(NumberOrPercentage::Number(OPAQUE)))
+        Ok(ColorComponent::AlphaOmitted)
     }
 }
 
 fn parse_modern_alpha<'i, 't>(
     context: &ParserContext,
     arguments: &mut Parser<'i, 't>,
+    allowed_channel_keywords: &[ChannelKeyword],
 ) -> Result<ColorComponent<NumberOrPercentage>, ParseError<'i>> {
     if !arguments.is_exhausted() {
         arguments.expect_delim('/')?;
-        parse_number_or_percentage(context, arguments, true)
+        parse_number_or_percentage(context, arguments, true, allowed_channel_keywords)
     } else {
-        Ok(ColorComponent::Value(NumberOrPercentage::Number(OPAQUE)))
+        Ok(ColorComponent::AlphaOmitted)
     }
 }
 
 impl ColorComponent<NumberOrPercentage> {
     /// Return true if the value contained inside is/can resolve to a percentage.
     /// Also returns false if the node is invalid somehow.
-    fn is_number(&self) -> bool {
+    fn could_be_number(&self) -> bool {
         match self {
-            Self::None => true,
+            Self::None | Self::AlphaOmitted => true,
             Self::Value(value) => matches!(value, NumberOrPercentage::Number { .. }),
             Self::Calc(node) => {
                 if let Ok(unit) = node.unit() {
@@ -573,9 +642,9 @@ impl ColorComponent<NumberOrPercentage> {
 
     /// Return true if the value contained inside is/can resolve to a percentage.
     /// Also returns false if the node is invalid somehow.
-    fn is_percentage(&self) -> bool {
+    fn could_be_percentage(&self) -> bool {
         match self {
-            Self::None => true,
+            Self::None | Self::AlphaOmitted => true,
             Self::Value(value) => matches!(value, NumberOrPercentage::Percentage { .. }),
             Self::Calc(node) => {
                 if let Ok(unit) = node.unit() {