CSS-wide keywords parsing in longhands: use a single code path with IDs

… rather than generating similar code for every longhand property.
servo · Jul 13, 2017 · 8a8614e · 8a8614e
1 parent a5b80e2
commit 8a8614e
Show file tree

Hide file tree

Showing 2 changed files with 42 additions and 38 deletions.
diff --git a/components/style/properties/helpers.mako.rs b/components/style/properties/helpers.mako.rs
@@ -452,31 +452,26 @@
             }
             pub fn parse_declared<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
                                           -> Result<PropertyDeclaration, ParseError<'i>> {
-                match input.try(|i| CSSWideKeyword::parse(context, i)) {
-                    Ok(keyword) => Ok(PropertyDeclaration::CSSWideKeyword(LonghandId::${property.camel_case}, keyword)),
-                    Err(_) => {
-                        input.look_for_var_functions();
-                        let start = input.position();
-                        let specified = parse_specified(context, input);
-                        if specified.is_err() {
-                            while let Ok(_) = input.next() {}  // Look for var() after the error.
-                        }
-                        let var = input.seen_var_functions();
-                        if specified.is_err() && var {
-                            input.reset(start);
-                            let (first_token_type, css) =
-                                ::custom_properties::parse_non_custom_with_var(input)?;
-                            return Ok(PropertyDeclaration::WithVariables(LonghandId::${property.camel_case},
-                                                                         Arc::new(UnparsedValue {
-                                css: css.into_owned(),
-                                first_token_type: first_token_type,
-                                url_data: context.url_data.clone(),
-                                from_shorthand: None,
-                            })))
-                        }
-                        specified.map(|s| PropertyDeclaration::${property.camel_case}(s))
-                    }
+                input.look_for_var_functions();
+                let start = input.position();
+                let specified = parse_specified(context, input);
+                if specified.is_err() {
+                    while let Ok(_) = input.next() {}  // Look for var() after the error.
+                }
+                let var = input.seen_var_functions();
+                if specified.is_err() && var {
+                    input.reset(start);
+                    let (first_token_type, css) =
+                        ::custom_properties::parse_non_custom_with_var(input)?;
+                    return Ok(PropertyDeclaration::WithVariables(LonghandId::${property.camel_case},
+                                                                 Arc::new(UnparsedValue {
+                        css: css.into_owned(),
+                        first_token_type: first_token_type,
+                        url_data: context.url_data.clone(),
+                        from_shorthand: None,
+                    })))
                 }
+                specified.map(|s| PropertyDeclaration::${property.camel_case}(s))
             }
         % endif
     }

diff --git a/components/style/properties/properties.mako.rs b/components/style/properties/properties.mako.rs
@@ -1521,22 +1521,31 @@ impl PropertyDeclaration {
                 Ok(())
             }
             PropertyId::Longhand(id) => {
-                match id {
-                % for property in data.longhands:
-                    LonghandId::${property.camel_case} => {
-                        % if not property.derived_from:
-                            match longhands::${property.ident}::parse_declared(context, input) {
-                                Ok(value) => {
-                                    declarations.push(value);
-                                    Ok(())
-                                },
-                                Err(_) => Err(PropertyDeclarationParseError::InvalidValue("${property.ident}".into())),
+                if let Ok(keyword) = input.try(|i| CSSWideKeyword::parse(context, i)) {
+                    declarations.push(PropertyDeclaration::CSSWideKeyword(id, keyword))
+                    Ok(())
+                } else {
+                    match id {
+                        % for property in data.longhands:
+                            LonghandId::${property.camel_case} => {
+                                % if not property.derived_from:
+                                    match longhands::${property.ident}::parse_declared(context, input) {
+                                        Ok(value) => {
+                                            declarations.push(value);
+                                            Ok(())
+                                        },
+                                        Err(_) => {
+                                            Err(PropertyDeclarationParseError::InvalidValue(
+                                                "${property.ident}".into()
+                                            ))
+                                        }
+                                    }
+                                % else:
+                                    Err(PropertyDeclarationParseError::UnknownProperty)
+                                % endif
                             }
-                        % else:
-                            Err(PropertyDeclarationParseError::UnknownProperty)
-                        % endif
+                        % endfor
                     }
-                % endfor
                 }
             }
             PropertyId::Shorthand(id) => {