Improve properties.mako.rs file structure, take 2

This is a new attempt of #10586, after Simon Sapin's great cleanups in #10749 has landed. I have adjusted the changes to the new structure that was introduced, and also only done a few of the longhand ones. Will certainly continue on this as soon as we have a basic agreement that this style is reasonable.

components/style/properties/build.py

@@ -10,6 +10,7 @@ BASE = os.path.dirname(__file__)
 sys.path.insert(0, os.path.join(BASE, "Mako-0.9.1.zip"))
 
 from mako import exceptions
+from mako.lookup import TemplateLookup
 from mako.template import Template
 
 import data
@@ -43,10 +44,19 @@ def abort(message):
 
 def render(filename, **context):
     try:
+        # Workaround the fact that we can have a different working directory when called, and Mako includes will fail
+        # miserably if we don't give it proper instructions in the TemplateLookup.
+        if os.getcwd().endswith("components/style"):
+            properties_path = "properties"
+        else:
+            properties_path = "components/style/properties"
+
+        lookup = TemplateLookup(directories=[properties_path])
         template = Template(open(filename, "rb").read(),
+                            filename=filename,
                             input_encoding="utf8",
-                            strict_undefined=True,
-                            filename=filename)
+                            lookup=lookup,
+                            strict_undefined=True)
         # Uncomment to debug generated Python code:
         # write("/tmp", "mako_%s.py" % os.path.basename(filename), template.code)
         return template.render(**context).encode("utf8")

components/style/properties/data.py

@@ -134,6 +134,9 @@ class PropertiesData(object):
                 return
         raise Exception("Failed to find the struct named " + name)
 
+    def new_method(self, name, return_type):
+        return Method(name, return_type)
+
     def declare_longhand(self, name, products="gecko servo", **kwargs):
         products = products.split()
         if self.product not in products:
@@ -154,3 +157,7 @@ class PropertiesData(object):
         shorthand = Shorthand(name, sub_properties, *args, **kwargs)
         self.shorthands.append(shorthand)
         return shorthand
+
+    # Wrapper for the module-level method, since some scopes can only access the stuff in the PropertiesData class.
+    def to_rust_ident(self, name):
+        return to_rust_ident(name)

components/style/properties/longhand/border.mako.rs

@@ -0,0 +1,62 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+<%page args="data, helpers" />
+
+<% data.new_style_struct("Border", inherited=False, gecko_ffi_name="nsStyleBorder",
+                   additional_methods=[data.new_method("border_" + side + "_is_none_or_hidden_and_has_nonzero_width",
+                                                       "bool") for side in ["top", "right", "bottom", "left"]]) %>
+
+% for side in ["top", "right", "bottom", "left"]:
+    ${helpers.predefined_type("border-%s-color" % side, "CSSColor", "::cssparser::Color::CurrentColor")}
+% endfor
+
+% for side in ["top", "right", "bottom", "left"]:
+    ${helpers.predefined_type("border-%s-style" % side, "BorderStyle", "specified::BorderStyle::none")}
+% endfor
+
+% for side in ["top", "right", "bottom", "left"]:
+    <%helpers:longhand name="border-${side}-width">
+        use app_units::Au;
+        use cssparser::ToCss;
+        use std::fmt;
+
+        impl ToCss for SpecifiedValue {
+            fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
+                self.0.to_css(dest)
+            }
+        }
+
+        #[inline]
+        pub fn parse(_context: &ParserContext, input: &mut Parser)
+                               -> Result<SpecifiedValue, ()> {
+            specified::parse_border_width(input).map(SpecifiedValue)
+        }
+        #[derive(Debug, Clone, PartialEq, HeapSizeOf)]
+        pub struct SpecifiedValue(pub specified::Length);
+        pub mod computed_value {
+            use app_units::Au;
+            pub type T = Au;
+        }
+        #[inline] pub fn get_initial_value() -> computed_value::T {
+            Au::from_px(3)  // medium
+        }
+
+        impl ToComputedValue for SpecifiedValue {
+            type ComputedValue = computed_value::T;
+
+            #[inline]
+            fn to_computed_value<Cx: TContext>(&self, context: &Cx) -> computed_value::T {
+                self.0.to_computed_value(context)
+            }
+        }
+    </%helpers:longhand>
+% endfor
+
+// FIXME(#4126): when gfx supports painting it, make this Size2D<LengthOrPercentage>
+% for corner in ["top-left", "top-right", "bottom-right", "bottom-left"]:
+    ${helpers.predefined_type("border-" + corner + "-radius", "BorderRadiusSize",
+                              "computed::BorderRadiusSize::zero()",
+                              "parse")}
+% endfor

