Fastpath some spread-call desugaring.

test/mjsunit/es6/spread-call.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.
 
 (function testSpreadCallsStrict() {
   "use strict"
   function countArgs() { return arguments.length; }
 
   // Test this argument
   function returnThis() { return this; }
   assertEquals(void 0, returnThis(..."test"));
 
   // Test argument counting with different iterables
   assertEquals(0, countArgs(...""));
   assertEquals(4, countArgs(..."test"));
   assertEquals(4, countArgs(..."tes", ..."t"));
   assertEquals(4, countArgs("t", ..."es", "t"));
   assertEquals(4, countArgs("tes", ..."t!!"));
 
   assertEquals(1, countArgs(...[1]));
   assertEquals(2, countArgs(...[1, 2]));
   assertEquals(3, countArgs(...[1, 2, 3]));
   assertEquals(4, countArgs(...[1, 2, 3, 4]));
   assertEquals(5, countArgs(...[1, 2, 3, 4, 5]));
   assertEquals(6, countArgs(...[1, 2, 3, 4, 5, 6]));
 
+  assertEquals(1, countArgs(...[1.1]));
+  assertEquals(2, countArgs(...[1.1, 2.2]));
+  assertEquals(3, countArgs(...[1.1, 2.2, 3.3]));
+  assertEquals(4, countArgs(...[1.1, 2.2, 3.3, 4.4]));
+  assertEquals(5, countArgs(...[1.1, 2.2, 3.3, 4.4, 5.5]));
+  assertEquals(6, countArgs(...[1.1, 2.2, 3.3, 4.4, 5.5, 6.6]));
+
   assertEquals(1, countArgs(...new Set([1])));
   assertEquals(2, countArgs(...new Set([1, 2])));
   assertEquals(3, countArgs(...new Set([1, 2, 3])));
   assertEquals(4, countArgs(...new Set([1, 2, 3, 4])));
   assertEquals(5, countArgs(...new Set([1, 2, 3, 4, 5])));
   assertEquals(6, countArgs(...new Set([1, 2, 3, 4, 5, 6])));
 
   assertEquals(3, countArgs(...(function*(){ yield 1; yield 2; yield 3; })()));
 
   // Test values
@@ skipping 302 matching lines @@
   result = fn(a(), ...b(), ...c(), d(), e());
   assertEquals([undefined, 0, 1, undefined, undefined], result);
   assertEquals("ABXYC1C2DE", log);
 
   log = "";
   result = fn(a(), ...b(), ...c(), d(), e(), ...b(), ...c());
   assertEquals([undefined, 0, 1, undefined, undefined, 0, 1], result);
   assertEquals("ABXYC1C2DEBXYC1C2", log);
 })();
 
+(function testArrayPrototypeHoleGetterModifiesIteratorPrototypeNext() {
+  function sum() {
+    var sum = arguments[0];
+    for (var i = 1; i < arguments.length; ++i) {
+      sum += arguments[i];
+    }
+    return sum;
+  }
+  var a = [1, 2];
+  a[3] = 4;
+  var called = 0;
+
+  Object.defineProperty(Array.prototype, 2, {
+    get: function() {
+      var ai = a[Symbol.iterator]();
+      var original_next = ai.__proto__["next"];
+      Object.defineProperty(ai.__proto__, "next", {
+        get: function() {
+          called++;
+          return original_next;
+        }
+      });
+      return 3;
+    },
+    configurable: true
+  });
+
+  assertEquals(10, sum(...a));
+  assertEquals(2, called);
+
+  Object.defineProperty(Array.prototype, 2, {});
+})();
+
+(function testArrayHasOtherPrototype() {
+  function countArgs() { return arguments.length; }
+  var a = [1, 2, 3];
+  var b = {};
+  Object.defineProperty(b, Symbol.iterator, {
+    value: function*() {
+      yield 4;
+    },
+    configurable: true
+  });
+
+  Object.setPrototypeOf(a, b);
+
+  assertEquals(1, countArgs(...a));
+})();
+
+(function testArrayIteratorPrototypeGetter() {
+  function countArgs() { return arguments.length; }
+  var a = [1, 2, 3];
+  var ai = a[Symbol.iterator]();
+  var called = 0;
+
+  var original_next = ai.__proto__["next"];
+
+  Object.defineProperty(ai.__proto__, "next", {
+    get: function() {
+      called++;
+      return original_next;
+    }
+  });
+
+  countArgs(...a);
+
+  // should be called 4 times; 3 for the values, 1 for the final
+  // {value: undefined, done: true} pair
+  assertEquals(4, called);
+})();
+
+(function testArrayIteratorPrototypeModified() {
+  function countArgs() { return arguments.length; }
+  var a = [1,2,3];
+  var ai = a[Symbol.iterator]();
+  Object.defineProperty(ai.__proto__, "next", {
+    value: function() {
+      return {value: undefined, done: true};
+     },
+     configurable: true
+  });
+
+  assertEquals(0, countArgs(...a));
+
+})();
 
 (function testCustomArrayPrototypeIterator() {
   var origIterator =
       Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator);
   Object.defineProperty(Array.prototype, Symbol.iterator, {
     value: function*() {
       yield 1;
       yield 2;
       yield 3;
     },
     configurable: true
   });
   function returnCountStrict() { 'use strict'; return arguments.length; }
   function returnCountSloppy() { return arguments.length; }
 
   assertEquals(3, returnCountStrict(...[1]));
   assertEquals(4, returnCountStrict(1, ...[2]));
   assertEquals(5, returnCountStrict(1, ...[2], 3));
   assertEquals(3, returnCountSloppy(...[1]));
   assertEquals(4, returnCountSloppy(1, ...[2]));
   assertEquals(5, returnCountSloppy(1, ...[2], 3));
 
   Object.defineProperty(Array.prototype, Symbol.iterator, origIterator);
 })();
+
+(function testGetPropertyIteratorCalledExactlyOnce() {
+  function countArgs() { return arguments.length; }
+  var a = [1, 2, 3];
+  var called = 0;
+
+  Object.defineProperty(Array.prototype, Symbol.iterator, {
+    value: function*() {
+      yield 1;
+      yield 2;
+    },
+    configurable: true
+  });
+
+  var it = a[Symbol.iterator];
+  Object.defineProperty(a, Symbol.iterator, {
+    get: function() {
+      called++;
+      return it;
+    }
+  });
+
+  countArgs(...a);
+
+  assertEquals(1, called);
+})();