Patch Function#call and Function#apply together, more robust than single fix.

Ref: es-shims#304

Changed some code back as mentioned in comments.

Changed more code as per comments

Changed more code as per comments.

Changed some variable names to better reflect comments.

Fixed missed invocation.

Added some comments and code changes as discussed.

[tests] Remove unneeded jshint comment.

[Tests] use the preferred it/skip pattern for this strict mode test.

es-shims#345 (comment)
And some other cleanup

Added `arguments` expectations to tests.

Add tests for `Object#toString` of typed arrays and Symbols, if they exist.

Added note about typed array tests.

Fix `hasToStringTagRegExpBug`

Removed RegExp and Array bug detection as can not test, possible Opera 9.
Fixed missing `force` on `defineProperties` that caused the patch to not be applied on IE<9.
Fixed `Uint8ClampedArray` tests for Opera 11 and IE10 that don't have it.

Removed offending test that was moved to detection, but forgotten.

Avoid all possibilities of `call` calling `call`.

Do not pass `undefined` argument, we know IE<9 has unfixable bug.

Final cleanup (hopeully)

Port over work from `apply` fix

Move code so that it is specific to the fix.

Robustness, move before bind.

Remove `Array#slice` tests.

Add notes about `eval` and `apply` avoidance.

Author: Xotic750

es5-shim.js

@@ -55,7 +55,9 @@ var array_splice = ArrayPrototype.splice;
 var array_push = ArrayPrototype.push;
 var array_unshift = ArrayPrototype.unshift;
 var array_concat = ArrayPrototype.concat;
+var str_split = StringPrototype.split;
 var call = FunctionPrototype.call;
+var apply = FunctionPrototype.apply;
 var max = Math.max;
 var min = Math.min;
 