components/style/properties/longhand/box.mako.rs

@@ -0,0 +1,127 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+ <%page args="data, helpers" />
+
+<% data.new_style_struct("Box", inherited=False, gecko_ffi_name="nsStyleDisplay",
+                   additional_methods=[data.new_method("clone_display",
+                                                       "longhands::display::computed_value::T"),
+                                       data.new_method("clone_position",
+                                                       "longhands::position::computed_value::T"),
+                                       data.new_method("is_floated", "bool"),
+                                       data.new_method("overflow_x_is_visible", "bool"),
+                                       data.new_method("overflow_y_is_visible", "bool"),
+                                       data.new_method("transition_count", "usize")]) %>
+
+// TODO(SimonSapin): don't parse `inline-table`, since we don't support it
+<%helpers:longhand name="display" custom_cascade="${product == 'servo'}">
+    <%
+        values = """inline block inline-block
+            table inline-table table-row-group table-header-group table-footer-group
+            table-row table-column-group table-column table-cell table-caption
+            list-item flex
+            none
+        """.split()
+        experimental_values = set("flex".split())
+    %>
+    pub use self::computed_value::T as SpecifiedValue;
+    use values::computed::{Context, ComputedValueAsSpecified};
+
+    pub mod computed_value {
+        #[allow(non_camel_case_types)]
+        #[derive(Clone, Eq, PartialEq, Copy, Hash, RustcEncodable, Debug, HeapSizeOf)]
+        #[derive(Deserialize, Serialize)]
+        pub enum T {
+            % for value in values:
+                ${data.to_rust_ident(value)},
+            % endfor
+        }
+
+        impl ::cssparser::ToCss for T {
+            fn to_css<W>(&self, dest: &mut W) -> ::std::fmt::Result
+            where W: ::std::fmt::Write {
+                match *self {
+                    % for value in values:
+                        T::${data.to_rust_ident(value)} => dest.write_str("${value}"),
+                    % endfor
+                }
+            }
+        }
+    }
+    #[inline] pub fn get_initial_value() -> computed_value::T {
+        computed_value::T::${data.to_rust_ident(values[0])}
+    }
+    pub fn parse(_context: &ParserContext, input: &mut Parser)
+                 -> Result<SpecifiedValue, ()> {
+        match_ignore_ascii_case! { try!(input.expect_ident()),
+            % for value in values:
+                "${value}" => {
+                    % if value in experimental_values:
+                        if !::util::prefs::get_pref("layout.${value}.enabled")
+                            .as_boolean().unwrap_or(false) {
+                            return Err(())
+                        }
+                    % endif
+                    Ok(computed_value::T::${data.to_rust_ident(value)})
+                },
+            % endfor
+            _ => Err(())
+        }
+    }
+
+    impl ComputedValueAsSpecified for SpecifiedValue {}
+
+    % if product == "servo":
+        fn cascade_property_custom<C: ComputedValues>(
+                                   _declaration: &PropertyDeclaration,
+                                   _inherited_style: &C,
+                                   context: &mut computed::Context<C>,
+                                   _seen: &mut PropertyBitField,
+                                   _cacheable: &mut bool,
+                                   _error_reporter: &mut StdBox<ParseErrorReporter + Send>) {
+            longhands::_servo_display_for_hypothetical_box::derive_from_display(context);
+            longhands::_servo_text_decorations_in_effect::derive_from_display(context);
+        }
+    % endif
+
+</%helpers:longhand>
+
+${helpers.single_keyword("position", "static absolute relative fixed", extra_gecko_values="sticky")}
+
+<%helpers:single_keyword_computed name="float" values="none left right" gecko_ffi_name="mFloats">
+    impl ToComputedValue for SpecifiedValue {
+        type ComputedValue = computed_value::T;
+
+        #[inline]
+        fn to_computed_value<Cx: TContext>(&self, context: &Cx) -> computed_value::T {
+            let positioned = matches!(context.style().get_box().clone_position(),
+                longhands::position::SpecifiedValue::absolute |
+                longhands::position::SpecifiedValue::fixed);
+            if positioned {
+                SpecifiedValue::none
+            } else {
+                *self
+            }
+        }
+    }
+
+</%helpers:single_keyword_computed>
+
+${helpers.single_keyword("clear", "none left right both", gecko_ffi_name="mBreakType")}
+
+<%helpers:longhand name="-servo-display-for-hypothetical-box" derived_from="display" products="servo">
+    pub use super::display::{SpecifiedValue, get_initial_value};
+    pub use super::display::{parse};
+
+    pub mod computed_value {
+        pub type T = super::SpecifiedValue;
+    }
+
+    #[inline]
+    pub fn derive_from_display<Cx: TContext>(context: &mut Cx) {
+        let d = context.style().get_box().clone_display();
+        context.mutate_style().mutate_box().set__servo_display_for_hypothetical_box(d);
+    }
+
+</%helpers:longhand>

