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 @@
 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 @@ def switch_to_style_struct(self, name):
                 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 @@ def declare_shorthand(self, name, sub_properties, *args, **kwargs):
         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>