WebIDL codegen: Replace cmake with a single Python script

When playing around with Cargo’s new timing visualization:
https://internals.rust-lang.org/t/exploring-crate-graph-build-times-with-cargo-build-ztimings/10975/21

… I was surprised to see the `script` crate’s build script take 76 seconds.
I did not expect WebIDL bindings generation to be *that* computationally
intensive.

It turns out almost all of this time is overhead. The build script uses CMake
to generate bindings for each WebIDL file in parallel, but that causes a lot
of work to be repeated 366 times:

* Starting up a Python VM
* Importing (parts of) the Python standard library
* Importing ~16k lines of our Python code
* Recompiling the latter to bytecode, since we used `python -B` to disable
  writing `.pyc` file
* Deserializing with `cPickle` and recreating in memory the results
  of parsing all WebIDL files

----

This commit remove the use of CMake and cPickle for the `script` crate.
Instead, all WebIDL bindings generation is done sequentially
in a single Python process. This takes 2 to 3 seconds.

components/script/dom/bindings/codegen/run.py

@@ -0,0 +1,119 @@
+# 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 os
+import sys
+import json
+
+
+def main():
+    os.chdir(os.path.join(os.path.dirname(__file__)))
+    sys.path[0:0] = ["./parser", "./ply"]
+
+    css_properties_json, out_dir, doc_servo = sys.argv[1:]
+    webidls_dir = "../../webidls"
+    config_file = "Bindings.conf"
+
+    import WebIDL
+    from Configuration import Configuration
+    from CodegenRust import CGBindingRoot
+
+    parser = WebIDL.Parser(make_dir(out_dir, "cache"))
+    webidls = [name for name in os.listdir(webidls_dir) if name.endswith(".webidl")]
+    for webidl in webidls:
+        filename = os.path.join(webidls_dir, webidl)
+        with open(filename, "rb") as f:
+            parser.parse(f.read(), filename)
+
+    add_css_properties_attributes(css_properties_json, parser)
+    parser_results = parser.finish()
+    config = Configuration(config_file, parser_results)
+    make_dir(out_dir, "Bindings")
+
+    for name, filename in [
+        ("PrototypeList", "PrototypeList.rs"),
+        ("RegisterBindings", "RegisterBindings.rs"),
+        ("InterfaceObjectMap", "InterfaceObjectMap.rs"),
+        ("InterfaceObjectMapData", "InterfaceObjectMapData.json"),
+        ("InterfaceTypes", "InterfaceTypes.rs"),
+        ("InheritTypes", "InheritTypes.rs"),
+        ("Bindings", "Bindings/mod.rs"),
+        ("UnionTypes", "UnionTypes.rs"),
+    ]:
+        generate(config, name, os.path.join(out_dir, filename))
+    make_dir(doc_servo)
+    generate(config, "SupportedDomApis", os.path.join(doc_servo, "apis.html"))
+
+    for webidl in webidls:
+        filename = os.path.join(webidls_dir, webidl)
+        prefix = "Bindings/%sBinding" % webidl[:-len(".webidl")]
+        module = CGBindingRoot(config, prefix, filename).define()
+        if module:
+            with open(os.path.join(out_dir, prefix + ".rs"), "wb") as f:
+                f.write(module)
+
+
+def make_dir(out_dir, nested=""):
+    path = os.path.join(out_dir, nested)
+    if not os.path.exists(path):
+        os.makedirs(path)
+    return path
+
+
+def generate(config, name, filename):
+    from CodegenRust import GlobalGenRoots
+    root = getattr(GlobalGenRoots, name)(config)
+    code = root.define()
+    with open(filename, "wb") as f:
+        f.write(code)
+
+
+def add_css_properties_attributes(css_properties_json, parser):
+    css_properties = json.load(open(css_properties_json, "rb"))
+    idl = "partial interface CSSStyleDeclaration {\n%s\n};\n" % "\n".join(
+        "  [%sCEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString %s;" % (
+            ('Pref="%s", ' % data["pref"] if data["pref"] else ""),
+            attribute_name
+        )
+        for (kind, properties_list) in sorted(css_properties.items())
+        for (property_name, data) in sorted(properties_list.items())
+        for attribute_name in attribute_names(property_name)
+    )
+    parser.parse(idl.encode("utf-8"), "CSSStyleDeclaration_generated.webidl")
+
+
+def attribute_names(property_name):
+    # https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-dashed-attribute
+    if property_name != "float":
+        yield property_name
+    else:
+        yield "_float"
+
+    # https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-camel-cased-attribute
+    if "-" in property_name:
+        yield "".join(camel_case(property_name))
+
+    # https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-webkit-cased-attribute
+    if property_name.startswith("-webkit-"):
+        yield "".join(camel_case(property_name), True)
+
+
+# https://drafts.csswg.org/cssom/#css-property-to-idl-attribute
+def camel_case(chars, webkit_prefixed=False):
+    if webkit_prefixed:
+        chars = chars[1:]
+    next_is_uppercase = False
+    for c in chars:
+        if c == '-':
+            next_is_uppercase = True
+        elif next_is_uppercase:
+            next_is_uppercase = False
+            # Should be ASCII-uppercase, but all non-custom CSS property names are within ASCII
+            yield c.upper()
+        else:
+            yield c
+
+
+if __name__ == "__main__":
+    main()