Make use of JS rest and spread operators throughout the codebase. NFC

Following up on #21270.  These operators were introduced way before
our current default set of browser versions.  Anyone targeting an
browser so old as to not support these will already be on the
transpilation path.

Author: sbc100

src/cpuprofiler.js

@@ -580,7 +580,7 @@ var emscriptenCpuProfiler = {
     var realf = 'real_' + f;
     glCtx[realf] = glCtx[f];
     var numArgs = this.webGLFunctionLength(f); // On Firefox & Chrome, could do "glCtx[realf].length", but that doesn't work on Edge, which always reports 0.
-    // Accessing 'arguments' is super slow, so to avoid overhead, statically reason the number of arguments.
+    // Accessing 'arguments'/'...' is super slow, so to avoid overhead, statically reason the number of arguments.
     switch (numArgs) {
       case 0: glCtx[f] = () => { this.enterSection(section); var ret = glCtx[realf](); this.endSection(section); return ret; }; break;
       case 1: glCtx[f] = (a1) => { this.enterSection(section); var ret =  glCtx[realf](a1); this.endSection(section); return ret; }; break;

src/embind/embind.js

@@ -98,12 +98,12 @@ var LibraryEmbind = {
     if (undefined === proto[methodName].overloadTable) {
       var prevFunc = proto[methodName];
       // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments.
-      proto[methodName] = function() {
+      proto[methodName] = function(...args) {
         // TODO This check can be removed in -O3 level "unsafe" optimizations.
-        if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
-            throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${arguments.length}) - expects one of (${proto[methodName].overloadTable})!`);
+        if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) {
+            throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`);
         }
-        return proto[methodName].overloadTable[arguments.length].apply(this, arguments);
+        return proto[methodName].overloadTable[args.length].apply(this, args);
       };
       // Move the previous function into the overload table.
       proto[methodName].overloadTable = [];
@@ -818,9 +818,9 @@ var LibraryEmbind = {
     var argsWired = new Array(expectedArgCount);
     var invokerFuncArgs = [];
     var destructors = [];
-    var invokerFn = function() {
-      if (arguments.length !== expectedArgCount) {
-        throwBindingError(`function ${humanName} called with ${arguments.length} arguments, expected ${expectedArgCount}`);
+    var invokerFn = function(...args) {
+      if (args.length !== expectedArgCount) {
+        throwBindingError(`function ${humanName} called with ${args.length} arguments, expected ${expectedArgCount}`);
       }
 #if EMSCRIPTEN_TRACING
       Module.emscripten_trace_enter_context(`embind::${humanName}`);
@@ -834,7 +834,7 @@ var LibraryEmbind = {
         invokerFuncArgs[1] = thisWired;
       }
       for (var i = 0; i < expectedArgCount; ++i) {
-        argsWired[i] = argTypes[i + 2]['toWireType'](destructors, arguments[i]);
+        argsWired[i] = argTypes[i + 2]['toWireType'](destructors, args[i]);
         invokerFuncArgs.push(argsWired[i]);
       }
 
@@ -1765,18 +1765,18 @@ var LibraryEmbind = {
           basePrototype = ClassHandle.prototype;
         }
 
-        var constructor = createNamedFunction(name, function() {
+        var constructor = createNamedFunction(name, function(...args) {
           if (Object.getPrototypeOf(this) !== instancePrototype) {
             throw new BindingError("Use 'new' to construct " + name);
           }
           if (undefined === registeredClass.constructor_body) {
             throw new BindingError(name + " has no accessible constructor");
           }
-          var body = registeredClass.constructor_body[arguments.length];
+          var body = registeredClass.constructor_body[args.length];
           if (undefined === body) {
-            throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${arguments.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`);
+            throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${args.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`);
           }
-          return body.apply(this, arguments);
+          return body.apply(this, args);
         });
 
         var instancePrototype = Object.create(basePrototype, {
@@ -2197,14 +2197,12 @@ var LibraryEmbind = {
     wrapperType = requireRegisteredType(wrapperType, 'wrapper');
     properties = Emval.toValue(properties);
 
-    var arraySlice = [].slice;
-
     var registeredClass = wrapperType.registeredClass;
     var wrapperPrototype = registeredClass.instancePrototype;
     var baseClass = registeredClass.baseClass;
     var baseClassPrototype = baseClass.instancePrototype;
     var baseConstructor = registeredClass.baseClass.constructor;
-    var ctor = createNamedFunction(constructorName, function() {
+    var ctor = createNamedFunction(constructorName, function(...args) {
       registeredClass.baseClass.pureVirtualFunctions.forEach(function(name) {
         if (this[name] === baseClassPrototype[name]) {
           throw new PureVirtualError(`Pure virtual function ${name} must be implemented in JavaScript`);
@@ -2214,19 +2212,19 @@ var LibraryEmbind = {
       Object.defineProperty(this, '__parent', {
         value: wrapperPrototype
       });
-      this["__construct"].apply(this, arraySlice.call(arguments));
+      this["__construct"].apply(this, args);
     });
 
     // It's a little nasty that we're modifying the wrapper prototype here.
 
-    wrapperPrototype["__construct"] = function __construct() {
+    wrapperPrototype["__construct"] = function __construct(...args) {
       if (this === wrapperPrototype) {
         throwBindingError("Pass correct 'this' to __construct");
       }
 
       var inner = baseConstructor["implement"].apply(
         undefined,
-        [this].concat(arraySlice.call(arguments)));
+        [this].concat(args));
       detachFinalizer(inner);
       var $$ = inner.$$;
       inner["notifyOnDestruction"]();

src/jsifier.js

@@ -237,9 +237,9 @@ ${argConvertions}
     if (LIBRARY_DEBUG && !isJsOnlySymbol(symbol)) {
       snippet = modifyJSFunction(snippet, (args, body, async) => `\
 function(${args}) {
-  var ret = (function() { if (runtimeDebug) err("[library call:${mangled}: " + Array.prototype.slice.call(arguments).map(prettyPrint) + "]");
+  var ret = (function(...args) { if (runtimeDebug) err("[library call:${mangled}: " + args.map(prettyPrint) + "]");
   ${body}
-  }).apply(this, arguments);
+  }).apply(this, ...args);
   if (runtimeDebug && typeof ret != "undefined") err("  [     return:" + prettyPrint(ret));
   return ret;
 }`);

src/library.js

@@ -3113,12 +3113,7 @@ addToLibrary({
 #if ASSERTIONS && !DYNCALLS
     assert(sig.includes('j') || sig.includes('p'), 'getDynCaller should only be called with i64 sigs')
 #endif
-    var argCache = [];
-    return function() {
-      argCache.length = 0;
-      Object.assign(argCache, arguments);
-      return dynCall(sig, ptr, argCache);
-    };
+    return (...args) => dynCall(sig, ptr, args);
   },
 
   $dynCall__docs: '/** @param {Object=} args */',

src/library_async.js

@@ -68,10 +68,10 @@ addToLibrary({
           }
 #endif
 #if ASSERTIONS && ASYNCIFY != 2 // We cannot apply assertions with stack switching, as the imports must not be modified from suspender.suspendOnReturnedPromise TODO find a way
-          imports[x] = function() {
+          imports[x] = (...args) => {
             var originalAsyncifyState = Asyncify.state;
             try {
-              return original.apply(null, arguments);
+              return original.apply(null, args);
             } finally {
               // Only asyncify-declared imports are allowed to change the
               // state.
@@ -130,7 +130,7 @@ addToLibrary({
             original = Asyncify.makeAsyncFunction(original);
           }
 #endif
-          ret[x] = function() {
+          ret[x] = (...args) => {
 #if ASYNCIFY_DEBUG >= 2
             dbg(`ASYNCIFY: ${'  '.repeat(Asyncify.exportCallStack.length} try ${x}`);
 #endif
@@ -143,9 +143,9 @@ addToLibrary({
               // can just call the function with no args at all since and the engine will produce zeros
               // for all arguments.  However, for i64 arguments we get `undefined cannot be converted to
               // BigInt`.
-              return original.apply(null, Asyncify.saveOrRestoreRewindArguments(x, arguments));
+              return original.apply(null, Asyncify.saveOrRestoreRewindArguments(x, args));
 #else
-              return original.apply(null, arguments);
+              return original.apply(null, args);
 #endif
 #if ASYNCIFY == 1
             } finally {

src/library_fs.js

@@ -1784,9 +1784,9 @@ FS.staticInit();` +
       var keys = Object.keys(node.stream_ops);
       keys.forEach((key) => {
         var fn = node.stream_ops[key];
-        stream_ops[key] = function forceLoadLazyFile() {
+        stream_ops[key] = (...args) => {
           FS.forceLoadFile(node);
-          return fn.apply(null, arguments);
+          return fn.apply(null, args);
         };
       });
       function writeChunks(stream, buffer, offset, length, position) {

src/library_idbfs.js

@@ -21,10 +21,8 @@ addToLibrary({
     },
     DB_VERSION: 21,
     DB_STORE_NAME: 'FILE_DATA',
-    mount: function(mount) {
-      // reuse all of the core MEMFS functionality
-      return MEMFS.mount.apply(null, arguments);
-    },
+    // reuse all of the core MEMFS functionality
+    mount: (...args) => MEMFS.mount.apply(null, ...args);
     syncfs: (mount, populate, callback) => {
       IDBFS.getLocalSet(mount, (err, local) => {
         if (err) return callback(err);

src/library_nodepath.js

@@ -17,18 +17,15 @@ addToLibrary({
     normalize: (path) => nodePath['normalize'](path),
     dirname: (path) => nodePath['dirname'](path),
     basename: (path) => nodePath['basename'](path),
-    join: function () {
-      return nodePath['join'].apply(null, arguments);
-    },
+    join: (...args) => nodePath['join'].apply(null, args),
     join2: (l, r) => nodePath['join'](l, r),
   },
   // The FS-using parts are split out into a separate object, so simple path
   // usage does not require the FS.
   $PATH_FS__deps: ['$FS'],
   $PATH_FS__docs: '/** @type{{resolve: function(...*)}} */',
   $PATH_FS: {
-    resolve: function () {
-      var paths = Array.prototype.slice.call(arguments, 0);
+    resolve: (...paths) => {
       paths.unshift(FS.cwd());
       return nodePath['posix']['resolve'].apply(null, paths);
     },

src/library_noderawfs.js

@@ -9,9 +9,9 @@ addToLibrary({
   $NODERAWFS__postset: `
     if (ENVIRONMENT_IS_NODE) {
       var _wrapNodeError = function(func) {
-        return function() {
+        return function(...args) {
           try {
-            return func.apply(this, arguments)
+            return func.apply(this, args)
           } catch (e) {
             if (e.code) {
               throw new FS.ErrnoError(ERRNO_CODES[e.code]);
@@ -52,34 +52,34 @@ addToLibrary({
     },
     // generic function for all node creation
     cwd() { return process.cwd(); },
-    chdir() { process.chdir.apply(void 0, arguments); },
+    chdir(args) { process.chdir.apply(void 0, args); },
     mknod(path, mode) {
       if (FS.isDir(path)) {
         fs.mkdirSync(path, mode);
       } else {
         fs.writeFileSync(path, '', { mode: mode });
       }
     },
-    mkdir() { fs.mkdirSync.apply(void 0, arguments); },
-    symlink() { fs.symlinkSync.apply(void 0, arguments); },
-    rename() { fs.renameSync.apply(void 0, arguments); },
-    rmdir() { fs.rmdirSync.apply(void 0, arguments); },
-    readdir() { return ['.', '..'].concat(fs.readdirSync.apply(void 0, arguments)); },
-    unlink() { fs.unlinkSync.apply(void 0, arguments); },
-    readlink() { return fs.readlinkSync.apply(void 0, arguments); },
-    stat() { return fs.statSync.apply(void 0, arguments); },
-    lstat() { return fs.lstatSync.apply(void 0, arguments); },
-    chmod() { fs.chmodSync.apply(void 0, arguments); },
+    mkdir(...args) { fs.mkdirSync.apply(void 0, args); },
+    symlink(...args) { fs.symlinkSync.apply(void 0, args); },
+    rename(...args) { fs.renameSync.apply(void 0, args); },
+    rmdir(...args) { fs.rmdirSync.apply(void 0, args); },
+    readdir(...args) { return ['.', '..'].concat(fs.readdirSync.apply(void 0, args)); },
+    unlink(...args) { fs.unlinkSync.apply(void 0, args); },
+    readlink(...args) { return fs.readlinkSync.apply(void 0, args); },
+    stat(...args) { return fs.statSync.apply(void 0, args); },
+    lstat(...args) { return fs.lstatSync.apply(void 0, args); },
+    chmod(...args) { fs.chmodSync.apply(void 0, args); },
     fchmod(fd, mode) {
       var stream = FS.getStreamChecked(fd);
       fs.fchmodSync(stream.nfd, mode);
     },
-    chown() { fs.chownSync.apply(void 0, arguments); },
+    chown(...args) { fs.chownSync.apply(void 0, args); },
     fchown(fd, owner, group) {
       var stream = FS.getStreamChecked(fd);
       fs.fchownSync(stream.nfd, owner, group);
     },
-    truncate() { fs.truncateSync.apply(void 0, arguments); },
+    truncate(...args) { fs.truncateSync.apply(void 0, args); },
     ftruncate(fd, len) {
       // See https://github.com/nodejs/node/issues/35632
       if (len < 0) {

src/library_path.js

@@ -72,10 +72,7 @@ addToLibrary({
       if (lastSlash === -1) return path;
       return path.substr(lastSlash+1);
     },
-    join: function() {
-      var paths = Array.prototype.slice.call(arguments);
-      return PATH.normalize(paths.join('/'));
-    },
+    join: (...paths) => PATH.normalize(paths.join('/')),
     join2: (l, r) => PATH.normalize(l + '/' + r),
   },
   // The FS-using parts are split out into a separate object, so simple path
@@ -90,11 +87,11 @@ addToLibrary({
 #endif
   ],
   $PATH_FS: {
-    resolve: function() {
+    resolve: (...args) => {
       var resolvedPath = '',
         resolvedAbsolute = false;
-      for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-        var path = (i >= 0) ? arguments[i] : FS.cwd();
+      for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+        var path = (i >= 0) ? args[i] : FS.cwd();
         // Skip empty and invalid entries
         if (typeof path != 'string') {
           throw new TypeError('Arguments to path.resolve must be strings');