Update the WebIDL parser

3 files changed, 192 insertions, 43 deletions

diff --git a/components/script/dom/bindings/codegen/parser/tests/test_cereactions.py b/components/script/dom/bindings/codegen/parser/tests/test_cereactions.py
index a1e5e78630f..dba16f53302 100644
--- a/components/script/dom/bindings/codegen/parser/tests/test_cereactions.py
+++ b/components/script/dom/bindings/codegen/parser/tests/test_cereactions.py
@@ -131,17 +131,3 @@ def WebIDLTest(parser, harness):
     harness.ok(threw,
                "Should have thrown for [CEReactions] used on a stringifier")
 
-    parser = parser.reset()
-    threw = False
-    try:
-        parser.parse("""
-            interface Foo {
-              [CEReactions] jsonifier;
-            };
-        """)
-
-        results = parser.finish()
-    except:
-        threw = True
-
-    harness.ok(threw, "Should have thrown for [CEReactions] used on a jsonifier")
diff --git a/components/script/dom/bindings/codegen/parser/tests/test_interface.py b/components/script/dom/bindings/codegen/parser/tests/test_interface.py
index e8ed67b54b3..a23243abe61 100644
--- a/components/script/dom/bindings/codegen/parser/tests/test_interface.py
+++ b/components/script/dom/bindings/codegen/parser/tests/test_interface.py
@@ -374,32 +374,3 @@ def WebIDLTest(parser, harness):
         threw = True
     harness.ok(threw,
                "Should not allow unknown extended attributes on interfaces")