components/style/properties/longhand/margin.mako.rs

@@ -0,0 +1,12 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+<%page args="data, helpers" />
+
+<% data.new_style_struct("Margin", inherited=False, gecko_ffi_name="nsStyleMargin") %>
+
+% for side in ["top", "right", "bottom", "left"]:
+    ${helpers.predefined_type("margin-" + side, "LengthOrPercentageOrAuto",
+                              "computed::LengthOrPercentageOrAuto::Length(Au(0))")}
+% endfor

components/style/properties/longhand/outline.mako.rs

@@ -0,0 +1,59 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+ <%page args="data, helpers" />
+
+<% data.new_style_struct("Outline", inherited=False, gecko_ffi_name="nsStyleOutline",
+                   additional_methods=[data.new_method("outline_is_none_or_hidden_and_has_nonzero_width", "bool")]) %>
+
+// TODO(pcwalton): `invert`
+${helpers.predefined_type("outline-color", "CSSColor", "::cssparser::Color::CurrentColor")}
+
+<%helpers:longhand name="outline-style">
+    pub use values::specified::BorderStyle as SpecifiedValue;
+    pub fn get_initial_value() -> SpecifiedValue { SpecifiedValue::none }
+    pub mod computed_value {
+        pub use values::specified::BorderStyle as T;
+    }
+    pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
+        match SpecifiedValue::parse(input) {
+            Ok(SpecifiedValue::hidden) => Err(()),
+            result => result
+        }
+    }
+</%helpers:longhand>
+
+<%helpers:longhand name="outline-width">
+    use app_units::Au;
+    use cssparser::ToCss;
+    use std::fmt;
+    use values::AuExtensionMethods;
+
+    impl ToCss for SpecifiedValue {
+        fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
+            self.0.to_css(dest)
+        }
+    }
+
+    pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
+        specified::parse_border_width(input).map(SpecifiedValue)
+    }
+    #[derive(Debug, Clone, PartialEq, HeapSizeOf)]
+    pub struct SpecifiedValue(pub specified::Length);
+    pub mod computed_value {
+        use app_units::Au;
+        pub type T = Au;
+    }
+    pub use super::border_top_width::get_initial_value;
+    impl ToComputedValue for SpecifiedValue {
+        type ComputedValue = computed_value::T;
+
+        #[inline]
+        fn to_computed_value<Cx: TContext>(&self, context: &Cx) -> computed_value::T {
+            self.0.to_computed_value(context)
+        }
+    }
+</%helpers:longhand>
+
+${helpers.predefined_type("outline-offset", "Length", "Au(0)")}

