Bug 2024601 - patch 4 - Remove the special-case for simple var() references (without default value) in feature expression values. r=firefox-style-system-reviewers,emilio

jfkthame · jfkthame · commit 9ed150d33b1d · 2026-04-01T00:04:57.000Z
Now that we have more general substitution-function support, the special-case for var() with a simple dashed-ident (and no default) isn't really necessary. In theory it would be slightly more efficient, but seems unlikely to be much used as query expressions also support bare custom-property names (without any var() wrapper), so authors have no reason to write the more verbose form. Differential Revision: https://phabricator.services.mozilla.com/D290905
diff --git a/servo/components/style/queries/feature_expression.rs b/servo/components/style/queries/feature_expression.rs
@@ -681,9 +681,6 @@ pub enum QueryExpressionValue {
     Time(Time),
     /// A custom property name.
     Custom(DashedIdent),
-    /// A simple var(...) reference without a default (equivalent to a bare Custom ident,
-    /// but will serialize with the `var()` wrapper).
-    Var(DashedIdent),
     /// An arbitrary substitution function (var(), attr(), env()), stored as a string
     /// for later evaluation. We store this as a custom-property value to make it easy
     /// to resolve later.
@@ -711,11 +708,6 @@ impl QueryExpressionValue {
             QueryExpressionValue::Angle(v) => v.to_css(dest),
             QueryExpressionValue::Time(v) => v.to_css(dest),
             QueryExpressionValue::Custom(ref v) => v.to_css(dest),
-            QueryExpressionValue::Var(ref v) => {
-                dest.write_str("var(")?;
-                v.to_css(dest)?;
-                dest.write_char(')')
-            },
             QueryExpressionValue::Function(ref f) => f.to_css(dest),
             QueryExpressionValue::Enumerated(value) => match for_expr
                 .expect("caller should have passed for_expr")
@@ -817,21 +809,10 @@ impl QueryExpressionValue {
                     )
                 };
 
-            if name.eq_ignore_ascii_case("var") {
-                // For simple `var(--foo)` references used as individual query-expression values,
-                // we can store as the Var() variant and just look up the custom property at
-                // evaluation time.
-                if let Ok(ident) =
-                    input.try_parse(|i| i.parse_nested_block(|i| DashedIdent::parse(context, i)))
-                {
-                    return Ok(Self::Var(ident));
-                }
-                // Otherwise, we store the entire function to be resolved later via
-                // custom_properties::substitute(), which will also handle fallbacks
-                // if necessary.
-                return Ok(Self::Function(Box::new(parse_func(input)?)));
-            }
-            if static_prefs::pref!("layout.css.attr.enabled") && name.eq_ignore_ascii_case("attr") {
+            if name.eq_ignore_ascii_case("var")
+                || (static_prefs::pref!("layout.css.attr.enabled")
+                    && name.eq_ignore_ascii_case("attr"))
+            {
                 return Ok(Self::Function(Box::new(parse_func(input)?)));
             }
         }
@@ -988,7 +969,7 @@ impl QueryStyleRange {
         visited_set: &mut PrecomputedHashSet<DashedIdent>,
     ) -> Option<Component> {
         match value {
-            QueryExpressionValue::Custom(ident) | QueryExpressionValue::Var(ident) => {
+            QueryExpressionValue::Custom(ident) => {
                 // `ident` is the dashed ident, but we need the name
                 // without "--" for custom-property lookup.
                 let name = ident.undashed();
