Don't exchange null and undefined with the global object in function.prototype.{call, apply} for ...

test/mjsunit/function-call.js

Index: test/mjsunit/function-call.js
===================================================================
--- test/mjsunit/function-call.js	(revision 0)
+++ test/mjsunit/function-call.js	(revision 0)
@@ -0,0 +1,314 @@
+// Copyright 2011 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.
+
+
+var should_throw_on_null_and_undefined =
+    [Object.prototype.toLocaleString,
+     Object.prototype.valueOf,
+     Object.prototype.hasOwnProperty,
+     Object.prototype.isPrototypeOf,
+     Object.prototype.propertyIsEnumerable,
+     // Array.prototype.toString,

[MarkM, 2011/04/28 21:16:54]

Why are these commented out?

[Rico, 2011/05/03 08:47:20]

Done (and fixed in Array.prototype.toString/toLocaleString which should be
generic)

+     // Array.prototype.toLocaleString,
+     Array.prototype.concat,
+     Array.prototype.join,
+     Array.prototype.pop,
+     Array.prototype.push,
+     Array.prototype.reverse,
+     Array.prototype.shift,
+     Array.prototype.slice,
+     Array.prototype.sort,
+     Array.prototype.splice,
+     Array.prototype.unshift,
+     Array.prototype.indexOf,
+     Array.prototype.lastIndexOf,
+     Array.prototype.every,
+     Array.prototype.some,
+     Array.prototype.forEach,
+     Array.prototype.map,
+     Array.prototype.filter,
+     Array.prototype.reduce,
+     Array.prototype.reduceRight,
+     String.prototype.charAt,
+     String.prototype.charCodeAt,
+     String.prototype.concat,
+     String.prototype.indexOf,
+     String.prototype.lastIndexOf,
+     String.prototype.localeCompare,
+     String.prototype.match,
+     String.prototype.replace,
+     String.prototype.search,
+     String.prototype.slice,
+     String.prototype.split,
+     String.prototype.substring,
+     String.prototype.toLowerCase,
+     String.prototype.toLocaleLowerCase,
+     String.prototype.toUpperCase,
+     String.prototype.toLocaleUpperCase,
+     String.prototype.trim,
+     Number.prototype.toLocaleString,
+     Error.prototype.toString];
+
+// Non generic natives does not work on any input other than the specific
+// type, but since this change will allow call to be invoked with undefined
+// or null as this we still explicitly test that we throw on these here.
+var non_generic =
+    [Function.prototype.toString,

[Lasse Reichstein, 2011/04/29 06:16:12]

How about Function.prototype.call and Function.prototype.apply? :)

[Rico, 2011/05/03 08:47:20]

Done.

+     String.prototype.toString,
+     String.prototype.valueOf,
+     Boolean.prototype.toString,
+     Boolean.prototype.valueOf,
+     Number.prototype.toString,
+     Number.prototype.valueOf,
+     Number.prototype.toFixed,
+     Number.prototype.toExponential,
+     Number.prototype.toPrecision,
+     Date.prototype.toString,
+     Date.prototype.toDateString,
+     Date.prototype.toTimeString,
+     Date.prototype.toLocaleString,
+     Date.prototype.toLocaleDateString,
+     Date.prototype.toLocaleTimeString,
+     Date.prototype.valueOf,
+     Date.prototype.getTime,
+     Date.prototype.getFullYear,
+     Date.prototype.getUTCFullYear,
+     Date.prototype.getMonth,
+     Date.prototype.getUTCMonth,
+     Date.prototype.getDate,
+     Date.prototype.getUTCDate,
+     Date.prototype.getDay,
+     Date.prototype.getUTCDay,
+     Date.prototype.getHours,
+     Date.prototype.getUTCHours,
+     Date.prototype.getMinutes,
+     Date.prototype.getUTCMinutes,
+     Date.prototype.getSeconds,
+     Date.prototype.getUTCSeconds,
+     Date.prototype.getMilliseconds,
+     Date.prototype.getUTCMilliseconds,
+     Date.prototype.getTimezoneOffset,
+     Date.prototype.setTime,
+     Date.prototype.setMilliseconds,
+     Date.prototype.setUTCMilliseconds,
+     Date.prototype.setSeconds,
+     Date.prototype.setUTCSeconds,
+     Date.prototype.setMinutes,
+     Date.prototype.setUTCMinutes,
+     Date.prototype.setHours,
+     Date.prototype.setUTCHours,
+     Date.prototype.setDate,
+     Date.prototype.setUTCDate,
+     Date.prototype.setMonth,
+     Date.prototype.setUTCMonth,
+     Date.prototype.setFullYear,
+     Date.prototype.setUTCFullYear,
+     Date.prototype.toUTCString,
+     Date.prototype.toISOString,
+     Date.prototype.toJSON,
+     RegExp.prototype.exec,
+     RegExp.prototype.test,
+     RegExp.prototype.toString];
+
+
+// Mapping functions.
+var mapping_functions =
+    [Array.prototype.every,
+     Array.prototype.some,
+     Array.prototype.forEach,
+     Array.prototype.map,
+     Array.prototype.filter];
+
+// Reduce functions.
+var reducing_functions =
+    [Array.prototype.reduce,
+     Array.prototype.reduceRight];

