[strong] Implement per-object restrictions behaviour of delete operator

test/mjsunit/strong/object-delete.js

+// Copyright 2015 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --strong-mode --allow-natives-syntax
+
+// TODO(conradw): Track implementation of strong bit for other objects, add
+// tests.
+
+function getSloppyObjects() {
+  return [(function(){}), ({})];
+}
+
+function getStrictObjects() {
+  "use strict";
+  return [(function(){}), ({})];
+}
+
+function getStrongObjects() {
+  "use strong";
+// Strong functions can't have properties added to them, and will be tested as a
+// special case.
+  return [({})];
+}
+
+function strongFunction() {
+  "use strong";
+}
+
+function deleteFromObjectSloppy(o) {
+  return delete o.foo;
+}
+
+function deleteFromObjectKeyedSloppy(o) {
+  return delete o["foo"];
+}
+
+function deleteFromObjectKeyedVarSloppy(o) {
+  var a = "foo";
+  return delete o[a];
+}
+
+function deleteFromObjectKeyedComputedSloppy(o) {
+  return delete o[Date()+""];
+}
+
+function deleteFromObjectWith(o) {
+  with(o) {
+    return delete foo;
+  }
+}
+
+function deleteFromObjectStrict(o) {
+  "use strict";
+  return delete o.foo;
+}
+
+function deleteFromObjectKeyedStrict(o) {
+  "use strict";
+  return delete o["foo"];
+}
+
+function deleteFromObjectKeyedVarStrict(o) {
+  "use strict";
+  var a = "foo";
+  return delete o[a];
+}
+
+function deleteFromObjectKeyedComputedStrict(o) {
+  "use strict";
+  return delete o[Date()+""];
+}
+
+function testStrongObjectDelete() {
+  "use strict";
+  let sloppyObjects = getSloppyObjects();
+  let strictObjects = getStrictObjects();
+  let strongObjects = getStrongObjects();
+  let nonStrongObjects = sloppyObjects.concat(strictObjects);
+
+  let deleteFuncsSloppy = [deleteFromObjectSloppy, deleteFromObjectKeyedSloppy,
+                           deleteFromObjectKeyedVarSloppy,
+                           deleteFromObjectKeyedComputedSloppy,
+                           deleteFromObjectWith
+                          ];
+  let deleteFuncsStrict = [deleteFromObjectStrict, deleteFromObjectKeyedStrict,
+                           deleteFromObjectKeyedVarStrict,
+                           deleteFromObjectKeyedComputedStrict
+                          ];
+
+  for (let deleteFunc of deleteFuncsSloppy) {
+    for (let o of nonStrongObjects) {
+      Object.defineProperty(o, "foo", {configurable:true, value:"bar"});
+      assertTrue(deleteFunc(o));
+      assertFalse(o.hasOwnProperty("foo"));
+      %OptimizeFunctionOnNextCall(deleteFunc);
+      Object.defineProperty(o, "foo", {configurable:true, value:"bar"});
+      assertTrue(deleteFunc(o));
+      assertFalse(o.hasOwnProperty("foo"));
+      %DeoptimizeFunction(deleteFunc);
+      Object.defineProperty(o, "foo", {configurable:true, value:"bar"});
+      assertTrue(deleteFunc(o));
+      assertFalse(o.hasOwnProperty("foo"));
+    }
+    for (let o of strongObjects) {
+      Object.defineProperty(o, "foo", {configurable:true, value:"bar"});
+      assertFalse(deleteFunc(o));
+      assertTrue(o.hasOwnProperty("foo"));
+      %OptimizeFunctionOnNextCall(deleteFunc);
+      assertFalse(deleteFunc(o));
+      assertTrue(o.hasOwnProperty("foo"));
+      %DeoptimizeFunction(deleteFunc);
+      assertFalse(deleteFunc(o));
+      assertTrue(o.hasOwnProperty("foo"));
+      assertTrue(delete o);

[rossberg, 2015/05/22 14:01:26]

I'm confused, shouldn't this be a SyntaxError in strict mode?

[conradw, 2015/05/27 18:09:32]

Yes, mistake here. I can't actually run the strongObjects part of the tests just
now due to the Array/map caching problems. Will re-write tests when rebasing on
top of fix for that.

+    }
+    assertFalse(deleteFunc(strongFunction));
+  }
+  for (let deleteFunc of deleteFuncsStrict) {
+    for (let o of nonStrongObjects) {
+      Object.defineProperty(o, "foo", {configurable:true, value:"bar"});
+      assertTrue(deleteFunc(o));
+      assertFalse(o.hasOwnProperty("foo"));
+      %OptimizeFunctionOnNextCall(deleteFunc);
+      Object.defineProperty(o, "foo", {configurable:true, value:"bar"});
+      assertTrue(deleteFunc(o));
+      assertFalse(o.hasOwnProperty("foo"));
+      %DeoptimizeFunction(deleteFunc);
+      Object.defineProperty(o, "foo", {configurable:true, value:"bar"});
+      assertTrue(deleteFunc(o));
+      assertFalse(o.hasOwnProperty("foo"));
+    }
+    for (let o of strongObjects) {
+      Object.defineProperty(o, "foo", {configurable:true, value:"bar"});
+      assertThrows(deleteFunc(o), TypeError);
+      assertTrue(o.hasOwnProperty("foo"));
+      %OptimizeFunctionOnNextCall(deleteFunc);
+      assertThrows(deleteFunc(o), TypeError);
+      assertTrue(o.hasOwnProperty("foo"));
+      %DeoptimizeFunction(deleteFunc);
+      assertThrows(deleteFunc(o), TypeError);
+      assertTrue(o.hasOwnProperty("foo"));
+      assertTrue(delete o);
+    }
+    assertThrows(deleteFunc(strongFunction), TypeError);
+  }
+}
+testStrongObjectDelete();

[rossberg, 2015/05/22 14:01:26]

It seems we don't have tests for redundant deletes succeeding.

[conradw, 2015/05/27 18:09:33]

Done, I thought they should fail (and should have tested for that anyway).