ReadableStream WebIDL.py patch

3 files changed, 202 insertions, 5 deletions

diff --git a/components/script/dom/bindings/codegen/parser/WebIDL.py b/components/script/dom/bindings/codegen/parser/WebIDL.py
index 9618ec3531f..2366e3f7027 100644
--- a/components/script/dom/bindings/codegen/parser/WebIDL.py
+++ b/components/script/dom/bindings/codegen/parser/WebIDL.py
@@ -2498,6 +2498,9 @@ class IDLType(IDLObject):
     def isRecord(self):
         return False
 
+    def isReadableStream(self):
+        return False
+
     def isArrayBuffer(self):
         return False
 
@@ -2526,7 +2529,7 @@ class IDLType(IDLObject):
     def isSpiderMonkeyInterface(self):
         """Returns a boolean indicating whether this type is an 'interface'
         type that is implemented in SpiderMonkey."""
-        return self.isInterface() and self.isBufferSource()
+        return self.isInterface() and (self.isBufferSource() or self.isReadableStream())
 
     def isAny(self):
         return self.tag() == IDLType.Tags.any
@@ -2743,6 +2746,9 @@ class IDLNullableType(IDLParametrizedType):
     def isRecord(self):
         return self.inner.isRecord()
 
+    def isReadableStream(self):
+        return self.inner.isReadableStream()
+
     def isArrayBuffer(self):
         return self.inner.isArrayBuffer()
 
@@ -3252,6 +3258,9 @@ class IDLTypedefType(IDLType):
     def isRecord(self):
         return self.inner.isRecord()
 
+    def isReadableStream(self):
+        return self.inner.isReadableStream()
+
     def isDictionary(self):
         return self.inner.isDictionary()
 
@@ -3597,6 +3606,7 @@ class IDLBuiltinType(IDLType):
         "Uint32Array",
         "Float32Array",
         "Float64Array",
+        "ReadableStream",
     )
 
     TagLookup = {
@@ -3632,6 +3642,7 @@ class IDLBuiltinType(IDLType):
         Types.Uint32Array: IDLType.Tags.interface,
         Types.Float32Array: IDLType.Tags.interface,
         Types.Float64Array: IDLType.Tags.interface,
+        Types.ReadableStream: IDLType.Tags.interface,
     }
 
     PrettyNames = {
@@ -3667,6 +3678,7 @@ class IDLBuiltinType(IDLType):
         Types.Uint32Array: "Uint32Array",
         Types.Float32Array: "Float32Array",
         Types.Float64Array: "Float64Array",
+        Types.ReadableStream: "ReadableStream",
     }
 
     def __init__(
@@ -3830,11 +3842,19 @@ class IDLBuiltinType(IDLType):
             and self._typeTag <= IDLBuiltinType.Types.Float64Array
         )
 
+    def isReadableStream(self):
+        return self._typeTag == IDLBuiltinType.Types.ReadableStream
+
     def isInterface(self):
         # TypedArray things are interface types per the TypedArray spec,
         # but we handle them as builtins because SpiderMonkey implements
         # all of it internally.
-        return self.isArrayBuffer() or self.isArrayBufferView() or self.isTypedArray()
+        return (
+            self.isArrayBuffer()
+            or self.isArrayBufferView()
+            or self.isTypedArray()
+            or self.isReadableStream()
+        )
 
     def isNonCallbackInterface(self):
         # All the interfaces we can be are non-callback
@@ -3928,6 +3948,7 @@ class IDLBuiltinType(IDLType):
                     # ArrayBuffer is distinguishable from everything
                     # that's not an ArrayBuffer or a callback interface
                     (self.isArrayBuffer() and not other.isArrayBuffer())
+                    or (self.isReadableStream() and not other.isReadableStream())
                     or
                     # ArrayBufferView is distinguishable from everything
                     # that's not an ArrayBufferView or typed array.
@@ -4134,6 +4155,11 @@ BuiltinTypes = {
         "Float64Array",
         IDLBuiltinType.Types.Float64Array,
     ),
+    IDLBuiltinType.Types.ReadableStream: IDLBuiltinType(
+        BuiltinLocation("<builtin type>"),
+        "ReadableStream",
+        IDLBuiltinType.Types.ReadableStream,
+    ),
 }
 
 
@@ -6883,6 +6909,9 @@ class Tokenizer(object):
     def t_IDENTIFIER(self, t):
         r"[_-]?[A-Za-z][0-9A-Z_a-z-]*"
         t.type = self.keywords.get(t.value, "IDENTIFIER")
+        # If Builtin readable streams are disabled, mark ReadableStream as an identifier.
+        if t.type == "READABLESTREAM" and not self._use_builtin_readable_streams:
+            t.type = "IDENTIFIER"
         return t
 
     def t_STRING(self, t):
@@ -6973,6 +7002,7 @@ class Tokenizer(object):
         "setlike": "SETLIKE",
         "iterable": "ITERABLE",
         "namespace": "NAMESPACE",