[Lasse Reichstein, 2011/04/29 06:16:12]

Try testing String.prototype.replace the same way. Let's, for now, assume that
we should be passing undefined as receiver (I'll ask es5-discuss).

[Rico, 2011/05/03 08:47:20]

We do not use null as argument to call when in String.prototype.replace as far
as I can see

[Lasse Reichstein, 2011/05/03 09:01:02]

No, but I think we should use undefined for strict functions, and not always the
global receiver.

[Rico, 2011/05/03 12:41:02]

Bug filled for this and Array.prototype.sort
http://code.google.com/p/v8/issues/detail?id=1360

+
+// Test that all natives using the ToObject call throws the right exception.
+for (var i = 0; i < should_throw_on_null_and_undefined.length; i++) {
+  // Sanity check that all functions are correct
+  assertEquals(typeof(should_throw_on_null_and_undefined[i]), "function");
+
+  try {
+    should_throw_on_null_and_undefined[i].call(null);
+    assertUnreachable();
+  } catch (e) {
+    assertTrue(/called on non-object/.test(e) || /Cannot convert/.test(e));

[MarkM, 2011/04/28 21:16:54]

If we changed the test here to

    assertTrue(e instanceof TypeError);

as it is for the non-generics below, then we could treat this as a normative
test eventually to be migrated into Sputnik and/or test262. OTOH, I can see why
you'd want to test that you're getting the diagnostic you expect.

[Lasse Reichstein, 2011/04/29 06:16:12]

It helps if the same algorithm can throw more than one TypeError. In that case,
we should check that it's the first test in the ES algorithm to fail that is
actually thrown.

[Rico, 2011/05/03 08:47:20]

We normally do test the output of the error message to ensure that we actually
get what we expected

+  }
+
+  try {
+    should_throw_on_null_and_undefined[i].call(undefined);

[MarkM, 2011/04/28 21:16:54]

If should_throw_on_null_and_undefined[i] happens to be a function that expects
more arguments and throws if these are absent, then calling it without the rest
of its expected arguments is not a reliable test that you're getting the error
for the right reason.

[Lasse Reichstein, 2011/04/29 06:16:12]

A comment should suffice. The general rule, which applies to all of these
functions, is that supplying too few arguments means that the remaining
parameters will take the undefined value. All of the functions here will test
their receiver for being convertible to object as the first thing, or have it as
a precondition for the non-generic methods.

Having meaningless and unusable arguments that would by themselves make the
method fail, is actually a good thing, since it also tests that the
object-coercible test is performed first.

[Rico, 2011/05/03 08:47:20]

Comment inserted

+    assertUnreachable();
+  } catch (e) {
+    assertTrue(/called on non-object/.test(e) || /Cannot convert/.test(e));
+  }
+
+  try {
+    should_throw_on_null_and_undefined[i].apply(null);
+    assertUnreachable();
+  } catch (e) {
+    assertTrue(/called on non-object/.test(e) || /Cannot convert/.test(e));
+  }
+
+  try {
+    should_throw_on_null_and_undefined[i].apply(undefined);
+    assertUnreachable();
+  } catch (e) {
+    assertTrue(/called on non-object/.test(e) || /Cannot convert/.test(e));
+  }
+}
+
+// Test that all natives that are non generic throws on null and undefined.
+for (var i = 0; i < non_generic.length; i++) {
+  // Sanity check that all functions are correct
+  assertEquals(typeof(non_generic[i]), "function");
+  print(non_generic[i].toString());
+  try {
+    non_generic[i].call(null);
+    assertUnreachable();
+  } catch (e) {
+    assertTrue(e instanceof TypeError);
+  }
+
+  try {
+    non_generic[i].call(null);
+    assertUnreachable();
+  } catch (e) {
+    assertTrue(e instanceof TypeError);
+  }
+
+  try {
+    non_generic[i].apply(null);
+    assertUnreachable();
+  } catch (e) {
+    assertTrue(e instanceof TypeError);
+  }
+
+  try {
+    non_generic[i].apply(null);
+    assertUnreachable();
+  } catch (e) {
+    assertTrue(e instanceof TypeError);
+  }
+}
+
+
+// Test that we still throw when calling with thisArg null or undefined
+// through an array mapping function.
+var array = [1,2,3,4,5];
+for (var j = 0; j < mapping_functions.length; j++) {
+  for (var i = 0; i < should_throw_on_null_and_undefined.length; i++) {
+    try {
+      mapping_functions[j].call(array,
+                                should_throw_on_null_and_undefined[i],
+                                null);
+      assertUnreachable();
+    } catch (e) {
+      assertTrue(/called on non-object/.test(e) || /Cannot convert/.test(e));
+    }
+
+    try {
+      mapping_functions[j].call(array,
+                                should_throw_on_null_and_undefined[i],
+                                undefined);
+      assertUnreachable();
+    } catch (e) {
+      assertTrue(/called on non-object/.test(e) || /Cannot convert/.test(e));
+    }
+  }
+}
+
+for (var j = 0; j < mapping_functions.length; j++) {
+  for (var i = 0; i < non_generic.length; i++) {
+    try {
+      mapping_functions[j].call(array,
+                                non_generic[i],
+                                null);
+      assertUnreachable();
+    } catch (e) {
+      assertTrue(e instanceof TypeError);
+    }
+
+    try {
+      mapping_functions[j].call(array,
+                                non_generic[i],
+                                null);
+      assertUnreachable();
+    } catch (e) {
+      assertTrue(e instanceof TypeError);
+    }
+  }
+}
+
+
+// Reduce functions do a call with null as this argument.
+for (var j = 0; j < reducing_functions.length; j++) {
+  for (var i = 0; i < should_throw_on_null_and_undefined.length; i++) {
+    try {
+      reducing_functions[j].call(array,
+                               should_throw_on_null_and_undefined[i]);

[Lasse Reichstein, 2011/04/28 10:44:38]

Indentation (more cases below).

[Rico, 2011/05/03 08:47:20]

Done.

+      assertUnreachable();
+    } catch (e) {
+      assertTrue(/called on non-object/.test(e) || /Cannot convert/.test(e));
+    }
+
+    try {
+      reducing_functions[j].call(array,
+                               should_throw_on_null_and_undefined[i]);
+      assertUnreachable();
+    } catch (e) {
+      assertTrue(/called on non-object/.test(e) || /Cannot convert/.test(e));
+    }
+  }
+}
+
+for (var j = 0; j < reducing_functions.length; j++) {
+  for (var i = 0; i < non_generic.length; i++) {
+    try {
+      reducing_functions[j].call(array,
+                                non_generic[i]);
+      assertUnreachable();
+    } catch (e) {
+      assertTrue(e instanceof TypeError);
+    }
+
+    try {
+      reducing_functions[j].call(array,
+                               non_generic[i]);
+      assertUnreachable();
+    } catch (e) {
+      assertTrue(e instanceof TypeError);
+    }
+  }
+}
+
+// Object.prototype.toString()
+assertEquals(Object.prototype.toString.call(null),
+             '[object Null]')
+
+assertEquals(Object.prototype.toString.call(undefined),
+             '[object Undefined]')