Array.prototype.{every, filter, find, findIndex, forEach, map, some}: Use fresh primitive wrapper f…

src/collection.js

 // Copyright 2012 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.
 
 "use strict";
 
 // This file relies on the fact that the following declaration has been made
 // in runtime.js:
 // var $Array = global.Array;
 
@@ skipping 87 matching lines @@
 
 function SetForEach(f, receiver) {
   if (!IS_SET(this)) {
     throw MakeTypeError('incompatible_method_receiver',
                         ['Set.prototype.forEach', this]);
   }
 
   if (!IS_SPEC_FUNCTION(f)) {
     throw MakeTypeError('called_non_callable', [f]);
   }
+  if (IS_NULL_OR_UNDEFINED(receiver)) {
+    receiver = %GetDefaultReceiver(f) || receiver;
+  }
 
   var iterator = new SetIterator(this, ITERATOR_KIND_VALUES);
   var key;
   var stepping = DEBUG_IS_ACTIVE && %DebugCallbackSupportsStepping(f);
   var value_array = [UNDEFINED];
   while (%SetIteratorNext(iterator, value_array)) {
+    var new_receiver = receiver;
+    if (!IS_NULL_OR_UNDEFINED(receiver)) {

[arv (Not doing code reviews), 2014/09/12 16:29:17]

Why is this one different? Can you verify with the spec and add a test that
hilights the difference if the spec requires a different semantic?

[Diego Pino, 2014/09/16 10:45:46]

I tried to preserve the semantics of the old code. There was no
!IS_SPEC_OBJECT(receiver) && %IsSloppyModeFunction(f) checking, so I didn't add
it.

The reason of IsSloppyModeFunction(f) is that according to the ECMA-262, Annex C
(The strict mode): "If this is evaluated within strict mode code, then the this
value is not coerced to an object". Currently, this is not being coerced to an
object (that's what the patch fixes :)) but it shouldn't do it if the function
is in strict mode, so MapForEach and SetForEach need this checking too.

+      new_receiver = ToObject(receiver);
+    }
     if (stepping) %DebugPrepareStepInIfStepping(f);
     key = value_array[0];
-    %_CallFunction(receiver, key, key, this, f);
+    %_CallFunction(new_receiver, key, key, this, f);
   }
 }
 
 
 // -------------------------------------------------------------------
 
 function SetUpSet() {
   %CheckIsBootstrapping();
 
   %SetCode($Set, SetConstructor);
@@ skipping 115 matching lines @@
 
 function MapForEach(f, receiver) {
   if (!IS_MAP(this)) {
     throw MakeTypeError('incompatible_method_receiver',
                         ['Map.prototype.forEach', this]);
   }
 
   if (!IS_SPEC_FUNCTION(f)) {
     throw MakeTypeError('called_non_callable', [f]);
   }
+  if (IS_NULL_OR_UNDEFINED(receiver)) {
+    receiver = %GetDefaultReceiver(f) || receiver;
+  }
 
   var iterator = new MapIterator(this, ITERATOR_KIND_ENTRIES);
   var stepping = DEBUG_IS_ACTIVE && %DebugCallbackSupportsStepping(f);
   var value_array = [UNDEFINED, UNDEFINED];
   while (%MapIteratorNext(iterator, value_array)) {
+    var new_receiver = receiver;
+    if (!IS_NULL_OR_UNDEFINED(receiver)) {

[wingo, 2014/09/15 09:12:21]

Same comment here as Erik's comment above.

+      new_receiver = ToObject(receiver);
+    }
     if (stepping) %DebugPrepareStepInIfStepping(f);
-    %_CallFunction(receiver, value_array[1], value_array[0], this, f);
+    %_CallFunction(new_receiver, value_array[1], value_array[0], this, f);
   }
 }
 
 
 // -------------------------------------------------------------------
 
 function SetUpMap() {
   %CheckIsBootstrapping();
 
   %SetCode($Map, MapConstructor);
   %FunctionSetPrototype($Map, new $Object());
   %AddNamedProperty($Map.prototype, "constructor", $Map, DONT_ENUM);
 
   %FunctionSetLength(MapForEach, 1);
 
   // Set up the non-enumerable functions on the Map prototype object.
   InstallGetter($Map.prototype, "size", MapGetSizeJS);
   InstallFunctions($Map.prototype, DONT_ENUM, $Array(
     "get", MapGetJS,
     "set", MapSetJS,
     "has", MapHasJS,
     "delete", MapDeleteJS,
     "clear", MapClearJS,
     "forEach", MapForEach
   ));
 }
 
 SetUpMap();