Bug 946906 part 7. Forbid using [Cached] or [StoreInSlot] with [NewObject]. r=bholley

This guarantees that an interface type returned from a [Cached] or [StoreInSlot]
getter must be wrappercached, because non-wrappercached things can only be
returned from [NewObject] getters or methods.

dom/bindings/parser/WebIDL.py

@@ -3458,6 +3458,14 @@ class IDLInterfaceMember(IDLObjectWithIdentifier, IDLExposureMixins):
                 raise WebIDLError("A [NewObject] method is not idempotent, "
                                   "so it has to depend on something other than DOM state.",
                                   [self.location])
+            if (self.getExtendedAttribute("Cached") or
+                self.getExtendedAttribute("StoreInSlot")):
+                raise WebIDLError("A [NewObject] attribute shouldnt be "
+                                  "[Cached] or [StoreInSlot], since the point "
+                                  "of those is to keep returning the same "
+                                  "thing across multiple calls, which is not "
+                                  "what [NewObject] does.",
+                                  [self.location])
 
     def _setDependsOn(self, dependsOn):
         if self.dependsOn != "Everything":

dom/bindings/parser/tests/test_newobject.py

@@ -0,0 +1,70 @@
+# Import the WebIDL module, so we can do isinstance checks and whatnot
+import WebIDL
+
+def WebIDLTest(parser, harness):
+    # Basic functionality
+    parser.parse(
+        """
+        interface Iface {
+          [NewObject] readonly attribute Iface attr;
+          [NewObject] Iface method();
+        };
+        """)
+    results = parser.finish()
+    harness.ok(results, "Should not have thrown on basic [NewObject] usage")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Iface {
+              [Pure, NewObject] readonly attribute Iface attr;
+            };
+            """)
+        results = parser.finish()
+    except:
+        threw = True
+    harness.ok(threw, "[NewObject] attributes must depend on something")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Iface {
+              [Pure, NewObject] Iface method();
+            };
+            """)
+        results = parser.finish()
+    except:
+        threw = True
+    harness.ok(threw, "[NewObject] methods must depend on something")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Iface {
+              [Cached, NewObject, Affects=Nothing] readonly attribute Iface attr;
+            };
+            """)
+        results = parser.finish()
+    except:
+        threw = True
+    harness.ok(threw, "[NewObject] attributes must not be [Cached]")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Iface {
+              [StoreInSlot, NewObject, Affects=Nothing] readonly attribute Iface attr;
+            };
+            """)
+        results = parser.finish()
+    except:
+        threw = True
+    harness.ok(threw, "[NewObject] attributes must not be [StoreInSlot]")