Fix Array.prototype.copyWithin polyfill

src/com/google/javascript/jscomp/js/es6/array/copywithin.js

@@ -15,8 +15,12 @@
  */
 
 'require util/polyfill';
+'require util/tointeger';
 
 $jscomp.polyfill('Array.prototype.copyWithin', function(orig) {
+  // requires strict mode to throw for invalid `this` or params
+  'use strict';
+
   if (orig) return orig;
 
   /**
@@ -30,33 +34,41 @@ $jscomp.polyfill('Array.prototype.copyWithin', function(orig) {
    * @template VALUE
    */
   var polyfill = function(target, start, opt_end) {
+    if (this == null) {
+      throw new TypeError('this is null or not defined');
+    }
     var len = this.length;
-    target = Number(target);
-    start = Number(start);
-    opt_end = Number(opt_end != null ? opt_end : len);
-    if (target < start) {
-      opt_end = Math.min(opt_end, len);
-      while (start < opt_end) {
-        if (start in this) {
-          this[target++] = this[start++];
+    target = $jscomp.toInteger(target);
+    start = $jscomp.toInteger(start);
+    var end = opt_end === undefined ? len : $jscomp.toInteger(opt_end);
+    var to = target < 0 ? Math.max(len + target, 0) : Math.min(target, len);
+    var from = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
+    var final = end < 0 ? Math.max(len + end, 0) : Math.min(end, len);
+    if (to < from) {
+      while (from < final) {
+        if (from in this) {
+          this[to++] = this[from++];
         } else {
-          delete this[target++];
-          start++;
+          delete this[to++];
+          from++;
         }
       }
     } else {
-      opt_end = Math.min(opt_end, len + start - target);
-      target += opt_end - start;
-      while (opt_end > start) {
-        if (--opt_end in this) {
-          this[--target] = this[opt_end];
+      final = Math.min(final, len + from - to);
+      to += final - from;
+      while (final > from) {
+        if (--final in this) {
+          this[--to] = this[final];
         } else {
-          delete this[target];
+          delete this[--to];
         }
       }
     }
     return this;
   };
 
+  $jscomp.defineProperty(polyfill, 'name', {value: 'copyWithin', configurable: true});
+  $jscomp.defineProperty(polyfill, 'length', {value: 2, configurable: true});
+
   return polyfill;
 }, 'es6', 'es3');

src/com/google/javascript/jscomp/js/util/tointeger.js

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2018 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Converts argument to an integral numeric value.
+ *
+ * @see https://www.ecma-international.org/ecma-262/8.0/#sec-tointeger
+ *
+ * @param {*} arg
+ * @return {number}
+ */
+$jscomp.toInteger = function(arg) {
+  var n = Number(arg);
+  if (isNaN(n)) {
+    return 0;
+  }
+  return n > 0 ? Math.floor(n) : Math.ceil(n);
+};

test/com/google/javascript/jscomp/runtime_tests/polyfill_tests/array_copywithin_test.js

@@ -64,5 +64,55 @@ testSuite({
     arr = {length: 3, 1: 4, 3: 'unused'};
     assertEquals(arr, Array.prototype.copyWithin.call(noCheck(arr), 0, 1));
     assertObjectEquals({length: 3, 0: 4, 3: 'unused'}, arr);
+
+    arr = {length: 3, 1: 4, 3: 'unused'};
+    assertEquals(arr, Array.prototype.copyWithin.call(noCheck(arr), 1, 0));
+    assertObjectEquals({length: 3, 2: 4, 3: 'unused'}, arr);
+  },
+
+  testCopyWithin_coercingArgs() {
+    assertObjectEquals([1, 2, 3, 3], [0, 1, 2, 3].copyWithin(NaN, 1));
+    assertObjectEquals([1, 2, 3, 3], [0, 1, 2, 3].copyWithin(0.5, 1));
+    assertObjectEquals([0, 0, 1, 2], [0, 1, 2, 3].copyWithin(1.5, 0));
+
+    assertObjectEquals([0, 0, 1, 2], [0, 1, 2, 3].copyWithin(1, NaN));
+    assertObjectEquals([0, 0, 1, 2], [0, 1, 2, 3].copyWithin(1, 0.5));
+    assertObjectEquals([1, 2, 3, 3], [0, 1, 2, 3].copyWithin(0, 1.5));
+
+    assertObjectEquals([0, 1, 2, 3], [0, 1, 2, 3].copyWithin(1, 0, NaN));
+    assertObjectEquals([0, 0, 2, 3], [0, 1, 2, 3].copyWithin(1, 0, 1.5));
+    assertObjectEquals([0, 0, 1, 3], [0, 1, 2, 3].copyWithin(1, 0, -2.5));
+    assertObjectEquals([0, 0, 1, 2], [0, 1, 2, 3].copyWithin(1, 0, undefined));
+  },
+
+  testCopyWithin_negativeArgs() {
+    assertObjectEquals([1, 2, 3, 1, 2], [1, 2, 3, 4, 5].copyWithin(-2, 0));
+    assertObjectEquals([1, 3, 4, 5, 5], [1, 2, 3, 4, 5].copyWithin(1, -3));
+    assertObjectEquals([1, 3, 4, 4, 5], [1, 2, 3, 4, 5].copyWithin(1, 2, -1));
+  },
+
+  testCopyWithin_throwsIfNullish() {
+    assertThrows(function() {
+      Array.prototype.copyWithin.call(null);
+    });
+    assertThrows(function() {
+      Array.prototype.copyWithin.call(undefined);
+    });
+  },
+
+  testCopyWithin_throwIfFailToDeleteProperty() {
+    var obj = {
+      length: 5
+    };
+
+    Object.defineProperty(obj, 4, {
+      value: 'a',
+      configurable: false,
+      writable: true
+    });
+
+    assertThrows(function() {
+      Array.prototype.copyWithin.call(noCheck(obj), 4, 0);
+    });
   },
 });