Enable ES6 Map and Set by default

test/mjsunit/es6/collections.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// Flags: --harmony-collections --harmony-iteration
 // Flags: --expose-gc --allow-natives-syntax
 
 
 // Test valid getter and setter calls on Sets and WeakSets
 function TestValidSetCalls(m) {
   assertDoesNotThrow(function () { m.add(new Object) });
   assertDoesNotThrow(function () { m.has(new Object) });
   assertDoesNotThrow(function () { m.delete(new Object) });
 }
 TestValidSetCalls(new Set);
@@ skipping 244 matching lines @@
 
 
 // Test name of constructor.
 assertEquals("Set", Set.name);
 assertEquals("Map", Map.name);
 assertEquals("WeakMap", WeakMap.name);
 assertEquals("WeakSet", WeakSet.name);
 
 
 // Test prototype property of Set, Map, WeakMap and WeakSet.
-// TODO(2793): Should all be non-writable, and the extra flag removed.
-function TestPrototype(C, writable) {
+function TestPrototype(C) {
   assertTrue(C.prototype instanceof Object);
   assertEquals({
     value: {},
-    writable: writable,
+    writable: false,
     enumerable: false,
     configurable: false
   }, Object.getOwnPropertyDescriptor(C, "prototype"));
 }
-TestPrototype(Set, true);
-TestPrototype(Map, true);
-TestPrototype(WeakMap, false);
-TestPrototype(WeakSet, false);
+TestPrototype(Set);
+TestPrototype(Map);
+TestPrototype(WeakMap);
+TestPrototype(WeakSet);
 
 
 // Test constructor property of the Set, Map, WeakMap and WeakSet prototype.
 function TestConstructor(C) {
   assertFalse(C === Object.prototype.constructor);
   assertSame(C, C.prototype.constructor);
   assertSame(C, (new C).__proto__.constructor);
 }
 TestConstructor(Set);
 TestConstructor(Map);
@@ skipping 705 matching lines @@
   s2.add('b');
   s2.add('c');
   s = new Set(s2.values());
   assertEquals(s.size, 3);
   assertTrue(s.has('a'));
   assertTrue(s.has('b'));
   assertTrue(s.has('c'));
 })();
 
 
+// Allows testing iterator-based constructors easily.
+var oneAndTwo = new Set();
+oneAndTwo.add(1);
+oneAndTwo.add(2);
+
+
 (function TestSetConstructorAddNotCallable() {
   var originalSetPrototypeAdd = Set.prototype.add;
   assertThrows(function() {
     Set.prototype.add = 42;
-    new Set([1, 2].values());
+    new Set(oneAndTwo.values());
   }, TypeError);
   Set.prototype.add = originalSetPrototypeAdd;
 })();
 
 
 (function TestSetConstructorGetAddOnce() {
   var originalSetPrototypeAdd = Set.prototype.add;
   var getAddCount = 0;
   Object.defineProperty(Set.prototype, 'add', {
     get: function() {
       getAddCount++;
       return function() {};
     }
   });
-  var s = new Set([1, 2].values());
+  var s = new Set(oneAndTwo.values());
   assertEquals(getAddCount, 1);
   assertEquals(s.size, 0);
   Object.defineProperty(Set.prototype, 'add', {
     value: originalSetPrototypeAdd,
     writable: true
   });
 })();
 
 
 (function TestSetConstructorAddReplaced() {
   var originalSetPrototypeAdd = Set.prototype.add;
   var addCount = 0;
   Set.prototype.add = function(value) {
     addCount++;
     originalSetPrototypeAdd.call(this, value);
     Set.prototype.add = null;
   };
-  var s = new Set([1, 2].values());
+  var s = new Set(oneAndTwo.values());
   assertEquals(addCount, 2);
   assertEquals(s.size, 2);
   Set.prototype.add = originalSetPrototypeAdd;
 })();
 
 
 (function TestSetConstructorOrderOfDoneValue() {
   var valueCount = 0, doneCount = 0;
   var iterator = {
     next: function() {
@@ skipping 71 matching lines @@
   assertEquals(m.get(0), 'a');
   assertEquals(m.get(1), 'b');
   assertEquals(m.get(2), 'c');
 })();
 
 
 (function TestMapConstructorSetNotCallable() {
   var originalMapPrototypeSet = Map.prototype.set;
   assertThrows(function() {
     Map.prototype.set = 42;
-    new Map([1, 2].entries());
+    new Map(oneAndTwo.entries());
   }, TypeError);
   Map.prototype.set = originalMapPrototypeSet;
 })();
 
 
 (function TestMapConstructorGetAddOnce() {
   var originalMapPrototypeSet = Map.prototype.set;
   var getSetCount = 0;
   Object.defineProperty(Map.prototype, 'set', {
     get: function() {
       getSetCount++;
       return function() {};
     }
   });
-  var m = new Map([1, 2].entries());
+  var m = new Map(oneAndTwo.entries());
   assertEquals(getSetCount, 1);
   assertEquals(m.size, 0);
   Object.defineProperty(Map.prototype, 'set', {
     value: originalMapPrototypeSet,
     writable: true
   });
 })();
 
 
 (function TestMapConstructorSetReplaced() {
   var originalMapPrototypeSet = Map.prototype.set;
   var setCount = 0;
   Map.prototype.set = function(key, value) {
     setCount++;
     originalMapPrototypeSet.call(this, key, value);
     Map.prototype.set = null;
   };
-  var m = new Map([1, 2].entries());
+  var m = new Map(oneAndTwo.entries());
   assertEquals(setCount, 2);
   assertEquals(m.size, 2);
   Map.prototype.set = originalMapPrototypeSet;
 })();
 
 
 (function TestMapConstructorOrderOfDoneValue() {
   var valueCount = 0, doneCount = 0;
   function FakeError() {}
   var iterator = {
@@ skipping 30 matching lines @@
     return this;
   };
   assertThrows(function() {
     new Map(iterator);
   }, TypeError);
 })();
 
 
 (function TestMapConstructorIteratorNotObjectValues() {
   assertThrows(function() {
-    new Map([1, 2].values());
+    new Map(oneAndTwo.values());
   }, TypeError);
 })();