Prefer for..of over forEach with lambdas. NFC

src/lib/libatomic.js

@@ -128,23 +128,23 @@ addToLibrary({
   emscripten_atomic_cancel_all_wait_asyncs__deps: ['$liveAtomicWaitAsyncs'],
   emscripten_atomic_cancel_all_wait_asyncs: () => {
     let waitAsyncs = Object.values(liveAtomicWaitAsyncs);
-    waitAsyncs.forEach((address) => {
+    for (var address of waitAsyncs) {
       Atomics.notify(HEAP32, {{{ getHeapOffset('address', 'i32') }}});
-    });
+    }
     liveAtomicWaitAsyncs = {};
     return waitAsyncs.length;
   },
 
   emscripten_atomic_cancel_all_wait_asyncs_at_address__deps: ['$liveAtomicWaitAsyncs'],
   emscripten_atomic_cancel_all_wait_asyncs_at_address: (address) => {
     let numCancelled = 0;
-    Object.keys(liveAtomicWaitAsyncs).forEach((waitToken) => {
-      if (liveAtomicWaitAsyncs[waitToken] == address) {
+    for (var [waitToken, waitAddress] of Object.entries(liveAtomicWaitAsyncs)) {
+      if (waitAddress == address) {
         Atomics.notify(HEAP32, {{{ getHeapOffset('address', 'i32') }}});
         delete liveAtomicWaitAsyncs[waitToken];
         numCancelled++;
       }
-    });
+    }
     return numCancelled;
   },
 

src/lib/libcore.js

@@ -1714,18 +1714,18 @@ addToLibrary({
   // If @elements is not provided, we default to the document and canvas
   // elements, which handle common use cases.
   // TODO(sbc): Remove seemingly unused elements argument
-  $autoResumeAudioContext__docs: '/** @param {Object=} elements */',
+  $autoResumeAudioContext__docs: '/** @param {Array<Object>=} elements */',
   $autoResumeAudioContext: (ctx, elements) => {
     if (!elements) {
       elements = [document, document.getElementById('canvas')];
     }
-    ['keydown', 'mousedown', 'touchstart'].forEach((event) => {
-      elements.forEach((element) => {
+    for (var event of ['keydown', 'mousedown', 'touchstart']) {
+      for (var element of elements) {
         element?.addEventListener(event, () => {
           if (ctx.state === 'suspended') ctx.resume();
         }, { 'once': true });
-      });
-    });
+      }
+    }
   },
 
 #if DYNCALLS || !WASM_BIGINT

src/lib/libdylink.js

@@ -978,7 +978,9 @@ var LibraryDylink = {
         .then(loadModule);
     }
 
-    metadata.neededDynlibs.forEach((needed) => loadDynamicLibrary(needed, flags, localScope));
+    for (var needed of metadata.neededDynlibs) {
+      loadDynamicLibrary(needed, flags, localScope)
+    }
     return loadModule();
   },
 

src/lib/libembind.js

@@ -897,20 +897,20 @@ var LibraryEmbind = {
     var rawDestructor = reg.rawDestructor;
 
     whenDependentTypesAreResolved([rawTupleType], elementTypes, (elementTypes) => {
-      elements.forEach((elt, i) => {
-        var getterReturnType = elementTypes[i];
-        var getter = elt.getter;
-        var getterContext = elt.getterContext;
-        var setterArgumentType = elementTypes[i + elementsLength];
-        var setter = elt.setter;
-        var setterContext = elt.setterContext;
+      for (const [i, elt] of elements.entries()) {
+        const getterReturnType = elementTypes[i];
+        const getter = elt.getter;
+        const getterContext = elt.getterContext;
+        const setterArgumentType = elementTypes[i + elementsLength];
+        const setter = elt.setter;
+        const setterContext = elt.setterContext;
         elt.read = (ptr) => getterReturnType.fromWireType(getter(getterContext, ptr));
         elt.write = (ptr, o) => {
           var destructors = [];
           setter(setterContext, ptr, setterArgumentType.toWireType(destructors, o));
           runDestructors(destructors);
         };
-      });
+      }
 
       return [{
         name: reg.name,
@@ -998,25 +998,23 @@ var LibraryEmbind = {
               concat(fieldRecords.map((field) => field.setterArgumentType));
     whenDependentTypesAreResolved([structType], fieldTypes, (fieldTypes) => {
       var fields = {};
-      fieldRecords.forEach((field, i) => {
-        var fieldName = field.fieldName;
-        var getterReturnType = fieldTypes[i];
-        var optional = fieldTypes[i].optional;
-        var getter = field.getter;
-        var getterContext = field.getterContext;
-        var setterArgumentType = fieldTypes[i + fieldRecords.length];
-        var setter = field.setter;
-        var setterContext = field.setterContext;
-        fields[fieldName] = {
+      for (var [i, field] of fieldRecords.entries()) {
+        const getterReturnType = fieldTypes[i];
+        const getter = field.getter;
+        const getterContext = field.getterContext;
+        const setterArgumentType = fieldTypes[i + fieldRecords.length];
+        const setter = field.setter;
+        const setterContext = field.setterContext;
+        fields[field.fieldName] = {
           read: (ptr) => getterReturnType.fromWireType(getter(getterContext, ptr)),
           write: (ptr, o) => {
             var destructors = [];
             setter(setterContext, ptr, setterArgumentType.toWireType(destructors, o));
             runDestructors(destructors);
           },
-          optional,
+          optional: getterReturnType.optional,
         };
-      });
+      }
 
       return [{
         name: reg.name,
@@ -2101,11 +2099,11 @@ var LibraryEmbind = {
     var baseClassPrototype = baseClass.instancePrototype;
     var baseConstructor = registeredClass.baseClass.constructor;
     var ctor = createNamedFunction(constructorName, function(...args) {
-      registeredClass.baseClass.pureVirtualFunctions.forEach(function(name) {
+      for (var name of registeredClass.baseClass.pureVirtualFunctions) {
         if (this[name] === baseClassPrototype[name]) {
           throw new PureVirtualError(`Pure virtual function ${name} must be implemented in JavaScript`);
         }
-      }.bind(this));
+      }
 
       Object.defineProperty(this, '__parent', {
         value: wrapperPrototype

src/lib/libembind_shared.js

@@ -71,7 +71,7 @@ var LibraryEmbindShared = {
     var typeConverters = new Array(dependentTypes.length);
     var unregisteredTypes = [];
     var registered = 0;
-    dependentTypes.forEach((dt, i) => {
+    for (let [i, dt] of dependentTypes.entries()) {
       if (registeredTypes.hasOwnProperty(dt)) {
         typeConverters[i] = registeredTypes[dt];
       } else {
@@ -87,7 +87,7 @@ var LibraryEmbindShared = {
           }
         });
       }
-    });
+    }
     if (0 === unregisteredTypes.length) {
       onComplete(typeConverters);
     }

src/lib/libfs.js

@@ -583,12 +583,13 @@ FS.staticInit();`;
       };
 
       // sync all mounts
-      mounts.forEach((mount) => {
-        if (!mount.type.syncfs) {
-          return done(null);
+      for (var mount of mounts) {
+        if (mount.type.syncfs) {
+          mount.type.syncfs(mount, populate, done);
+        } else {
+          done(null);
         }
-        mount.type.syncfs(mount, populate, done);
-      });
+      }
     },
     mount(type, opts, mountpoint) {
 #if ASSERTIONS
@@ -657,9 +658,7 @@ FS.staticInit();`;
       var mount = node.mounted;
       var mounts = FS.getMounts(mount);
 
-      Object.keys(FS.nameTable).forEach((hash) => {
-        var current = FS.nameTable[hash];
-
+      for (var [hash, current] of Object.entries(FS.nameTable)) {
         while (current) {
           var next = current.name_next;
 
@@ -669,7 +668,7 @@ FS.staticInit();`;
 
           current = next;
         }
-      });
+      }
 
       // no longer a mountpoint
       node.mounted = null;
@@ -1850,14 +1849,12 @@ FS.staticInit();`;
       });
       // override each stream op with one that tries to force load the lazy file first
       var stream_ops = {};
-      var keys = Object.keys(node.stream_ops);
-      keys.forEach((key) => {
-        var fn = node.stream_ops[key];
+      for (const [key, fn] of Object.entries(node.stream_ops)) {
         stream_ops[key] = (...args) => {
           FS.forceLoadFile(node);
           return fn(...args);
         };
-      });
+      }
       function writeChunks(stream, buffer, offset, length, position) {
         var contents = stream.node.contents;
         if (position >= contents.length)

src/lib/libglemu.js

@@ -626,10 +626,10 @@ var LibraryGLEmulation = {
         if (GL.debug) {
           dbg('[using program with shaders]');
           if (program) {
-            GL.programShaders[program].forEach((shader) => {
+            for (var shader of GL.programShaders[program]) {
               dbg(`  shader ${shader}, original source: ${GL.shaderOriginalSources[shader]}`);
               dbg(`         Source: ${GL.shaderSources[shader]}`);
-            });
+            }
           }
         }
 #endif

src/lib/libidbfs.js

@@ -114,7 +114,9 @@ addToLibrary({
       });
     },
     quit: () => {
-      Object.values(IDBFS.dbs).forEach((value) => value.close());
+      for (var value of Object.values(IDBFS.dbs)) {
+        value.close()
+      }
       IDBFS.dbs = {};
     },
     getDB: (name, callback) => {
@@ -312,22 +314,21 @@ addToLibrary({
       var total = 0;
 
       var create = [];
-      Object.keys(src.entries).forEach((key) => {
-        var e = src.entries[key];
+      for (var [key, e] of Object.entries(src.entries)) {
         var e2 = dst.entries[key];
         if (!e2 || e['timestamp'].getTime() != e2['timestamp'].getTime()) {
           create.push(key);
           total++;
         }
-      });
+      }
 
       var remove = [];
-      Object.keys(dst.entries).forEach((key) => {
+      for (var key of Object.keys(dst.entries)) {
         if (!src.entries[key]) {
           remove.push(key);
           total++;
         }
-      });
+      }
 
       if (!total) {
         return callback(null);
@@ -359,7 +360,7 @@ addToLibrary({
 
       // sort paths in ascending order so directory entries are created
       // before the files inside them
-      create.sort().forEach((path) => {
+      for (const path of create.sort()) {
         if (dst.type === 'local') {
           IDBFS.loadRemoteEntry(store, path, (err, entry) => {
             if (err) return done(err);
@@ -371,17 +372,17 @@ addToLibrary({
             IDBFS.storeRemoteEntry(store, path, entry, done);
           });
         }
-      });
+      }
 
       // sort paths in descending order so files are deleted before their
       // parent directories
-      remove.sort().reverse().forEach((path) => {
+      for (var path of remove.sort().reverse()) {
         if (dst.type === 'local') {
           IDBFS.removeLocalEntry(path, done);
         } else {
           IDBFS.removeRemoteEntry(store, path, done);
         }
-      });
+      }
     }
   }
 });

src/lib/libwasi.js

@@ -119,7 +119,9 @@ var WasiLibrary = {
 #if MAIN_READS_PARAMS
     {{{ makeSetValue('pargc', 0, 'mainArgs.length', SIZE_TYPE) }}};
     var bufSize = 0;
-    mainArgs.forEach((arg) => bufSize += arg.length + 1);
+    for (var arg of mainArgs) {
+      bufSize += arg.length + 1;
+    }
     {{{ makeSetValue('pargv_buf_size', 0, 'bufSize', SIZE_TYPE) }}};
 #else
     {{{ makeSetValue('pargc', 0, '0', SIZE_TYPE) }}};
@@ -132,12 +134,12 @@ var WasiLibrary = {
   args_get: (argv, argv_buf) => {
 #if MAIN_READS_PARAMS
     var bufSize = 0;
-    mainArgs.forEach((arg, i) => {
+    for (let [i, arg] of mainArgs.entries()) {
       var ptr = argv_buf + bufSize;
       {{{ makeSetValue('argv', `i*${POINTER_SIZE}`, 'ptr', '*') }}};
       stringToAscii(arg, ptr);
       bufSize += arg.length + 1;
-    });
+    }
 #endif
     return 0;
   },

src/lib/libwasmfs_node.js

@@ -74,7 +74,7 @@ addToLibrary({
     let path = UTF8ToString(path_p);
     return wasmfsTry(() => {
       let entries = fs.readdirSync(path, { withFileTypes: true });
-      entries.forEach((entry) => {
+      for (var entry of entries) {
         let sp = stackSave();
         let name = stringToUTF8OnStack(entry.name);
         let type;
@@ -90,7 +90,7 @@ addToLibrary({
         __wasmfs_node_record_dirent(vec, name, type);
         stackRestore(sp);
         // implicitly return 0
-      });
+      }
     });
   },