+        "ReadableStream": "READABLESTREAM",
         "constructor": "CONSTRUCTOR",
         "symbol": "SYMBOL",
         "async": "ASYNC",
@@ -6993,7 +7023,8 @@ class Tokenizer(object):
             ],
         )
 
-    def __init__(self, outputdir, lexer=None):
+    def __init__(self, outputdir, lexer=None, use_builtin_readable_streams=True):
+        self._use_builtin_readable_streams = use_builtin_readable_streams
         if lexer:
             self.lexer = lexer
         else:
@@ -8482,6 +8513,7 @@ class Parser(Tokenizer):
         """
         DistinguishableType : PrimitiveType Null
                             | ARRAYBUFFER Null
+                            | READABLESTREAM Null
                             | OBJECT Null
                             | UNDEFINED Null
         """
@@ -8489,6 +8521,8 @@ class Parser(Tokenizer):
             type = BuiltinTypes[IDLBuiltinType.Types.object]
         elif p[1] == "ArrayBuffer":
             type = BuiltinTypes[IDLBuiltinType.Types.ArrayBuffer]
+        elif p[1] == "ReadableStream":
+            type = BuiltinTypes[IDLBuiltinType.Types.ReadableStream]
         elif p[1] == "undefined":
             type = BuiltinTypes[IDLBuiltinType.Types.undefined]
         else:
@@ -8827,8 +8861,8 @@ class Parser(Tokenizer):
                 [Location(self.lexer, p.lineno, p.lexpos, self._filename)],
             )
 
-    def __init__(self, outputdir="", lexer=None):
-        Tokenizer.__init__(self, outputdir, lexer)
+    def __init__(self, outputdir="", lexer=None, use_builtin_readable_stream=True):
+        Tokenizer.__init__(self, outputdir, lexer, use_builtin_readable_stream)
 
         logger = SqueakyCleanLogger()
         try:
diff --git a/components/script/dom/bindings/codegen/parser/readable-stream.patch b/components/script/dom/bindings/codegen/parser/readable-stream.patch
new file mode 100644
index 00000000000..4b90067696e
--- /dev/null
+++ b/components/script/dom/bindings/codegen/parser/readable-stream.patch
@@ -0,0 +1,162 @@
+--- WebIDL.py
++++ WebIDL.py
+@@ -2498,6 +2498,9 @@ class IDLType(IDLObject):
+     def isRecord(self):
+         return False
+ 
++    def isReadableStream(self):
++        return False
++
+     def isArrayBuffer(self):
+         return False
+ 
+@@ -2526,7 +2529,7 @@ class IDLType(IDLObject):
+     def isSpiderMonkeyInterface(self):
+         """Returns a boolean indicating whether this type is an 'interface'
+         type that is implemented in SpiderMonkey."""
+-        return self.isInterface() and self.isBufferSource()
++        return self.isInterface() and (self.isBufferSource() or self.isReadableStream())
+ 
+     def isAny(self):
+         return self.tag() == IDLType.Tags.any
+@@ -2743,6 +2746,9 @@ class IDLNullableType(IDLParametrizedType):
+     def isRecord(self):
+         return self.inner.isRecord()
+ 
++    def isReadableStream(self):
++        return self.inner.isReadableStream()
++
+     def isArrayBuffer(self):
+         return self.inner.isArrayBuffer()
+ 
+@@ -3252,6 +3258,9 @@ class IDLTypedefType(IDLType):
+     def isRecord(self):
+         return self.inner.isRecord()
+ 
++    def isReadableStream(self):
++        return self.inner.isReadableStream()
++
+     def isDictionary(self):
+         return self.inner.isDictionary()
+ 
+@@ -3597,6 +3606,7 @@ class IDLBuiltinType(IDLType):
+         "Uint32Array",
+         "Float32Array",
+         "Float64Array",
++        "ReadableStream",
+     )
+ 
+     TagLookup = {
+@@ -3632,6 +3642,7 @@ class IDLBuiltinType(IDLType):
+         Types.Uint32Array: IDLType.Tags.interface,
+         Types.Float32Array: IDLType.Tags.interface,
+         Types.Float64Array: IDLType.Tags.interface,
++        Types.ReadableStream: IDLType.Tags.interface,
+     }
+ 
+     PrettyNames = {
+@@ -3667,6 +3678,7 @@ class IDLBuiltinType(IDLType):
+         Types.Uint32Array: "Uint32Array",
+         Types.Float32Array: "Float32Array",
+         Types.Float64Array: "Float64Array",
++        Types.ReadableStream: "ReadableStream",
+     }
+ 
+     def __init__(
+@@ -3830,11 +3842,19 @@ class IDLBuiltinType(IDLType):
+             and self._typeTag <= IDLBuiltinType.Types.Float64Array
+         )
+ 
++    def isReadableStream(self):
++        return self._typeTag == IDLBuiltinType.Types.ReadableStream
++
+     def isInterface(self):
+         # TypedArray things are interface types per the TypedArray spec,
+         # but we handle them as builtins because SpiderMonkey implements
+         # all of it internally.
+-        return self.isArrayBuffer() or self.isArrayBufferView() or self.isTypedArray()
++        return (
++            self.isArrayBuffer()
++            or self.isArrayBufferView()
++            or self.isTypedArray()
++            or self.isReadableStream()
++        )
+ 
+     def isNonCallbackInterface(self):
+         # All the interfaces we can be are non-callback
+@@ -3928,6 +3948,7 @@ class IDLBuiltinType(IDLType):
+                     # ArrayBuffer is distinguishable from everything
+                     # that's not an ArrayBuffer or a callback interface
+                     (self.isArrayBuffer() and not other.isArrayBuffer())
++                    or (self.isReadableStream() and not other.isReadableStream())
+                     or
+                     # ArrayBufferView is distinguishable from everything
+                     # that's not an ArrayBufferView or typed array.
+@@ -4134,6 +4155,11 @@ BuiltinTypes = {
+         "Float64Array",
+         IDLBuiltinType.Types.Float64Array,
+     ),
++    IDLBuiltinType.Types.ReadableStream: IDLBuiltinType(
++        BuiltinLocation("<builtin type>"),
++        "ReadableStream",
++        IDLBuiltinType.Types.ReadableStream,
++    ),
+ }
+ 
+ 
+@@ -6883,6 +6909,9 @@ class Tokenizer(object):
+     def t_IDENTIFIER(self, t):
+         r"[_-]?[A-Za-z][0-9A-Z_a-z-]*"
+         t.type = self.keywords.get(t.value, "IDENTIFIER")
++        # If Builtin readable streams are disabled, mark ReadableStream as an identifier.
++        if t.type == "READABLESTREAM" and not self._use_builtin_readable_streams:
++            t.type = "IDENTIFIER"
+         return t
+ 
+     def t_STRING(self, t):
+@@ -6973,6 +7002,7 @@ class Tokenizer(object):
+         "setlike": "SETLIKE",
+         "iterable": "ITERABLE",
+         "namespace": "NAMESPACE",
++        "ReadableStream": "READABLESTREAM",
+         "constructor": "CONSTRUCTOR",
+         "symbol": "SYMBOL",
+         "async": "ASYNC",
+@@ -6993,7 +7023,8 @@ class Tokenizer(object):
+             ],
+         )
+ 
+-    def __init__(self, outputdir, lexer=None):
++    def __init__(self, outputdir, lexer=None, use_builtin_readable_streams=True):
++        self._use_builtin_readable_streams = use_builtin_readable_streams
+         if lexer:
+             self.lexer = lexer
+         else:
+@@ -8482,6 +8513,7 @@ class Parser(Tokenizer):
+         """
+         DistinguishableType : PrimitiveType Null
+                             | ARRAYBUFFER Null
++                            | READABLESTREAM Null
+                             | OBJECT Null
+                             | UNDEFINED Null
+         """
+@@ -8489,6 +8521,8 @@ class Parser(Tokenizer):
+             type = BuiltinTypes[IDLBuiltinType.Types.object]
+         elif p[1] == "ArrayBuffer":
+             type = BuiltinTypes[IDLBuiltinType.Types.ArrayBuffer]
++        elif p[1] == "ReadableStream":
++            type = BuiltinTypes[IDLBuiltinType.Types.ReadableStream]
+         elif p[1] == "undefined":
+             type = BuiltinTypes[IDLBuiltinType.Types.undefined]
+         else:
+@@ -8827,8 +8861,8 @@ class Parser(Tokenizer):
+                 [Location(self.lexer, p.lineno, p.lexpos, self._filename)],
+             )
+ 
+-    def __init__(self, outputdir="", lexer=None):
+-        Tokenizer.__init__(self, outputdir, lexer)
++    def __init__(self, outputdir="", lexer=None, use_builtin_readable_stream=True):
++        Tokenizer.__init__(self, outputdir, lexer, use_builtin_readable_stream)
+ 
+         logger = SqueakyCleanLogger()
+         try:
diff --git a/components/script/dom/bindings/codegen/parser/update.sh b/components/script/dom/bindings/codegen/parser/update.sh
index dd7803c940c..cec4d6a378e 100755
--- a/components/script/dom/bindings/codegen/parser/update.sh
+++ b/components/script/dom/bindings/codegen/parser/update.sh
@@ -4,6 +4,7 @@ patch < debug.patch
 patch < callback-location.patch
 patch < union-typedef.patch
 patch < inline.patch
+patch < readable-stream.patch
 
 wget https://hg.mozilla.org/mozilla-central/archive/tip.zip/dom/bindings/parser/tests/ -O tests.zip
 rm -r tests