@@ -163,7 +165,6 @@ var ES = {
     // http://es5.github.com/#x9.9
     /* replaceable with https://npmjs.com/package/es-abstract ES5.ToObject */
     ToObject: function (o) {
-        /* jshint eqnull: true */
         if (o == null) { // this matches both null and undefined
             throw new TypeError("can't convert " + o + ' to object');
         }
@@ -176,11 +177,160 @@ var ES = {
     }
 };
 
+// Check failure of by-index access of string characters (IE < 9)
+// and failure of `0 in boxedString` (Rhino)
+var boxedString = $Object('a');
+var splitString = boxedString[0] !== 'a' || !(0 in boxedString);
+
 //
 // Function
 // ========
 //
 
+// Tests for inconsistent or buggy `[[Class]]` strings.
+/* eslint-disable no-useless-call */
+var hasToStringTagBasicBug = to_string.call() !== '[object Undefined]' || to_string.call(null) !== '[object Null]';
+/* eslint-enable no-useless-call */
+var hasToStringTagLegacyArguments = to_string.call(arguments) !== '[object Arguments]';
+var hasToStringTagInconsistency = hasToStringTagBasicBug || hasToStringTagLegacyArguments;
+// Others that could be fixed:
+// Older ES3 native functions like `alert` return `[object Object]`.
+// Inconsistent `[[Class]]` strings for `window` or `global`.
+
+var hasApplyArrayLikeDeficiency = (function () {
+    var arrayLike = { length: 4, 0: 1, 2: 4, 3: true };
+    var expectedArray = [1, undefined, 4, true];
+    var actualArray;
+    try {
+        actualArray = (function () {
+            // `array_slice` is safe to use here, no known issue at present.
+            return array_slice.apply(arguments);
+        }.apply(null, arrayLike));
+    } catch (e) {
+        if (to_string.call(actualArray) !== '[object Array]' || actualArray.length !== arrayLike.length) {
+            return true;
+        }
+        while (expectedArray.length) {
+            if (actualArray.pop() !== expectedArray.pop()) {
+                return true;
+            }
+        }
+    }
+    return false;
+}());
+
+var shouldPatchCallApply = hasToStringTagInconsistency || hasApplyArrayLikeDeficiency;
+
+if (shouldPatchCallApply) {
+    // Constant. ES3 maximum array length.
+    var MAX_ARRAY_LENGTH = 4294967295;
+    // To prevent recursion when `call` and `apply` are patched. Robustness.
+    call.call = call;
+    call.apply = apply;
+    apply.call = call;
+    apply.apply = apply;
+}
+
+if (hasToStringTagLegacyArguments) {
+    // This function is for use within `call` and `apply` only.
+    // To avoid any possibility of `call` recursion we use original `hasOwnProperty`.
+    var isDuckTypeArguments = (function (hasOwnProperty) {
+      return function (value) {
+          if (value != null) { // Checks `null` or `undefined`.
+              if (typeof value === 'object' && call.call(hasOwnProperty, value, 'length')) {
+                  var length = value.length;
+                  if (length > -1 && length % 1 === 0 && length <= MAX_ARRAY_LENGTH) {
+                      return !call.call(hasOwnProperty, value, 'arguments') && call.call(hasOwnProperty, value, 'callee');
+                  }
+              }
+          }
+          return false;
+      };
+    }(ObjectPrototype.hasOwnProperty));
+}
+
+if (shouldPatchCallApply) {
+    // For use with `call` and `apply` fixes.
+    var toStringTag = function (value) {
+        // Add whatever fixes for getting `[[Class]]` strings here.
+        if (value === null) {
+            return '[object Null]';
+        }
+        if (typeof value === 'undefined') {
+            return '[object Undefined]';
+        }
+        if (hasToStringTagLegacyArguments && isDuckTypeArguments(value)) {
+            return '[object Arguments]';
+        }
+        // `to_string` is safe to use here, no known issue at present.
+        return call.call(to_string, value);
+    };
+    // For use with `apply` fix.
+    var isArrayLikeObject = function (value) {
+        if (value != null) { // Checks `null` or `undefined`.
+            var type = typeof value;
+            // `to_string` is safe to use here, no known issue at present.
+            if (type === 'object' && type !== 'function' && call.call(to_string, value) !== '[object Function]') {
+                var length = value.length;
+                if (typeof length === 'number') {
+                    return length > -1 && length % 1 === 0 && length <= MAX_ARRAY_LENGTH;
+                }
+            }
+        }
+        return false;
+    };
+}
+
+defineProperties(FunctionPrototype, {
+    // ES-5 15.3.4.3
+    // http://es5.github.io/#x15.3.4.3
+    // The apply() method calls a function with a given this value and arguments
+    // provided as an array (or an array-like object).
+    apply: function (thisArg) {
+        var argsArray = arguments[1];
+        if (arguments.length > 1) {
+            // IE9 (though fix not needed) has a problem here for some reason!!!
+            // Pretty much any function here causes error `SCRIPT5007: Object expected`.
+            if (!isArrayLikeObject(argsArray)) {
+                throw new TypeError('Function.prototype.apply: Arguments list has wrong type');
+            }
+        }
+        // If `this` is `Object#toString`, captured or modified.
+        if (this === to_string || this === Object.prototype.toString) {
+            return toStringTag(thisArg);
+        }
+        // All other applys.
+        if (arguments.length > 1) {
+            // Boxed string access bug fix.
+            if (splitString && to_string.call(thisArg) === '[object String]') {
+                // `str_split` is safe to use here, no known issue at present.
+                argsArray = call.call(str_split, argsArray, '');
+            }
+            // `array_slice` is safe to use here, no known issue at present.
+            argsArray = call.call(array_slice, argsArray);
+        } else {
+            // `argsArray` was `undefined` (not present).
+            argsArray = [];
+        }
+
+        return apply.call(this, thisArg, argsArray);
+    },
+
+    // ES-5 15.3.4.4
+    // http://es5.github.io/#x15.3.4.4
+    // The call() method calls a function with a given this value and arguments
+    // provided individually.
+    call: function (thisArg) {
+        // If `this` is `Object#toString`, captured or modified.
+        if (this === to_string || this === Object.prototype.toString) {
+            return toStringTag(thisArg);
+        }
+        // All other calls.
+        // `array_slice` is safe to use here, no known issue at present.
+        return apply.call(this, thisArg, call.call(array_slice, arguments, 1));
+    }
+}, shouldPatchCallApply);
+
 // ES-5 15.3.4.5
 // http://es5.github.com/#x15.3.4.5
 
@@ -321,7 +471,7 @@ defineProperties(FunctionPrototype, {
 });
 
 // _Please note: Shortcuts are defined after `Function.prototype.bind` as we
-// us it in defining shortcuts.
+// use it in defining shortcuts.
 var owns = call.bind(ObjectPrototype.hasOwnProperty);
 var toStr = call.bind(ObjectPrototype.toString);
 var strSlice = call.bind(StringPrototype.slice);
@@ -372,11 +522,6 @@ defineProperties($Array, { isArray: isArray });
 // http://es5.github.com/#x15.4.4.18
 // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/forEach
 
-// Check failure of by-index access of string characters (IE < 9)
-// and failure of `0 in boxedString` (Rhino)
-var boxedString = $Object('a');
-var splitString = boxedString[0] !== 'a' || !(0 in boxedString);
-
 var properlyBoxesContext = function properlyBoxed(method) {
     // Check node 0.6.21 bug where third parameter is not boxed
     var properlyBoxesNonStrict = true;

tests/spec/s-array.js

@@ -9,6 +9,7 @@ var hasStrictMode = (function () {
 
    return !this;
 }());
+var ifHasStrictIt = hasStrictMode ? it : xit;
 
 describe('Array', function () {
     var testSubject;
@@ -123,17 +124,15 @@ describe('Array', function () {
             expect(toStr.call(listArg)).toBe('[object String]');
         });
 
-        if (hasStrictMode) {
-            it('does not autobox the content in strict mode', function () {
-                var context;
-                [1].forEach(function () {
-                    'use strict';
+        ifHasStrictIt('does not autobox the content in strict mode', function () {
+            var context;
+            [1].forEach(function () {
+                'use strict';
 
-                    context = this;
-                }, 'x');
-                expect(typeof context).toBe('string');
-            });
-        }
+                context = this;
+            }, 'x');
+            expect(typeof context).toBe('string');
+        });
     });
     describe('#some()', function () {
         var actual, expected, numberOfRuns;
@@ -1541,4 +1540,32 @@ describe('Array', function () {
             expect(obj[2]).toBeUndefined();
         });
     });
+
+    describe('#slice()', function () {
+        it('works on arrays', function () {
+            var arr = [1, 2, 3, 4];
+            var result = arr.slice(1, 3);
+            expect(result).toEqual([2, 3]);
+        });
+
+        it('is generic', function () {
+            var obj = { 0: 1, 1: 2, 2: 3, 3: 4, length: 4 };
+            var result = Array.prototype.slice.call(obj, 1, 3);
+            expect(result).toEqual([2, 3]);
+        });
+
+        it('works with arguments', function () {
+            var obj = (function () {
+              return arguments;
+            }(1, 2, 3, 4));
+            var result = Array.prototype.slice.call(obj, 1, 3);
+            expect(result).toEqual([2, 3]);
+        });
+
+        it('boxed string access', function () {
+            var obj = '1234';
+            var result = Array.prototype.slice.call(obj, 1, 3);
+            expect(result).toEqual(['2', '3']);
+        });
+    });
 });

