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

Following up on emscripten-core#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,11 +834,11 @@ 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]);
       }
 
-      var rv = cppInvokerFunc.apply(null, invokerFuncArgs);
+      var rv = cppInvokerFunc(...invokerFuncArgs);
 
       function onDone(rv) {
         if (needsDestructorStack) {
@@ -896,11 +896,11 @@ var LibraryEmbind = {
 
 #if EMBIND_AOT
   var signature = createJsInvokerSignature(argTypes, isClassMethodFunc, returns, isAsync);
-  var invokerFn = InvokerFunctions[signature].apply(null, closureArgs);
+  var invokerFn = InvokerFunctions[signature](...closureArgs);
 #else
   let [args, invokerFnBody] = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync);
   args.push(invokerFnBody);
-  var invokerFn = newFunc(Function, args).apply(null, closureArgs);
+  var invokerFn = newFunc(Function, args)(...closureArgs);
 #endif
 #endif
     return createNamedFunction(humanName, invokerFn);
@@ -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/embind/emval.js

@@ -369,7 +369,7 @@ var LibraryEmVal = {
       "};\n";
 
     params.push(functionBody);
-    var invokerFunction = newFunc(Function, params).apply(null, args);
+    var invokerFunction = newFunc(Function, params)(...args);
 #endif
     var functionName = `methodCaller<(${types.map(t => t.name).join(', ')}) => ${retType.name}>`;
     return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction));

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);
+  }).call(this, ${args});
   if (runtimeDebug && typeof ret != "undefined") err("  [     return:" + prettyPrint(ret));
   return ret;
 }`);
@@ -443,7 +443,7 @@ function(${args}) {
           if (ASSERTIONS) {
             assertion += `if (!${target} || ${target}.stub) abort("external symbol '${symbol}' is missing. perhaps a side module was not linked in? if this function was expected to arrive from a system library, try to build the MAIN_MODULE with EMCC_FORCE_STDLIBS=1 in the environment");\n`;
           }
-          const functionBody = assertion + `return ${target}.apply(null, arguments);`;
+          const functionBody = assertion + `return ${target}(...arguments);`;
           LibraryManager.library[symbol] = new Function(functionBody);
           isStub = true;
         }

src/library.js

@@ -2874,7 +2874,7 @@ addToLibrary({
 #if ASSERTIONS
     assert(ASM_CONSTS.hasOwnProperty(code), `No EM_ASM constant found at address ${code}.  The loaded WebAssembly file is likely out of sync with the generated JavaScript.`);
 #endif
-    return ASM_CONSTS[code].apply(null, args);
+    return ASM_CONSTS[code](...args);
   },
 
   emscripten_asm_const_int__deps: ['$runEmAsmFunction'],
@@ -2917,7 +2917,7 @@ addToLibrary({
 #if ASSERTIONS
     assert(ASM_CONSTS.hasOwnProperty(code), `No EM_ASM constant found at address ${code}.  The loaded WebAssembly file is likely out of sync with the generated JavaScript.`);
 #endif
-    return ASM_CONSTS[code].apply(null, args);
+    return ASM_CONSTS[code](...args);
   },
   emscripten_asm_const_int_sync_on_main_thread__deps: ['$runMainThreadEmAsm'],
   emscripten_asm_const_int_sync_on_main_thread: (code, sigPtr, argbuf) => {
@@ -3100,7 +3100,7 @@ addToLibrary({
 #endif
     var f = Module['dynCall_' + sig];
 #endif
-    return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr);
+    return f(ptr, ...args);
   },
   $dynCall__deps: ['$dynCallLegacy', '$getWasmTableEntry'],
 #endif
@@ -3113,15 +3113,10 @@ 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 */',
+  $dynCall__docs: '/** @param {!Array} args */',
   $dynCall: (sig, ptr, args) => {
 #if MEMORY64
     // With MEMORY64 we have an additional step to convert `p` arguments to
@@ -3145,7 +3140,7 @@ addToLibrary({
 #if ASSERTIONS
     assert(getWasmTableEntry(ptr), `missing table entry in dynCall: ${ptr}`);
 #endif
-    var rtn = getWasmTableEntry(ptr).apply(null, args);
+    var rtn = getWasmTableEntry(ptr)(...args);
 #endif
 #if MEMORY64
     return sig[0] == 'p' ? Number(rtn) : rtn;

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(...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(...Asyncify.saveOrRestoreRewindArguments(x, args));
 #else
-              return original.apply(null, arguments);
+              return original(...args);
 #endif
 #if ASYNCIFY == 1
             } finally {

src/library_ccall.js

@@ -77,7 +77,7 @@ addToLibrary({
     // Data for a previous async operation that was in flight before us.
     var previousAsync = Asyncify.currData;
 #endif
-    var ret = func.apply(null, cArgs);
+    var ret = func(...cArgs);
     function onDone(ret) {
 #if ASYNCIFY == 1
       runtimeKeepalivePop();

src/library_dylink.js

@@ -707,9 +707,9 @@ var LibraryDylink = {
           // when first called.
           if (!(prop in stubs)) {
             var resolved;
-            stubs[prop] = function() {
+            stubs[prop] = (...args) => {
               resolved ||= resolveSymbol(prop);
-              return resolved.apply(null, arguments);
+              return resolved(...args);
             };
           }
           return stubs[prop];

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(...args);
         };
       });
       function writeChunks(stream, buffer, offset, length, position) {

src/library_glemu.js

@@ -3580,7 +3580,7 @@ var LibraryGLEmulation = {
         _glEnableVertexAttribArray(vaa);
       }
       for (var vaa in info.vertexAttribPointers) {
-        _glVertexAttribPointer.apply(null, info.vertexAttribPointers[vaa]);
+        _glVertexAttribPointer(...info.vertexAttribPointers[vaa]);
       }
       for (var attrib in info.enabledClientStates) {
         _glEnableClientState(attrib|0);

src/library_html5.js

@@ -140,7 +140,7 @@ var LibraryHTML5 = {
         var call = JSEvents.deferredCalls[i];
         JSEvents.deferredCalls.splice(i, 1);
         --i;
-        call.targetFunction.apply(null, call.argsList);
+        call.targetFunction(...call.argsList);
       }
     },
 #endif

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(...args);
     syncfs: (mount, populate, callback) => {
       IDBFS.getLocalSet(mount, (err, local) => {
         if (err) return callback(err);

src/library_math.js

@@ -26,7 +26,7 @@ addToLibrary({
     for (var i = 0; i < count; ++i) {
       args.push({{{ makeGetValue('varargs', `i * ${getNativeTypeSize('double')}`, 'double') }}});
     }
-    return Math.hypot.apply(null, args);
+    return Math.hypot(...args);
   },
   emscripten_math_sin: (x) => Math.sin(x),
   emscripten_math_sinh: (x) => Math.sinh(x),

src/library_nodefs.js

@@ -87,7 +87,7 @@ addToLibrary({
       }
       parts.push(node.mount.opts.root);
       parts.reverse();
-      return PATH.join.apply(null, parts);
+      return PATH.join(...parts);
     },
     // This maps the integer permission modes from http://linux.die.net/man/3/open
     // to node.js-specific file open permission strings at http://nodejs.org/api/fs.html#fs_fs_open_path_flags_mode_callback

src/library_nodepath.js

@@ -17,20 +17,17 @@ 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'](...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);
+      return nodePath['posix']['resolve'](...paths);
     },
     relative: (from, to) => nodePath['posix']['relative'](from || FS.cwd(), to || FS.cwd()),
   }