Don't take iterable path in ArrayFrom if items[@@iterator] is null

test/mjsunit/harmony/array-from.js

 // Copyright 2014 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: --harmony-arrays --harmony-generators
+// Flags: --harmony-arrays
 (function() {
 
 assertEquals(1, Array.from.length);
 
 function assertArrayLikeEquals(value, expected, type) {
   assertInstanceof(value, type);
   assertEquals(expected.length, value.length);
   for (var i=0; i<value.length; ++i) {
     assertEquals(expected[i], value[i]);
   }
@@ skipping 68 matching lines @@
 
   assertArrayLikeEquals(Array.from.call(thisArg, 'test', function(x) {
     return this.filter(x);
   }, {
     filter: function(x) { return x.toUpperCase(); }
   }), ['T', 'E', 'S', 'T'], constructor);
   assertArrayLikeEquals(Array.from.call(thisArg, 'test', function(x) {
     return x.toUpperCase();
   }), ['T', 'E', 'S', 'T'], constructor);
 
-  this.thisArg = thisArg;
-  assertThrows('Array.from.call(thisArg, null)', TypeError);
-  assertThrows('Array.from.call(thisArg, undefined)', TypeError);
-  assertThrows('Array.from.call(thisArg, [], null)', TypeError);
-  assertThrows('Array.from.call(thisArg, [], "noncallable")', TypeError);
+  assertThrows(function() { Array.from.call(thisArg, null); }, TypeError);
+  assertThrows(function() { Array.from.call(thisArg, undefined); }, TypeError);
+  assertThrows(function() { Array.from.call(thisArg, [], null); }, TypeError);
+  assertThrows(function() { Array.from.call(thisArg, [], "noncallable"); },
+               TypeError);
 
-  this.nullIterator = {};
+  var nullIterator = {};
   nullIterator[Symbol.iterator] = null;
-  assertThrows('Array.from.call(thisArg, nullIterator)', TypeError);
+  assertArrayLikeEquals(Array.from.call(thisArg, nullIterator), [],
+                        constructor);
 
-  this.nonObjIterator = {};
+  var nonObjIterator = {};
   nonObjIterator[Symbol.iterator] = function() { return "nonObject"; };
-  assertThrows('Array.from.call(thisArg, nonObjIterator)', TypeError);
+  assertThrows(function() { Array.from.call(thisArg, nonObjIterator); },
+               TypeError);
 
-  assertThrows('Array.from.call(thisArg, [], null)', TypeError);
+  assertThrows(function() { Array.from.call(thisArg, [], null); }, TypeError);
+
+  // Ensure iterator is only accessed once, and only invoked once
+  var called = false;
+  var arr = [1,2,3];

[arv (Not doing code reviews), 2015/01/22 21:14:58]

ws after ,

+  var obj = {};
+
+  // Test order --- only get iterator method once
+  function testIterator() {
+    if (!called) {

[arv (Not doing code reviews), 2015/01/22 21:14:58]

Maybe use assertFalse instead?

+      called = true;
+      assertEquals(obj, this);
+      return arr[Symbol.iterator]();
+    }
+    assertUnreachable("@@iterator should be called only once");
+  }
+  var getCalled = false;
+  Object.defineProperty(obj, Symbol.iterator, {
+    get: function() {
+      if (!getCalled) {
+        getCalled = true;
+        return testIterator;
+      }
+      assertUnreachable("@@iterator should be accessed only once");
+    },
+    set: function() {
+      assertUnreachable("@@iterator should not be set");
+    }
+  });
+  assertArrayLikeEquals(Array.from.call(thisArg, obj), [1,2,3], constructor);

[arv (Not doing code reviews), 2015/01/22 21:14:58]

ws

 }
 
 function Other() {}
 
 var boundFn = (function() {}).bind(Array, 27);
 
 testArrayFrom(Array, Array);
 testArrayFrom(null, Array);
 testArrayFrom({}, Array);
 testArrayFrom(Object, Object);
 testArrayFrom(Other, Other);
 testArrayFrom(Math.cos, Array);
 testArrayFrom(Math.cos.bind(Math), Array);
 testArrayFrom(boundFn, boundFn);
 
 })();