tests/spec/s-function.js

@@ -1,7 +1,84 @@
-/* global describe, it, expect, beforeEach */
+/* global describe, it, xit,  expect, beforeEach */
+var hasStrictMode = (function () {
+    'use strict';
+
+    return !this;
+}());
+var ifHasStrictIt = hasStrictMode ? it : xit;
+var global = Function('return this')();
 
 describe('Function', function () {
-    'use strict';
+    describe('#call()', function () {
+        it('should pass correct arguments', function () {
+            // https://github.com/es-shims/es5-shim/pull/345#discussion_r44878754
+            var result;
+            var testFn = function () {
+                return Array.prototype.slice.call(arguments);
+            };
+            var argsExpected = [null, '1', 1, true, testFn];
+            /* eslint-disable no-useless-call */
+            result = testFn.call(undefined, null, '1', 1, true, testFn);
+            expect(result).toEqual(argsExpected);
+            result = testFn.call(null, null, '1', 1, true, testFn);
+            expect(result).toEqual(argsExpected);
+            /* eslint-enable no-useless-call */
+            result = testFn.call('a', null, '1', 1, true, testFn);
+            expect(result).toEqual(argsExpected);
+            result = testFn.call(1, null, '1', 1, true, testFn);
+            expect(result).toEqual(argsExpected);
+            result = testFn.call(true, null, '1', 1, true, testFn);
+            expect(result).toEqual(argsExpected);
+            result = testFn.call(testFn, null, '1', 1, true, testFn);
+            expect(result).toEqual(argsExpected);
+            result = testFn.call(new Date(), null, '1', 1, true, testFn);
+            expect(result).toEqual(argsExpected);
+        });
+        // https://github.com/es-shims/es5-shim/pull/345#discussion_r44878771
+        ifHasStrictIt('should have correct context in strict mode', function () {
+            'use strict';
+
+            var subject;
+            var testFn = function () {
+                return this;
+            };
+            expect(testFn.call()).toBe(undefined);
+            /* eslint-disable no-useless-call */
+            expect(testFn.call(undefined)).toBe(undefined);
+            expect(testFn.call(null)).toBe(null);
+            /* eslint-enable no-useless-call */
+            expect(testFn.call('a')).toBe('a');
+            expect(testFn.call(1)).toBe(1);
+            expect(testFn.call(true)).toBe(true);
+            expect(testFn.call(testFn)).toBe(testFn);
+            subject = new Date();
+            expect(testFn.call(subject)).toBe(subject);
+        });
+        it('should have correct context in non-strict mode', function () {
+            var result;
+            var subject;
+            var testFn = function () {
+                return this;
+            };
+
+            expect(testFn.call()).toBe(global);
+            /* eslint-disable no-useless-call */
+            expect(testFn.call(undefined)).toBe(global);
+            expect(testFn.call(null)).toBe(global);
+            /* eslint-enable no-useless-call */
+            result = testFn.call('a');
+            expect(typeof result).toBe('object');
+            expect(String(result)).toBe('a');
+            result = testFn.call(1);
+            expect(typeof result).toBe('object');
+            expect(Number(result)).toBe(1);
+            result = testFn.call(true);
+            expect(typeof result).toBe('object');
+            expect(Boolean(result)).toBe(true);
+            expect(testFn.call(testFn)).toBe(testFn);
+            subject = new Date();
+            expect(testFn.call(subject)).toBe(subject);
+        });
+    });
 
     describe('#apply()', function () {
         it('works with arraylike objects', function () {