components/style/properties/longhand/padding.mako.rs

@@ -0,0 +1,13 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+<%page args="data, helpers" />
+
+<% data.new_style_struct("Padding", inherited=False, gecko_ffi_name="nsStylePadding") %>
+
+% for side in ["top", "right", "bottom", "left"]:
+    ${helpers.predefined_type("padding-" + side, "LengthOrPercentage",
+                               "computed::LengthOrPercentage::Length(Au(0))",
+                               "parse_non_negative")}
+% endfor

components/style/properties/longhand/position.mako.rs

@@ -0,0 +1,58 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+<%page args="data, helpers" />
+
+<% data.new_style_struct("Position", inherited=False, gecko_ffi_name="nsStylePosition") %>
+
+% for side in ["top", "right", "bottom", "left"]:
+    ${helpers.predefined_type(side, "LengthOrPercentageOrAuto",
+                              "computed::LengthOrPercentageOrAuto::Auto")}
+% endfor
+
+<%helpers:longhand name="z-index">
+    use values::computed::ComputedValueAsSpecified;
+
+    impl ComputedValueAsSpecified for SpecifiedValue {}
+    pub type SpecifiedValue = computed_value::T;
+    pub mod computed_value {
+        use cssparser::ToCss;
+        use std::fmt;
+
+        #[derive(PartialEq, Clone, Eq, Copy, Debug, HeapSizeOf)]
+        pub enum T {
+            Auto,
+            Number(i32),
+        }
+
+        impl ToCss for T {
+            fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
+                match *self {
+                    T::Auto => dest.write_str("auto"),
+                    T::Number(number) => write!(dest, "{}", number),
+                }
+            }
+        }
+
+        impl T {
+            pub fn number_or_zero(self) -> i32 {
+                match self {
+                    T::Auto => 0,
+                    T::Number(value) => value,
+                }
+            }
+        }
+    }
+    #[inline]
+    pub fn get_initial_value() -> computed_value::T {
+        computed_value::T::Auto
+    }
+    fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
+        if input.try(|input| input.expect_ident_matching("auto")).is_ok() {
+            Ok(computed_value::T::Auto)
+        } else {
+            specified::parse_integer(input).map(computed_value::T::Number)
+        }
+    }
+</%helpers:longhand>

components/style/properties/properties.mako.rs