-
-    parser = parser.reset()
-    threw = False
-    try:
-        parser.parse("""
-            interface B {};
-            [ArrayClass]
-            interface A : B {
-            };
-        """)
-        results = parser.finish()
-    except:
-        threw = True
-    harness.ok(threw,
-               "Should not allow [ArrayClass] on interfaces with parents")
-
-    parser = parser.reset()
-    threw = False
-    try:
-        parser.parse("""
-            [ArrayClass]
-            interface A {
-            };
-        """)
-        results = parser.finish()
-    except:
-        threw = True
-    harness.ok(not threw,
-               "Should allow [ArrayClass] on interfaces without parents")
diff --git a/components/script/dom/bindings/codegen/parser/tests/test_toJSON.py b/components/script/dom/bindings/codegen/parser/tests/test_toJSON.py
new file mode 100644
index 00000000000..b8b4f796ccb
--- /dev/null
+++ b/components/script/dom/bindings/codegen/parser/tests/test_toJSON.py
@@ -0,0 +1,192 @@
+def WebIDLTest(parser, harness):
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Test {
+              object toJSON();
+            };
+            """)
+        results = parser.finish()
+    except:
+        threw = True
+    harness.ok(not threw, "Should allow a toJSON method.")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Test {
+              object toJSON(object arg);
+              object toJSON(long arg);
+            };
+            """)
+        results = parser.finish()
+    except:
+        threw = True
+    harness.ok(threw, "Should not allow overloads of a toJSON method.")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Test {
+              object toJSON(object arg);
+            };
+            """)
+        results = parser.finish()
+    except:
+        threw = True
+    harness.ok(threw, "Should not allow a toJSON method with arguments.")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Test {
+              long toJSON();
+            };
+            """)
+        results = parser.finish()
+    except:
+        threw = True
+    harness.ok(not threw, "Should allow a toJSON method with 'long' as return type.")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Test {
+              [Default] object toJSON();
+            };
+            """)
+        results = parser.finish()
+    except:
+        threw = True
+    harness.ok(not threw, "Should allow a default toJSON method with 'object' as return type.")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Test {
+              [Default] long toJSON();
+            };
+            """)
+        results = parser.finish()
+    except:
+        threw = True
+    harness.ok(threw, "Should not allow a default toJSON method with non-'object' as return type.")
+
+    JsonTypes = [ "byte", "octet", "short", "unsigned short", "long", "unsigned long", "long long",
+                  "unsigned long long", "float", "unrestricted float", "double", "unrestricted double", "boolean",
+                  "DOMString", "ByteString", "USVString", "Enum", "InterfaceWithToJSON", "object" ]
+
+    nonJsonTypes = [ "InterfaceWithoutToJSON", "any", "Int8Array", "Int16Array", "Int32Array","Uint8Array",
+                     "Uint16Array", "Uint32Array", "Uint8ClampedArray", "Float32Array", "Float64Array", "ArrayBuffer" ]
+
+    def doTest(testIDL, shouldThrow, description):
+        p = parser.reset()
+        threw = False
+        try:
+            p.parse(testIDL +
+                """
+                enum Enum { "a", "b", "c" };
+                interface InterfaceWithToJSON { long toJSON(); };
+                interface InterfaceWithoutToJSON {};
+                """);
+            p.finish();
+        except Exception as x:
+            threw = True
+            harness.ok(x.message == "toJSON method has non-JSON return type", x)
+        harness.check(threw, shouldThrow, description)
+
+
+    for type in JsonTypes:
+        doTest("interface Test { %s toJSON(); };" % type, False,
+               "%s should be a JSON type" % type)
+
+        doTest("interface Test { sequence<%s> toJSON(); };" % type, False,
+               "sequence<%s> should be a JSON type" % type)
+
+        doTest("dictionary Foo { %s foo; }; "
+               "interface Test { Foo toJSON(); }; " % type, False,
+               "dictionary containing only JSON type (%s) should be a JSON type" % type)
+
+        doTest("dictionary Foo { %s foo; }; dictionary Bar : Foo { }; "
+               "interface Test { Bar toJSON(); }; " % type, False,
+               "dictionary whose ancestors only contain JSON types should be a JSON type")
+
+        doTest("dictionary Foo { any foo; }; dictionary Bar : Foo { %s bar; };"
+               "interface Test { Bar toJSON(); };" % type, True,
+               "dictionary whose ancestors contain non-JSON types should not be a JSON type")
+
+        doTest("interface Test { record<DOMString, %s> toJSON(); };" % type, False,
+               "record<DOMString, %s> should be a JSON type" % type)
+
+        doTest("interface Test { record<ByteString, %s> toJSON(); };" % type, False, 
+               "record<ByteString, %s> should be a JSON type" % type)
+
+        doTest("interface Test { record<USVString, %s> toJSON(); };" % type, False,
+               "record<USVString, %s> should be a JSON type" % type)
+
+        otherUnionType = "Foo" if type != "object" else "long"
+        doTest("interface Foo { object toJSON(); };"
+               "interface Test { (%s or %s) toJSON(); };" % (otherUnionType, type), False,
+               "union containing only JSON types (%s or %s) should be a JSON type" %(otherUnionType, type))
+
+        doTest("interface test { %s? toJSON(); };" % type, False,
+               "Nullable type (%s) should be a JSON type" % type)
+
+        doTest("interface Foo : InterfaceWithoutToJSON { %s toJSON(); };"
+               "interface Test { Foo toJSON(); };" % type, False,
+               "interface with toJSON should be a JSON type")
+
+    doTest("interface Foo : InterfaceWithToJSON { };"
+           "interface Test { Foo toJSON(); };", False,
+           "inherited interface with toJSON should be a JSON type")
+
+    for type in nonJsonTypes:
+        doTest("interface Test { %s toJSON(); };" % type, True,
+               "%s should not be a JSON type" % type)
+
+        doTest("interface Test { sequence<%s> toJSON(); };" % type, True,
+               "sequence<%s> should not be a JSON type" % type)
+
+        doTest("dictionary Foo { %s foo; }; "
+               "interface Test { Foo toJSON(); }; " % type, True, 
+               "Dictionary containing a non-JSON type (%s) should not be a JSON type" % type)
+
+        doTest("dictionary Foo { %s foo; }; dictionary Bar : Foo { }; "
+               "interface Test { Bar toJSON(); }; " % type, True,
+               "dictionary whose ancestors only contain non-JSON types should not be a JSON type")
+
+        doTest("interface Test { record<DOMString, %s> toJSON(); };" % type, True,
+               "record<DOMString, %s> should not be a JSON type" % type)
+
+        doTest("interface Test { record<ByteString, %s> toJSON(); };" % type, True,
+               "record<ByteString, %s> should not be a JSON type" % type)
+
+        doTest("interface Test { record<USVString, %s> toJSON(); };" % type, True,
+               "record<USVString, %s> should not be a JSON type" % type)
+        
+        if type != "any":
+            doTest("interface Foo { object toJSON(); }; "
+                   "interface Test { (Foo or %s) toJSON(); };" % type, True,
+                   "union containing a non-JSON type (%s) should not be a JSON type" % type)
+        
+            doTest("interface test { %s? toJSON(); };" % type, True,
+                   "Nullable type (%s) should not be a JSON type" % type)
+
+    doTest("dictionary Foo { long foo; any bar; };"
+           "interface Test { Foo toJSON(); };", True,
+           "dictionary containing a non-JSON type should not be a JSON type")
+
+    doTest("interface Foo : InterfaceWithoutToJSON { }; "
+           "interface Test { Foo toJSON(); };", True, 
+           "interface without toJSON should not be a JSON type")