blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/properties/data.py

@@ -0,0 +1,1375 @@
+# 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 https://mozilla.org/MPL/2.0/.
+
+import re
+import toml
+import os
+from itertools import groupby
+from counted_unknown_properties import COUNTED_UNKNOWN_PROPERTIES
+
+# It is important that the order of these physical / logical variants matches
+# the order of the enum variants in logical_geometry.rs
+PHYSICAL_SIDES = ["top", "right", "bottom", "left"]
+PHYSICAL_CORNERS = ["top-left", "top-right", "bottom-right", "bottom-left"]
+PHYSICAL_AXES = ["y", "x"]
+PHYSICAL_SIZES = ["height", "width"]
+LOGICAL_SIDES = ["block-start", "block-end", "inline-start", "inline-end"]
+LOGICAL_CORNERS = ["start-start", "start-end", "end-start", "end-end"]
+LOGICAL_SIZES = ["block-size", "inline-size"]
+LOGICAL_AXES = ["block", "inline"]
+
+SYSTEM_FONT_LONGHANDS = """font_family font_size font_style
+                           font_width font_weight""".split()
+
+PRIORITARY_PROPERTIES = set(
+    [
+        # The writing-mode group has the most priority of all property groups, as
+        # sizes like font-size can depend on it.
+        "writing-mode",
+        "direction",
+        "text-orientation",
+        # The fonts and colors group has the second priority, as all other lengths
+        # and colors depend on them.
+        #
+        # There are some interdependencies between these, but we fix them up in
+        # Cascade::fixup_font_stuff.
+        # Needed to properly compute the zoomed font-size.
+        "-x-text-scale",
+        # Needed to do font-size computation in a language-dependent way.
+        "-x-lang",
+        # Needed for ruby to respect language-dependent min-font-size
+        # preferences properly, see bug 1165538.
+        "-moz-min-font-size-ratio",
+        # font-size depends on math-depth's computed value.
+        "math-depth",
+        # Needed to compute the first available font and its used size,
+        # in order to compute font-relative units correctly.
+        "font-size",
+        "font-size-adjust",
+        "font-weight",
+        "font-width",
+        "font-style",
+        "font-family",
+        # color-scheme affects how system colors and light-dark() resolve.
+        "color-scheme",
+        # forced-color-adjust affects whether colors are adjusted.
+        "forced-color-adjust",
+        # Zoom affects all absolute lengths.
+        "zoom",
+        # Line height lengths depend on this.
+        "line-height",
+        # appearance and -moz-default-appearance control whether
+        # @appearance-base rules apply.
+        "-moz-default-appearance",
+        "appearance",
+    ]
+)
+
+# Set of prioritary properties and dependencies between them.
+#
+# Some properties must depend on appearance because of the @appearance-base rule.
+# If a property doesn't depend on `appearance` (either directly or transitively), then
+# declarations inside the @appearance-base rule might not apply consistently.
+#
+# We don't want to necessarily make all properties work in @appearance-base, however.
+# For example we don't want to mess with writing-modes etc there, so we can skip the
+# dependency.
+PRIORITARY_PROPERTY_DEPENDENCIES = {
+    # Needed for @appearance-base
+    "-moz-default-appearance": [],
+    "appearance": ["-moz-default-appearance"],
+    # Language affects font-family and thus other prioritary font properties.
+    "-x-lang": [],
+    # font-family potentially changes keyword font sizes, we want to apply text
+    # un-scaling after it.
+    "-x-text-scale": ["font-family"],
+    # Affects all colors due to forced-colors mode.
+    "forced-color-adjust": [],
+    # color-scheme potentially affects all colors via light-dark() / system colors.
+    # It depends on forced-color-adjust because it's one of the
+    # "ignored_when_colors_disabled" properties.
+    "color-scheme": ["forced-color-adjust"],
+    # Affects all lengths.
+    "zoom": [],
+    # Affects the `math` keyword font-size.
+    "math-depth": [],
+    # Affects min font-size.
+    "-moz-min-font-size-ratio": [],
+    # Default font-family depends on language.
+    "font-family": ["-x-lang", "appearance"],
+    # font-size depends on zoom because it's a length, and other properties because of
+    # their respective size implications, see their comments.
+    "font-size": [
+        "zoom",
+        "math-depth",
+        "-x-text-scale",
+        "-moz-min-font-size-ratio",
+    ],
+    # Various font properties affect primary font selection, which affect all other
+    # lengths (other than font-size) via font-relative units.
+    "font-size-adjust": ["appearance"],
+    "font-weight": ["appearance"],
+    "font-width": ["appearance"],
+    "font-style": ["appearance"],
+    # Writing-mode properties affect logical -> physical property conversions, but also
+    # font metrics.
+    "direction": [],
+    "writing-mode": [],
+    "text-orientation": [],
+    # Line-height depends on the primary font and writing-mode because it can be a
+    # length.
+    "line-height": [
+        "direction",
+        "writing-mode",
+        "text-orientation",
+        "font-size",
+        "font-weight",
+        "font-width",
+        "font-style",
+        "font-size-adjust",
+    ],
+}
+
+PRIORITARY_PROPERTIES = set(PRIORITARY_PROPERTY_DEPENDENCIES.keys())
+
+VISITED_DEPENDENT_PROPERTIES = set(
+    [
+        "column-rule-color",
+        "text-emphasis-color",
+        "-webkit-text-fill-color",
+        "-webkit-text-stroke-color",
+        "text-decoration-color",
+        "fill",
+        "stroke",
+        "caret-color",
+        "background-color",
+        "border-top-color",
+        "border-right-color",
+        "border-bottom-color",
+        "border-left-color",
+        "border-block-start-color",
+        "border-inline-end-color",
+        "border-block-end-color",
+        "border-inline-start-color",
+        "outline-color",
+        "color",
+    ]
+)
+
+# Bitfield values for all rule types which can have property declarations.
+STYLE_RULE = 1 << 0
+PAGE_RULE = 1 << 1
+KEYFRAME_RULE = 1 << 2
+POSITION_TRY_RULE = 1 << 3
+SCOPE_RULE = 1 << 4
+
+ALL_RULES = STYLE_RULE | PAGE_RULE | KEYFRAME_RULE | SCOPE_RULE
+DEFAULT_RULES = STYLE_RULE | KEYFRAME_RULE | SCOPE_RULE
+DEFAULT_RULES_AND_PAGE = DEFAULT_RULES | PAGE_RULE
+DEFAULT_RULES_EXCEPT_KEYFRAME = STYLE_RULE | SCOPE_RULE
+DEFAULT_RULES_AND_POSITION_TRY = DEFAULT_RULES | POSITION_TRY_RULE
+
+# Rule name to value dict
+RULE_VALUES = {
+    "style": STYLE_RULE,
+    "page": PAGE_RULE,
+    "keyframe": KEYFRAME_RULE,
+    "position-try": POSITION_TRY_RULE,
+    "scope": SCOPE_RULE,
+}
+
+
+def rule_values_from_arg(rule_types):
+    if not rule_types:
+        return DEFAULT_RULES
+    mask = 0
+    for rule in rule_types:
+        mask |= RULE_VALUES[rule]
+    return mask
+
+
+def to_rust_ident(name):
+    name = name.replace("-", "_")
+    if name in ["static", "super", "box", "move"]:  # Rust keywords
+        name += "_"
+    return name
+
+
+def idl_method(name, camel_case):
+    if name == "float":
+        return "CssFloat"
+    if name.startswith("-x-"):
+        return camel_case[1:]
+    return camel_case
+
+
+def to_snake_case(ident):
+    return re.sub("([A-Z]+)", lambda m: "_" + m.group(1).lower(), ident).strip("_")
+
+
+def to_camel_case(ident):
+    return re.sub(
+        "(^|_|-)([a-z0-9])", lambda m: m.group(2).upper(), ident.strip("_").strip("-")
+    )
+
+
+def to_camel_case_lower(ident):
+    camel = to_camel_case(ident)
+    return camel[0].lower() + camel[1:]
+
+
+# https://drafts.csswg.org/cssom/#css-property-to-idl-attribute
+def to_idl_name(name):
+    return re.sub("-([a-z])", lambda m: m.group(1).upper(), name)
+
+
+def parse_aliases(value):
+    aliases = {}
+    for pair in value:
+        [a, v] = pair.split("=")
+        aliases[a] = v
+    return aliases
+
+
+class Vector(object):
+    def __init__(
+        self,
+        need_index=False,
+        none_value=None,
+        separator='Comma',
+        animation_type=None,
+        simple_bindings=False,
+    ):
+        self.need_index = need_index
+        self.none_value = none_value
+        self.separator = separator
+        self.animation_type = animation_type
+        self.simple_bindings = simple_bindings
+
+
+class Keyword(object):
+    def __init__(
+        self,
+        name,
+        values,
+        gecko_constant_prefix=None,
+        gecko_enum_prefix=None,
+        extra_gecko_values=None,
+        extra_servo_values=None,
+        gecko_aliases=None,
+        servo_aliases=None,
+        gecko_inexhaustive=None,
+    ):
+        self.name = name
+        self.values = values;
+        assert isinstance(values, list), name
+        if gecko_constant_prefix and gecko_enum_prefix:
+            raise TypeError(
+                "Only one of gecko_constant_prefix and gecko_enum_prefix "
+                "can be specified"
+            )
+        self.gecko_constant_prefix = gecko_constant_prefix
+        self.gecko_enum_prefix = gecko_enum_prefix
+        if not gecko_constant_prefix and not gecko_enum_prefix:
+            self.gecko_enum_prefix = "Style" + to_camel_case(name.replace("-moz-", "").replace("-webkit-", ""))
+        self.extra_gecko_values = extra_gecko_values or []
+        self.extra_servo_values = extra_servo_values or []
+        self.gecko_aliases = parse_aliases(gecko_aliases or [])
+        self.servo_aliases = parse_aliases(servo_aliases or [])
+        self.gecko_inexhaustive = gecko_inexhaustive or self.gecko_constant_prefix is not None
+
+    def values_for(self, engine):
+        if engine == "gecko":
+            return self.values + self.extra_gecko_values
+        elif engine == "servo":
+            return self.values + self.extra_servo_values
+        else:
+            raise Exception("Bad engine: " + engine)
+
+    def aliases_for(self, engine):
+        if engine == "gecko":
+            return self.gecko_aliases
+        elif engine == "servo":
+            return self.servo_aliases
+        else:
+            raise Exception("Bad engine: " + engine)
+
+    def gecko_constant(self, value):
+        moz_stripped = value.replace("-moz-", "")
+        if self.gecko_enum_prefix:
+            parts = moz_stripped.replace("-", "_").split("_")
+            parts = [p.title() for p in parts]
+            return self.gecko_enum_prefix + "::" + "".join(parts)
+        else:
+            suffix = moz_stripped.replace("-", "_")
+            return self.gecko_constant_prefix + "_" + suffix.upper()
+
+    def needs_cast(self):
+        return self.gecko_enum_prefix is None
+
+    def maybe_cast(self, type_str):
+        return "as " + type_str if self.needs_cast() else ""
+
+    def casted_constant_name(self, value, cast_type):
+        if cast_type is None:
+            raise TypeError("We should specify the cast_type.")
+
+        if self.gecko_enum_prefix is None:
+            return cast_type.upper() + "_" + self.gecko_constant(value)
+        else:
+            return (
+                cast_type.upper()
+                + "_"
+                + self.gecko_constant(value).upper().replace("::", "_")
+            )
+
+
+def parse_property_aliases(alias_list):
+    result = []
+    if alias_list:
+        for alias in alias_list:
+            (name, _, pref) = alias.partition(":")
+            result.append((name, pref))
+    return result
+
+
+def to_phys(name, logical, physical):
+    return name.replace(logical, physical).replace("inset-", "")
+
+
+class Property(object):
+    def __init__(
+        self,
+        name,
+        spec,
+        servo_pref,
+        gecko_pref,
+        enabled_in,
+        rule_types_allowed,
+        aliases,
+        extra_prefixes,
+        flags,
+    ):
+        self.name = name
+        if not spec:
+            raise TypeError("Spec should be specified for " + name)
+        self.spec = spec
+        self.ident = to_rust_ident(name)
+        self.camel_case = to_camel_case(self.ident)
+        self.servo_pref = servo_pref
+        self.gecko_pref = gecko_pref
+        self.idl_method = idl_method(name, self.camel_case)
+        self.rule_types_allowed = rule_values_from_arg(rule_types_allowed)
+        # For enabled_in, the setup is as follows:
+        # It needs to be one of the four values: ["", "ua", "chrome", "content"]
+        #  * "chrome" implies "ua", and implies that they're explicitly
+        #    enabled.
+        #  * "" implies the property will never be parsed.
+        #  * "content" implies the property is accessible unconditionally,
+        #    modulo a pref, set via servo_pref / gecko_pref.
+        assert enabled_in in ("", "ua", "chrome", "content")
+        self.enabled_in = enabled_in
+        self.aliases = parse_property_aliases(aliases)
+        self.extra_prefixes = parse_property_aliases(extra_prefixes)
+        self.flags = flags.split() if flags else []
+
+    def rule_types_allowed_names(self):
+        for name in RULE_VALUES:
+            if self.rule_types_allowed & RULE_VALUES[name] != 0:
+                yield name
+
+    def experimental(self, engine):
+        if engine == "gecko":
+            return bool(self.gecko_pref)
+        elif engine == "servo":
+            return bool(self.servo_pref)
+        else:
+            raise Exception("Bad engine: " + engine)
+
+    def explicitly_enabled_in_ua_sheets(self):
+        return self.enabled_in in ("ua", "chrome")
+
+    def explicitly_enabled_in_chrome(self):
+        return self.enabled_in == "chrome"
+
+    def enabled_in_content(self):
+        return self.enabled_in == "content"
+
+    def is_visited_dependent(self):
+        return self.name in VISITED_DEPENDENT_PROPERTIES
+
+    def is_prioritary(self):
+        return self.name in PRIORITARY_PROPERTIES
+
+    def noncustomcsspropertyid(self):
+        return "NonCustomCSSPropertyId::eCSSProperty_" + self.ident
+
+
+class Longhand(Property):
+    def __init__(
+        self,
+        style_struct,
+        name,
+        initial_value=None,
+        initial_specified_value=None,
+        parse_method='parse',
+        spec=None,
+        animation_type="normal",
+        keyword=None,
+        predefined_type=None,
+        servo_pref=None,
+        gecko_pref=None,
+        enabled_in="content",
+        gecko_ffi_name=None,
+        has_effect_on_gecko_scrollbars=None,
+        rule_types_allowed=None,
+        cast_type="u8",
+        logical=False,
+        logical_group=None,
+        aliases=None,
+        extra_prefixes=None,
+        boxed=False,
+        flags=None,
+        allow_quirks=False,
+        ignored_when_colors_disabled=False,
+        vector=None,
+        servo_restyle_damage="rebuild_box",
+        affects=None,
+    ):
+        Property.__init__(
+            self,
+            name=name,
+            spec=spec,
+            servo_pref=servo_pref,
+            gecko_pref=gecko_pref,
+            enabled_in=enabled_in,
+            rule_types_allowed=rule_types_allowed,
+            aliases=aliases,
+            extra_prefixes=extra_prefixes,
+            flags=flags,
+        )
+
+        self.affects = affects
+        self.flags += self.affects_flags()
+
+        self.parse_method = parse_method
+        self.initial_value = initial_value
+        self.initial_specified_value = initial_specified_value
+        self.keyword = keyword
+        self.predefined_type = predefined_type
+        self.style_struct = style_struct
+        self.has_effect_on_gecko_scrollbars = has_effect_on_gecko_scrollbars
+        assert (
+            has_effect_on_gecko_scrollbars in [None, False, True]
+            and not style_struct.inherited
+            or (gecko_pref is None and enabled_in != "")
+            == (has_effect_on_gecko_scrollbars is None)
+        ), (
+            "Property "
+            + name
+            + ": has_effect_on_gecko_scrollbars must be "
+            + "specified, and must have a value of True or False, iff a "
+            + "property is inherited and is behind a Gecko pref or internal"
+        )
+        self.gecko_ffi_name = gecko_ffi_name or "m" + self.camel_case
+        self.cast_type = cast_type
+        self.logical = logical
+        self.logical_group = logical_group
+        if self.logical:
+            assert logical_group, f"Property {name} must have a logical group"
+
+        self.boxed = boxed
+        self.allow_quirks = allow_quirks
+        self.ignored_when_colors_disabled = ignored_when_colors_disabled
+        self.vector = Vector(**vector) if vector is not None else None
+
+        assert animation_type in ["none", "normal", "discrete"]
+        self.animation_type = animation_type
+        self.animatable = animation_type != "none"
+
+        # See compute_damage for the various values this can take
+        self.servo_restyle_damage = servo_restyle_damage
+
+    def affects_flags(self):
+        # Layout is the stronger hint. This property animation affects layout
+        # or frame construction. `display` or `width` are examples that should
+        # use this.
+        if self.affects == "layout":
+            return ["AFFECTS_LAYOUT"]
+        # This property doesn't affect layout, but affects overflow.
+        # `transform` and co. are examples of this.
+        if self.affects == "overflow":
+            return ["AFFECTS_OVERFLOW"]
+        # This property affects the rendered output but doesn't affect layout.
+        # `opacity`, `color`, or `z-index` are examples of this.
+        if self.affects == "paint":
+            return ["AFFECTS_PAINT"]
+        # This property doesn't affect rendering in any way.
+        # `user-select` is an example of this.
+        assert self.affects == "", (
+            "Property "
+            + self.name
+            + ': affects must be specified and be one of ["layout", "overflow", "paint", ""], see Longhand.affects_flags for documentation'
+        )
+        return []
+
+    @staticmethod
+    def type():
+        return "longhand"
+
+    # For a given logical property, return the kind of mapping we need to
+    # perform, and which logical value we represent, in a tuple.
+    def logical_mapping_data(self, data):
+        if not self.logical:
+            return []
+        # Sizes and axes are basically the same for mapping, we just need
+        # slightly different replacements (block-size -> height, etc rather
+        # than -x/-y) below.
+        for [ty, logical_items, physical_items] in [
+            ["Side", LOGICAL_SIDES, PHYSICAL_SIDES],
+            ["Corner", LOGICAL_CORNERS, PHYSICAL_CORNERS],
+            ["Axis", LOGICAL_SIZES, PHYSICAL_SIZES],
+            ["Axis", LOGICAL_AXES, PHYSICAL_AXES],
+        ]:
+            candidate = [s for s in logical_items if s in self.name]
+            if candidate:
+                assert len(candidate) == 1
+                return [ty, candidate[0], logical_items, physical_items]
+        assert False, "Don't know how to deal with " + self.name
+
+    def logical_mapping_kind(self, data):
+        assert self.logical
+        [kind, item, _, _] = self.logical_mapping_data(data)
+        return "LogicalMappingKind::{}(Logical{}::{})".format(
+            kind, kind, to_camel_case(item.replace("-size", ""))
+        )
+
+    # For a given logical property return all the physical property names
+    # corresponding to it.
+    def all_physical_mapped_properties(self, data):
+        if not self.logical:
+            return []
+        [_, logical_side, _, physical_items] = self.logical_mapping_data(data)
+        return [
+            data.longhands_by_name[to_phys(self.name, logical_side, physical_side)]
+            for physical_side in physical_items
+        ]
+
+    def may_be_disabled_in(self, shorthand, engine):
+        if "ALLOWS_DISABLED_SUBPROPERTIES" in shorthand.flags:
+            assert "IS_LEGACY_SHORTHAND" in shorthand.flags
+            assert len(shorthand.sub_properties) == 1
+            return False
+
+        if engine == "gecko":
+            return self.gecko_pref and self.gecko_pref != shorthand.gecko_pref
+        elif engine == "servo":
+            return self.servo_pref and self.servo_pref != shorthand.servo_pref
+        else:
+            raise Exception("Bad engine: " + engine)
+
+    def base_type(self):
+        if self.predefined_type and not self.vector:
+            return "crate::values::specified::{}".format(self.predefined_type)
+        return "longhands::{}::SpecifiedValue".format(self.ident)
+
+    def specified_type(self):
+        if self.predefined_type and not self.vector:
+            ty = "crate::values::specified::{}".format(self.predefined_type)
+        else:
+            ty = "longhands::{}::SpecifiedValue".format(self.ident)
+        if self.boxed:
+            ty = "Box<{}>".format(ty)
+        return ty
+
+    def is_zoom_dependent(self):
+        if not self.predefined_type:
+            return False
+        # TODO: Get this from SpecifiedValueInfo or so instead; see bug 1887627.
+        return self.predefined_type in {
+            "BorderSideWidth",
+            "BorderSpacing",
+            "BoxShadow",
+            "Filter",
+            "FontSize",
+            "Inset",
+            "Length",
+            "LengthPercentage",
+            "LengthPercentageOrAuto",
+            "LetterSpacing",
+            "LineHeight",
+            "LineWidth",
+            "MaxSize",
+            "Margin",
+            "NonNegativeLength",
+            "NonNegativeLengthOrAuto",
+            "NonNegativeLengthOrNumber",
+            "NonNegativeLengthOrNumberRect",
+            "NonNegativeLengthPercentage",
+            "NonNegativeLengthPercentageOrAuto",
+            "NonNegativeLengthPercentageOrNormal",
+            "Position",
+            "PositionOrAuto",
+            "SimpleShadow",
+            "Size",
+            "SVGLength",
+            "SVGStrokeDashArray",
+            "SVGWidth",
+            "TextDecorationLength",
+            "TextDecorationInset",
+            "TextIndent",
+            "WordSpacing",
+        }
+
+    def is_inherited_zoom_dependent_property(self):
+        if self.logical:
+            return False
+        if not self.style_struct.inherited:
+            return False
+        return self.is_zoom_dependent()
+
+    def specified_is_copy(self):
+        if self.vector or self.boxed:
+            return False
+        if self.predefined_type:
+            return self.predefined_type in {
+                "AlignmentBaseline",
+                "Appearance",
+                "AnimationComposition",
+                "AnimationDirection",
+                "AnimationFillMode",
+                "AnimationPlayState",
+                "BaselineSource",
+                "BreakBetween",
+                "BreakWithin",
+                "BackgroundRepeat",
+                "BorderImageRepeat",
+                "BorderStyle",
+                "table::CaptionSide",
+                "Clear",
+                "Contain",
+                "ContentVisibility",
+                "ContainerType",
+                "Display",
+                "DominantBaseline",
+                "FillRule",
+                "FlexWrap",
+                "Float",
+                "FontLanguageOverride",
+                "FontSynthesis",
+                "FontSynthesisStyle",
+                "FontVariantEastAsian",
+                "FontVariantLigatures",
+                "FontVariantNumeric",
+                "GridAutoFlow",
+                "ImageDecoding",
+                "ImageRendering",
+                "Inert",
+                "PositionArea",
+                "PositionAreaKeyword",
+                "PositionProperty",
+                "ContentDistribution",
+                "ItemPlacement",
+                "SelfAlignment",
+                "JustifyItems",
+                "LineBreak",
+                "MarginTrim",
+                "MasonryAutoFlow",
+                "MozTheme",
+                "BoolInteger",
+                "text::MozControlCharacterVisibility",
+                "MozScriptMinSize",
+                "MozScriptSizeMultiplier",
+                "TransformBox",
+                "TextDecorationSkipInk",
+                "OutlineStyle",
+                "Overflow",
+                "OverflowAnchor",
+                "OverflowWrap",
+                "OverscrollBehavior",
+                "PageOrientation",
+                "PointerEvents",
+                "PositionTryOrder",
+                "PositionVisibility",
+                "PrintColorAdjust",
+                "ForcedColorAdjust",
+                "Resize",
+                "RubyPosition",
+                "SVGPaintOrder",
+                "ScrollbarGutter",
+                "ScrollSnapAlign",
+                "ScrollSnapAxis",
+                "ScrollSnapStop",
+                "ScrollSnapStrictness",
+                "ScrollSnapType",
+                "TextAlign",
+                "TextAlignLast",
+                "TextAutospace",
+                "TextBoxEdge",
+                "TextBoxTrim",
+                "TextDecorationLine",
+                "TextEmphasisPosition",
+                "TextJustify",
+                "TextTransform",
+                "TextUnderlinePosition",
+                "TouchAction",
+                "TransformStyle",
+                "UserFocus",
+                "UserSelect",
+                "VectorEffect",
+                "WordBreak",
+                "WritingModeProperty",
+                "XSpan",
+                "XTextScale",
+            }
+        if self.name == "overflow-y":
+            return True
+        return bool(self.keyword)
+
+    def animated_type(self):
+        assert self.animatable
+        computed = "<{} as ToComputedValue>::ComputedValue".format(self.base_type())
+        if self.animation_type == "discrete":
+            return computed
+        return "<{} as ToAnimatedValue>::AnimatedValue".format(computed)
+
+
+class Shorthand(Property):
+    def __init__(
+        self,
+        name,
+        sub_properties,
+        spec=None,
+        servo_pref=None,
+        gecko_pref=None,
+        kind=None,
+        allow_quirks=False,
+        derive_serialize=False,
+        derive_value_info=True,
+        enabled_in="content",
+        rule_types_allowed=None,
+        aliases=None,
+        extra_prefixes=None,
+        flags=None,
+    ):
+        Property.__init__(
+            self,
+            name=name,
+            spec=spec,
+            servo_pref=servo_pref,
+            gecko_pref=gecko_pref,
+            enabled_in=enabled_in,
+            rule_types_allowed=rule_types_allowed,
+            aliases=aliases,
+            extra_prefixes=extra_prefixes,
+            flags=flags,
+        )
+        self.sub_properties = sub_properties
+        self.derive_serialize = derive_serialize
+        self.derive_value_info = derive_value_info
+        self.allow_quirks = allow_quirks
+        self.kind = kind
+
+    def get_animatable(self):
+        for sub in self.sub_properties:
+            if sub.animatable:
+                return True
+        return False
+
+    animatable = property(get_animatable)
+
+    @staticmethod
+    def type():
+        return "shorthand"
+
+
+class Alias(object):
+    def __init__(self, name, original, gecko_pref):
+        self.name = name
+        self.ident = to_rust_ident(name)
+        self.camel_case = to_camel_case(self.ident)
+        self.idl_method = idl_method(name, self.camel_case)
+        self.original = original
+        self.enabled_in = original.enabled_in
+        self.animatable = original.animatable
+        self.servo_pref = original.servo_pref
+        self.gecko_pref = gecko_pref
+        self.rule_types_allowed = original.rule_types_allowed
+        self.flags = original.flags
+
+    @staticmethod
+    def type():
+        return "alias"
+
+    def rule_types_allowed_names(self):
+        for name in RULE_VALUES:
+            if self.rule_types_allowed & RULE_VALUES[name] != 0:
+                yield name
+
+    def experimental(self, engine):
+        if engine == "gecko":
+            return bool(self.gecko_pref)
+        elif engine == "servo":
+            return bool(self.servo_pref)
+        else:
+            raise Exception("Bad engine: " + engine)
+
+    def explicitly_enabled_in_ua_sheets(self):
+        return self.enabled_in in ["ua", "chrome"]
+
+    def explicitly_enabled_in_chrome(self):
+        return self.enabled_in == "chrome"
+
+    def enabled_in_content(self):
+        return self.enabled_in == "content"
+
+    def noncustomcsspropertyid(self):
+        return "NonCustomCSSPropertyId::eCSSPropertyAlias_%s" % self.ident
+
+
+class Method(object):
+    def __init__(self, name, return_type=None, arg_types=None, is_mut=False):
+        self.name = name
+        self.return_type = return_type
+        self.arg_types = arg_types or []
+        self.is_mut = is_mut
+
+    def arg_list(self):
+        args = ["_: " + x for x in self.arg_types]
+        args = ["&mut self" if self.is_mut else "&self"] + args
+        return ", ".join(args)
+
+    def signature(self):
+        sig = "fn %s(%s)" % (self.name, self.arg_list())
+        if self.return_type:
+            sig = sig + " -> " + self.return_type
+        return sig
+
+    def declare(self):
+        return self.signature() + ";"
+
+    def stub(self):
+        return self.signature() + "{ unimplemented!() }"
+
+
+class StyleStruct(object):
+    def __init__(self, name, inherited, gecko_name=None):
+        self.gecko_struct_name = "Gecko" + name
+        self.name = name
+        self.name_lower = to_snake_case(name)
+        self.ident = to_rust_ident(self.name_lower)
+        self.longhands = []
+        self.inherited = inherited
+        self.gecko_name = gecko_name or name
+        self.gecko_ffi_name = "nsStyle" + self.gecko_name
+        self.document_dependent = self.gecko_name in ["Font", "Visibility", "Text"]
+
+
+class Descriptor(object):
+    def __init__(self, name, type, parser=None, gecko_pref=None, ignore_malloc_size_of=None, aliases=[]):
+        self.name = name
+        self.aliases = aliases
+        self.type = type
+        self.parser = parser
+        self.gecko_pref = gecko_pref
+        self.ignore_malloc_size_of = ignore_malloc_size_of
+        self.ident = to_rust_ident(name)
+        self.camel_case = to_camel_case(name)
+
+
+class PropertiesData(object):
+    def __init__(self, engine):
+        self.engine = engine
+        self.longhands = []
+        self.longhands_by_name = {}
+        self.logical_groups = {}
+        self.longhand_aliases = []
+        self.shorthands = []
+        self.shorthands_by_name = {}
+        self.shorthand_aliases = []
+        self.counted_unknown_properties = [
+            CountedUnknownProperty(p) for p in COUNTED_UNKNOWN_PROPERTIES
+        ]
+
+        self.style_structs = [
+            StyleStruct("Background", inherited=False),
+            StyleStruct("Border", inherited=False),
+            StyleStruct("Box", inherited=False, gecko_name="Display"),
+            StyleStruct("Column", inherited=False),
+            StyleStruct("Counters", inherited=False, gecko_name="Content"),
+            StyleStruct("Effects", inherited=False),
+            StyleStruct("Font", inherited=True),
+            StyleStruct("InheritedBox", inherited=True, gecko_name="Visibility"),
+            StyleStruct("InheritedSVG", inherited=True, gecko_name="SVG"),
+            StyleStruct("InheritedTable", inherited=True, gecko_name="TableBorder"),
+            StyleStruct("InheritedText", inherited=True, gecko_name="Text"),
+            StyleStruct("InheritedUI", inherited=True, gecko_name="UI"),
+            StyleStruct("List", inherited=True),
+            StyleStruct("Margin", inherited=False),
+            StyleStruct("Outline", inherited=False),
+            StyleStruct("Padding", inherited=False),
+            StyleStruct("Page", inherited=False),
+            StyleStruct("Position", inherited=False),
+            StyleStruct("SVG", inherited=False, gecko_name="SVGReset"),
+            StyleStruct("Table", inherited=False),
+            StyleStruct("Text", inherited=False, gecko_name="TextReset"),
+            StyleStruct("UI", inherited=False, gecko_name="UIReset"),
+            StyleStruct("XUL", inherited=False),
+        ]
+
+        longhands_toml = toml.loads(open(os.path.join(os.path.dirname(__file__), "longhands.toml")).read())
+        for name, args in longhands_toml.items():
+            style_struct = self.style_struct_by_name_lower(args["struct"])
+            del args['struct']
+
+            # Handle keyword properties
+            if 'keyword' in args:
+                keyword_dict = args.pop('keyword')
+                if 'values' not in keyword_dict:
+                    raise TypeError(f"{name}: keyword should have 'values'")
+                values = keyword_dict.pop('values')
+                keyword = Keyword(name, values, **keyword_dict)
+                self.declare_longhand(style_struct, name, keyword=keyword, **args)
+            else:
+                # Handle predefined_type properties
+                if 'type' not in args:
+                    raise TypeError(f"{name} should have a type")
+                args['predefined_type'] = args.pop('type')
+                if 'initial' not in args and not args.get('vector'):
+                    raise TypeError(f"{name} should have an initial value (only vector properties should lack one)")
+                args['initial_value'] = args.pop('initial', None)
+                self.declare_longhand(style_struct, name, **args)
+
+        for group, props in self.logical_groups.items():
+            logical_count = sum(1 for p in props if p.logical)
+            if logical_count * 2 != len(props):
+                raise RuntimeError(f"Logical group {group} has unbalanced logical / physical properties")
+
+        # After this code, `data.longhands` is sorted in the following order:
+        # - first all keyword variants and all variants known to be Copy,
+        # - second all the other variants, such as all variants with the same field
+        #   have consecutive discriminants.
+        # The variable `variants` contain the same entries as `data.longhands` in
+        # the same order, but must exist separately to the data source, because
+        # we then need to add three additional variants `WideKeywordDeclaration`,
+        # `VariableDeclaration` and `CustomDeclaration`.
+        self.declaration_variants = []
+        for property in self.longhands:
+            self.declaration_variants.append({
+                "name": property.camel_case,
+                "type": property.specified_type(),
+                "doc": "`" + property.name + "`",
+                "copy": property.specified_is_copy(),
+            })
+        groups = {}
+        keyfunc = lambda x: x["type"]
+        sortkeys = {}
+        # WARNING: It is *really* important for the variants of `LonghandId`
+        # and `PropertyDeclaration` to be defined in the exact same order,
+        # with the exception of `CSSWideKeyword`, `WithVariables` and `Custom`,
+        # which don't exist in `LonghandId`.
+        for ty, group in groupby(sorted(self.declaration_variants, key=keyfunc), keyfunc):
+            group = list(group)
+            groups[ty] = group
+            for v in group:
+                if len(group) == 1:
+                    sortkeys[v["name"]] = (not v["copy"], 1, v["name"], "")
+                else:
+                    sortkeys[v["name"]] = (not v["copy"], len(group), ty, v["name"])
+        # It is extremely important to sort the `data.longhands` array here so
+        # that it is in the same order as `variants`, for `LonghandId` and
+        # `PropertyDeclarationId` to coincide.
+        self.longhands.sort(key=lambda x: sortkeys[x.camel_case])
+        self.declaration_variants.sort(key=lambda x: sortkeys[x["name"]])
+        self.declaration_extra_variants = [
+            {
+                "name": "CSSWideKeyword",
+                "type": "WideKeywordDeclaration",
+                "doc": "A CSS-wide keyword.",
+                "copy": False,
+            },
+            {
+                "name": "WithVariables",
+                "type": "VariableDeclaration",
+                "doc": "An unparsed declaration.",
+                "copy": False,
+            },
+            {
+                "name": "Custom",
+                "type": "CustomDeclaration",
+                "doc": "A custom property declaration.",
+                "copy": False,
+            },
+        ]
+        for v in self.declaration_extra_variants:
+            self.declaration_variants.append(v)
+            groups[v["type"]] = [v]
+
+        shorthands_toml = toml.loads(open(os.path.join(os.path.dirname(__file__), "shorthands.toml")).read())
+        for name, args in shorthands_toml.items():
+            self.declare_shorthand(name, **args)
+        self.declare_all_shorthand()
+
+        self.font_face_descriptors = self._load_descriptors("font_face_descriptors.toml")
+        self.counter_style_descriptors = self._load_descriptors("counter_style_descriptors.toml")
+        self.property_descriptors = self._load_descriptors("property_descriptors.toml")
+        self.view_transition_descriptors = self._load_descriptors("view_transition_descriptors.toml")
+
+
+    def declare_all_shorthand(self):
+        # We don't define the 'all' shorthand using the regular helpers:shorthand
+        # mechanism, since it causes some very large types to be generated.
+        #
+        # Make sure logical properties appear before its physical
+        # counter-parts, in order to prevent bugs like:
+        #
+        #   https://bugzilla.mozilla.org/show_bug.cgi?id=1410028
+        #
+        # FIXME(emilio): Adopt the resolution from:
+        #
+        #   https://github.com/w3c/csswg-drafts/issues/1898
+        #
+        # when there is one, whatever that is.
+        logical_longhands = []
+        other_longhands = []
+        for p in self.longhands:
+            if p.name in ['direction', 'unicode-bidi']:
+                continue;
+            if not p.enabled_in_content() and not p.experimental(self.engine):
+                continue;
+            if "style" not in p.rule_types_allowed_names():
+                continue;
+            if p.logical:
+                logical_longhands.append(p)
+            else:
+                other_longhands.append(p)
+
+        # Cache locality when iterating over the `all` shorthand is important
+        # for transition handling, so we sort by style struct.
+        # We technically don't care about the logical prop order (because those
+        # are not animated themselves), but we sort them the same way for
+        # consistency.
+        logical_longhands.sort(key=lambda p: p.style_struct.name)
+        other_longhands.sort(key=lambda p: p.style_struct.name)
+
+        all_names = list(map(lambda p: p.name, logical_longhands + other_longhands))
+
+        self.all_shorthand_length = len(all_names)
+        self.declare_shorthand(
+            "all",
+            all_names,
+            spec="https://drafts.csswg.org/css-cascade-3/#all-shorthand"
+        )
+
+
+    def _load_descriptors(self, filename):
+        path = os.path.join(os.path.dirname(__file__), filename)
+        data = toml.loads(open(path).read())
+        return [Descriptor(name, **args) for name, args in data.items()]
+
+    def style_struct_by_name_lower(self, name):
+        for s in self.style_structs:
+            if s.name_lower == name:
+                return s
+        raise TypeError(f"Unexpected struct name {name}")
+
+    def active_style_structs(self):
+        return [s for s in self.style_structs if s.longhands]
+
+    def add_prefixed_aliases(self, property):
+        for prefix, pref in property.extra_prefixes:
+            property.aliases.append(("-%s-%s" % (prefix, property.name), pref))
+
+    def declare_longhand(self, style_struct, name, extra_gecko_aliases=None, engine=None, **kwargs):
+        if engine and self.engine != engine:
+            return
+        if extra_gecko_aliases and self.engine == "gecko":
+            kwargs.setdefault('aliases', []).extend(extra_gecko_aliases)
+        longhand = Longhand(style_struct, name, **kwargs)
+        self.add_prefixed_aliases(longhand)
+        longhand.aliases = [Alias(xp[0], longhand, xp[1]) for xp in longhand.aliases]
+        self.longhand_aliases += longhand.aliases
+        style_struct.longhands.append(longhand)
+        self.longhands.append(longhand)
+        self.longhands_by_name[name] = longhand
+        if longhand.logical_group:
+            self.logical_groups.setdefault(
+                longhand.logical_group, []
+            ).append(longhand)
+
+        return longhand
+
+    def declare_shorthand(self, name, sub_properties, extra_gecko_sub_properties=None, extra_gecko_aliases=None, engine=None, *args, **kwargs):
+        if engine and self.engine != engine:
+            return
+        if self.engine == "gecko":
+            if extra_gecko_sub_properties:
+                sub_properties.extend(extra_gecko_sub_properties)
+            if extra_gecko_aliases:
+                kwargs.setdefault('aliases', []).extend(extra_gecko_aliases)
+        sub_properties = [self.longhands_by_name[s] for s in sub_properties]
+        shorthand = Shorthand(name, sub_properties, *args, **kwargs)
+        self.add_prefixed_aliases(shorthand)
+        shorthand.aliases = [Alias(xp[0], shorthand, xp[1]) for xp in shorthand.aliases]
+        self.shorthand_aliases += shorthand.aliases
+        self.shorthands.append(shorthand)
+        self.shorthands_by_name[name] = shorthand
+        return shorthand
+
+    def shorthands_except_all(self):
+        return [s for s in self.shorthands if s.name != "all"]
+
+    def all_aliases(self):
+        return self.longhand_aliases + self.shorthand_aliases
+
+    def all_properties_and_aliases(self):
+        return self.longhands + self.shorthands + self.longhand_aliases + self.shorthand_aliases
+
+
+def _add_logical_props(data, props):
+    groups = set()
+    for prop in props:
+        if prop not in data.longhands_by_name:
+            assert data.engine == "servo"
+            continue
+        prop = data.longhands_by_name[prop]
+        if prop.logical_group:
+            groups.add(prop.logical_group)
+    for group in groups:
+        for prop in data.logical_groups[group]:
+            props.add(prop.name)
+
+
+# These are probably Gecko bugs and should be supported per spec.
+def _remove_common_first_line_and_first_letter_properties(props, engine):
+    if engine == "gecko":
+        props.remove("tab-size")
+        props.remove("hyphens")
+        props.remove("line-break")
+        props.remove("text-align-last")
+        props.remove("text-emphasis-position")
+        props.remove("text-emphasis-style")
+        props.remove("text-emphasis-color")
+        props.remove("text-wrap-style")
+
+    props.remove("overflow-wrap")
+    props.remove("text-align")
+    props.remove("text-justify")
+    props.remove("white-space-collapse")
+    props.remove("text-wrap-mode")
+    props.remove("word-break")
+    props.remove("text-indent")
+
+
+class PropertyRestrictions:
+    @staticmethod
+    def logical_group(data, group):
+        return [p.name for p in data.logical_groups[group]]
+
+    @staticmethod
+    def shorthand(data, shorthand):
+        if shorthand not in data.shorthands_by_name:
+            return []
+        return [p.name for p in data.shorthands_by_name[shorthand].sub_properties]
+
+    @staticmethod
+    def spec(data, spec_path):
+        return [p.name for p in data.longhands if spec_path in p.spec]
+
+    # https://svgwg.org/svg2-draft/propidx.html
+    @staticmethod
+    def svg_text_properties():
+        props = set(
+            [
+                "fill",
+                "fill-opacity",
+                "fill-rule",
+                "paint-order",
+                "stroke",
+                "stroke-dasharray",
+                "stroke-dashoffset",
+                "stroke-linecap",
+                "stroke-linejoin",
+                "stroke-miterlimit",
+                "stroke-opacity",
+                "stroke-width",
+                "text-rendering",
+                "vector-effect",
+            ]
+        )
+        return props
+
+    @staticmethod
+    def webkit_text_properties():
+        props = set(
+            [
+                # Kinda like css-text?
+                "-webkit-text-stroke-width",
+                "-webkit-text-fill-color",
+                "-webkit-text-stroke-color",
+            ]
+        )
+        return props
+
+    # https://drafts.csswg.org/css-pseudo/#first-letter-styling
+    @staticmethod
+    def first_letter(data):
+        props = set(
+            [
+                "color",
+                "opacity",
+                "float",
+                "initial-letter",
+                # Kinda like css-fonts?
+                "-moz-osx-font-smoothing",
+                "alignment-baseline",
+                "baseline-shift",
+                "baseline-source",
+                "line-height",
+                # Kinda like css-backgrounds?
+                "background-blend-mode",
+            ]
+            + PropertyRestrictions.shorthand(data, "padding")
+            + PropertyRestrictions.shorthand(data, "margin")
+            + PropertyRestrictions.spec(data, "css-fonts")
+            + PropertyRestrictions.spec(data, "css-backgrounds")
+            + PropertyRestrictions.spec(data, "css-text")
+            + PropertyRestrictions.spec(data, "css-shapes")
+            + PropertyRestrictions.spec(data, "css-text-decor")
+        )
+        props = props.union(PropertyRestrictions.svg_text_properties())
+        props = props.union(PropertyRestrictions.webkit_text_properties())
+
+        _add_logical_props(data, props)
+
+        _remove_common_first_line_and_first_letter_properties(props, data.engine)
+        return props
+
+    # https://drafts.csswg.org/css-pseudo/#first-line-styling
+    @staticmethod
+    def first_line(data):
+        props = set(
+            [
+                # Per spec.
+                "color",
+                "opacity",
+                # Kinda like css-fonts?
+                "-moz-osx-font-smoothing",
+                "alignment-baseline",
+                "baseline-shift",
+                "baseline-source",
+                "line-height",
+                # Kinda like css-backgrounds?
+                "background-blend-mode",
+            ]
+            + PropertyRestrictions.spec(data, "css-fonts")
+            + PropertyRestrictions.spec(data, "css-backgrounds")
+            + PropertyRestrictions.spec(data, "css-text")
+            + PropertyRestrictions.spec(data, "css-text-decor")
+        )
+        props = props.union(PropertyRestrictions.svg_text_properties())
+        props = props.union(PropertyRestrictions.webkit_text_properties())
+
+        # These are probably Gecko bugs and should be supported per spec.
+        for prop in PropertyRestrictions.shorthand(data, "border"):
+            props.remove(prop)
+        for prop in PropertyRestrictions.shorthand(data, "border-radius"):
+            props.remove(prop)
+        props.remove("box-shadow")
+
+        _remove_common_first_line_and_first_letter_properties(props, data.engine)
+        return props
+
+    # https://drafts.csswg.org/css-pseudo/#placeholder
+    #
+    # The spec says that placeholder and first-line have the same restrictions,
+    # except those defined in css-inline.
+    # We also allow a handful other properties for ::placeholder, which is allowed by
+    # the spec.
+    @staticmethod
+    def placeholder(data):
+        props = PropertyRestrictions.first_line(data)
+        for p in PropertyRestrictions.spec(data, "css-inline"):
+            props.discard(p)
+        props.add("opacity")
+        props.add("text-overflow")
+        props.add("text-align")
+        props.add("text-justify")
+        for p in PropertyRestrictions.shorthand(data, "text-wrap"):
+            props.add(p)
+        for p in PropertyRestrictions.shorthand(data, "white-space"):
+            props.add(p)
+        # ::placeholder can't be SVG text
+        props -= PropertyRestrictions.svg_text_properties()
+        # Historically ::placeholder's line-height was !important in the UA sheet.
+        props.remove("line-height")
+
+        return props
+
+    # https://drafts.csswg.org/css-lists-3/#marker-properties
+    @staticmethod
+    def marker(data):
+        return set(
+            [
+                "color",
+                "content",
+                "counter-increment",
+                "counter-reset",
+                "counter-set",
+                "cursor",
+                "direction",
+                "hyphens",
+                "line-height",
+                "quotes",
+                "text-combine-upright",
+                "text-emphasis-color",
+                "text-emphasis-position",
+                "text-emphasis-style",
+                "text-orientation",
+                "text-shadow",
+                "text-transform",
+                "unicode-bidi",
+                "-moz-osx-font-smoothing",
+            ]
+            + PropertyRestrictions.shorthand(data, "animation-range")
+            + PropertyRestrictions.shorthand(data, "text-wrap")
+            + PropertyRestrictions.shorthand(data, "white-space")
+            + PropertyRestrictions.spec(data, "css-fonts")
+            + PropertyRestrictions.spec(data, "css-animations")
+            + PropertyRestrictions.spec(data, "css-transitions")
+        )
+
+    # https://www.w3.org/TR/webvtt1/#the-cue-pseudo-element
+    @staticmethod
+    def cue(data):
+        return set(
+            [
+                "color",
+                "opacity",
+                "visibility",
+                "text-shadow",
+                "text-combine-upright",
+                "ruby-position",
+                # XXX Should these really apply to cue?
+                "-moz-osx-font-smoothing",
+                # FIXME(emilio): background-blend-mode should be part of the
+                # background shorthand, and get reset, per
+                # https://drafts.fxtf.org/compositing/#background-blend-mode
+                "background-blend-mode",
+            ]
+            + PropertyRestrictions.shorthand(data, "text-decoration")
+            + PropertyRestrictions.shorthand(data, "text-wrap")
+            + PropertyRestrictions.shorthand(data, "white-space")
+            + PropertyRestrictions.shorthand(data, "background")
+            + PropertyRestrictions.shorthand(data, "outline")
+            + PropertyRestrictions.shorthand(data, "font")
+            + PropertyRestrictions.shorthand(data, "font-synthesis")
+        )
+
+
+class CountedUnknownProperty:
+    def __init__(self, name):
+        self.name = name
+        self.ident = to_rust_ident(name)
+        self.camel_case = to_camel_case(self.ident)