@@ -233,311 +233,14 @@ pub mod longhands {
 
 
     // CSS 2.1, Section 8 - Box model
-
-    <% data.new_style_struct("Margin", inherited=False, gecko_ffi_name="nsStyleMargin") %>
-
-    % for side in ["top", "right", "bottom", "left"]:
-        ${predefined_type("margin-" + side, "LengthOrPercentageOrAuto",
-                          "computed::LengthOrPercentageOrAuto::Length(Au(0))")}
-    % endfor
-
-    <% data.new_style_struct("Padding", inherited=False, gecko_ffi_name="nsStylePadding") %>
-
-    % for side in ["top", "right", "bottom", "left"]:
-        ${predefined_type("padding-" + side, "LengthOrPercentage",
-                          "computed::LengthOrPercentage::Length(Au(0))",
-                          "parse_non_negative")}
-    % endfor
-
-    <% data.new_style_struct("Border", inherited=False, gecko_ffi_name="nsStyleBorder",
-                       additional_methods=[Method("border_" + side + "_is_none_or_hidden_and_has_nonzero_width",
-                                                  "bool") for side in ["top", "right", "bottom", "left"]]) %>
-
-    % for side in ["top", "right", "bottom", "left"]:
-        ${predefined_type("border-%s-color" % side, "CSSColor", "::cssparser::Color::CurrentColor")}
-    % endfor
-
-    % for side in ["top", "right", "bottom", "left"]:
-        ${predefined_type("border-%s-style" % side, "BorderStyle", "specified::BorderStyle::none")}
-    % endfor
-
-    % for side in ["top", "right", "bottom", "left"]:
-        <%self:longhand name="border-${side}-width">
-            use app_units::Au;
-            use cssparser::ToCss;
-            use std::fmt;
-
-            impl ToCss for SpecifiedValue {
-                fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-                    self.0.to_css(dest)
-                }
-            }
-
-            #[inline]
-            pub fn parse(_context: &ParserContext, input: &mut Parser)
-                                   -> Result<SpecifiedValue, ()> {
-                specified::parse_border_width(input).map(SpecifiedValue)
-            }
-            #[derive(Debug, Clone, PartialEq, HeapSizeOf)]
-            pub struct SpecifiedValue(pub specified::Length);
-            pub mod computed_value {
-                use app_units::Au;
-                pub type T = Au;
-            }
-            #[inline] pub fn get_initial_value() -> computed_value::T {
-                Au::from_px(3)  // medium
-            }
-
-            impl ToComputedValue for SpecifiedValue {
-                type ComputedValue = computed_value::T;
-
-                #[inline]
-                fn to_computed_value<Cx: TContext>(&self, context: &Cx) -> computed_value::T {
-                    self.0.to_computed_value(context)
-                }
-            }
-        </%self:longhand>
-    % endfor
-
-    // FIXME(#4126): when gfx supports painting it, make this Size2D<LengthOrPercentage>
-    % for corner in ["top-left", "top-right", "bottom-right", "bottom-left"]:
-        ${predefined_type("border-" + corner + "-radius", "BorderRadiusSize",
-                          "computed::BorderRadiusSize::zero()",
-                          "parse")}
-    % endfor
-
-    <% data.new_style_struct("Outline", inherited=False, gecko_ffi_name="nsStyleOutline",
-                       additional_methods=[Method("outline_is_none_or_hidden_and_has_nonzero_width", "bool")]) %>
-
-    // TODO(pcwalton): `invert`
-    ${predefined_type("outline-color", "CSSColor", "::cssparser::Color::CurrentColor")}
-
-    <%self:longhand name="outline-style">
-        pub use values::specified::BorderStyle as SpecifiedValue;
-        pub fn get_initial_value() -> SpecifiedValue { SpecifiedValue::none }
-        pub mod computed_value {
-            pub use values::specified::BorderStyle as T;
-        }
-        pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
-            match SpecifiedValue::parse(input) {
-                Ok(SpecifiedValue::hidden) => Err(()),
-                result => result
-            }
-        }
-    </%self:longhand>
-
-    <%self:longhand name="outline-width">
-        use app_units::Au;
-        use cssparser::ToCss;
-        use std::fmt;
-        use values::AuExtensionMethods;
-
-        impl ToCss for SpecifiedValue {
-            fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-                self.0.to_css(dest)
-            }
-        }
-
-        pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
-            specified::parse_border_width(input).map(SpecifiedValue)
-        }
-        #[derive(Debug, Clone, PartialEq, HeapSizeOf)]
-        pub struct SpecifiedValue(pub specified::Length);
-        pub mod computed_value {
-            use app_units::Au;
-            pub type T = Au;
-        }
-        pub use super::border_top_width::get_initial_value;
-        impl ToComputedValue for SpecifiedValue {
-            type ComputedValue = computed_value::T;
-
-            #[inline]
-            fn to_computed_value<Cx: TContext>(&self, context: &Cx) -> computed_value::T {
-                self.0.to_computed_value(context)
-            }
-        }
-    </%self:longhand>
-
-    ${predefined_type("outline-offset", "Length", "Au(0)")}
-
-    <% data.new_style_struct("Position", inherited=False, gecko_ffi_name="nsStylePosition") %>
-
-    % for side in ["top", "right", "bottom", "left"]:
-        ${predefined_type(side, "LengthOrPercentageOrAuto",
-                          "computed::LengthOrPercentageOrAuto::Auto")}
-    % endfor
+    <%include file="/longhand/margin.mako.rs" args="helpers=self" />
+    <%include file="/longhand/padding.mako.rs" args="helpers=self" />
+    <%include file="/longhand/border.mako.rs" args="helpers=self" />
+    <%include file="/longhand/outline.mako.rs" args="helpers=self" />
+    <%include file="/longhand/position.mako.rs" args="helpers=self" />
 
     // CSS 2.1, Section 9 - Visual formatting model
-
-    <% data.new_style_struct("Box", inherited=False, gecko_ffi_name="nsStyleDisplay",
-                       additional_methods=[Method("clone_display",
-                                                  "longhands::display::computed_value::T"),
-                                           Method("clone_position",
-                                                  "longhands::position::computed_value::T"),
-                                           Method("is_floated", "bool"),
-                                           Method("overflow_x_is_visible", "bool"),
-                                           Method("overflow_y_is_visible", "bool"),
-                                           Method("transition_count", "usize")]) %>
-
-    // TODO(SimonSapin): don't parse `inline-table`, since we don't support it
-    <%self:longhand name="display" custom_cascade="${product == 'servo'}">
-        <%
-            values = """inline block inline-block
-                table inline-table table-row-group table-header-group table-footer-group
-                table-row table-column-group table-column table-cell table-caption
-                list-item flex
-                none
-            """.split()
-            experimental_values = set("flex".split())
-        %>
-        pub use self::computed_value::T as SpecifiedValue;
-        use values::computed::{Context, ComputedValueAsSpecified};
-
-        pub mod computed_value {
-            #[allow(non_camel_case_types)]
-            #[derive(Clone, Eq, PartialEq, Copy, Hash, RustcEncodable, Debug, HeapSizeOf)]
-            #[derive(Deserialize, Serialize)]
-            pub enum T {
-                % for value in values:
-                    ${to_rust_ident(value)},
-                % endfor
-            }
-
-            impl ::cssparser::ToCss for T {
-                fn to_css<W>(&self, dest: &mut W) -> ::std::fmt::Result
-                where W: ::std::fmt::Write {
-                    match *self {
-                        % for value in values:
-                            T::${to_rust_ident(value)} => dest.write_str("${value}"),
-                        % endfor
-                    }
-                }
-            }
-        }
-        #[inline] pub fn get_initial_value() -> computed_value::T {
-            computed_value::T::${to_rust_ident(values[0])}
-        }
-        pub fn parse(_context: &ParserContext, input: &mut Parser)
-                     -> Result<SpecifiedValue, ()> {
-            match_ignore_ascii_case! { try!(input.expect_ident()),
-                % for value in values:
-                    "${value}" => {
-                        % if value in experimental_values:
-                            if !::util::prefs::get_pref("layout.${value}.enabled")
-                                .as_boolean().unwrap_or(false) {
-                                return Err(())
-                            }
-                        % endif
-                        Ok(computed_value::T::${to_rust_ident(value)})
-                    },
-                % endfor
-                _ => Err(())
-            }
-        }
-
-        impl ComputedValueAsSpecified for SpecifiedValue {}
-
-        % if product == "servo":
-            fn cascade_property_custom<C: ComputedValues>(
-                                       _declaration: &PropertyDeclaration,
-                                       _inherited_style: &C,
-                                       context: &mut computed::Context<C>,
-                                       _seen: &mut PropertyBitField,
-                                       _cacheable: &mut bool,
-                                       _error_reporter: &mut StdBox<ParseErrorReporter + Send>) {
-                longhands::_servo_display_for_hypothetical_box::derive_from_display(context);
-                longhands::_servo_text_decorations_in_effect::derive_from_display(context);
-            }
-        % endif
-
-    </%self:longhand>
-
-    ${single_keyword("position", "static absolute relative fixed", extra_gecko_values="sticky")}
-
-    <%self:single_keyword_computed name="float" values="none left right" gecko_ffi_name="mFloats">
-        impl ToComputedValue for SpecifiedValue {
-            type ComputedValue = computed_value::T;
-
-            #[inline]
-            fn to_computed_value<Cx: TContext>(&self, context: &Cx) -> computed_value::T {
-                let positioned = matches!(context.style().get_box().clone_position(),
-                    longhands::position::SpecifiedValue::absolute |
-                    longhands::position::SpecifiedValue::fixed);
-                if positioned {
-                    SpecifiedValue::none
-                } else {
-                    *self
-                }
-            }
-        }
-
-    </%self:single_keyword_computed>
-
-    ${single_keyword("clear", "none left right both", gecko_ffi_name="mBreakType")}
-
-    <%self:longhand name="-servo-display-for-hypothetical-box" derived_from="display" products="servo">
-        pub use super::display::{SpecifiedValue, get_initial_value};
-        pub use super::display::{parse};
-
-        pub mod computed_value {
-            pub type T = super::SpecifiedValue;
-        }
-
-        #[inline]
-        pub fn derive_from_display<Cx: TContext>(context: &mut Cx) {
-            let d = context.style().get_box().clone_display();
-            context.mutate_style().mutate_box().set__servo_display_for_hypothetical_box(d);
-        }
-
-    </%self:longhand>
-
-    <% data.switch_to_style_struct("Position") %>
-
-    <%self:longhand name="z-index">
-        use values::computed::ComputedValueAsSpecified;
-
-        impl ComputedValueAsSpecified for SpecifiedValue {}
-        pub type SpecifiedValue = computed_value::T;
-        pub mod computed_value {
-            use cssparser::ToCss;
-            use std::fmt;
-
-            #[derive(PartialEq, Clone, Eq, Copy, Debug, HeapSizeOf)]
-            pub enum T {
-                Auto,
-                Number(i32),
-            }
-
-            impl ToCss for T {
-                fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-                    match *self {
-                        T::Auto => dest.write_str("auto"),
-                        T::Number(number) => write!(dest, "{}", number),
-                    }
-                }
-            }
-
-            impl T {
-                pub fn number_or_zero(self) -> i32 {
-                    match self {
-                        T::Auto => 0,
-                        T::Number(value) => value,
-                    }
-                }
-            }
-        }
-        #[inline]
-        pub fn get_initial_value() -> computed_value::T {
-            computed_value::T::Auto
-        }
-        fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
-            if input.try(|input| input.expect_ident_matching("auto")).is_ok() {
-                Ok(computed_value::T::Auto)
-            } else {
-                specified::parse_integer(input).map(computed_value::T::Number)
-            }
-        }
-    </%self:longhand>
+    <%include file="/longhand/box.mako.rs" args="helpers=self" />
 
     <% data.new_style_struct("InheritedBox", inherited=True, gecko_ffi_name="nsStyleVisibility",
                        additional_methods=[Method("clone_direction",

python/tidy/servo_tidy/tidy.py

@@ -278,6 +278,8 @@ def check_toml(file_name, lines):
 def check_rust(file_name, lines):
     if not file_name.endswith(".rs") or \
        file_name.endswith("properties.mako.rs") or \
+       file_name.find("properties/longhand") or \
+       file_name.find("properties/shorthand") or \
        file_name.endswith(os.path.join("style", "build.rs")) or \
        file_name.endswith(os.path.join("geckolib", "build.rs")) or \
        file_name.endswith(os.path.join("unit", "style", "stylesheets.rs")):