Defer emitting JS library aliases when target is in a dependency cycle

When a JS library alias target (e.g. `foo`) is visited first and
transitively depends on its own alias (e.g. `foo_alias: 'foo'`),
`addedLibraryItems['foo']` is marked as visited before `var _foo = ...`
is emitted. Without deferral, `addFromLibrary('foo_alias')` emits
`var _foo_alias = _foo;` before `var _foo = ...`, leaving `_foo_alias`
initialized to `undefined` for arrow functions and non-hoisted values.

Track emitted library symbols in `emittedLibraryItems` and defer alias
assignments in `deferredAliases` until immediately after their target
symbol is emitted.

Author: sbc100

src/jsifier.mjs

@@ -45,6 +45,8 @@ import {
 import {extraExports, LibraryManager, librarySymbols, nativeAliases} from './modules.mjs';
 
 const addedLibraryItems = {};
+const emittedLibraryItems = new Set();
+const deferredAliases = {};
 
 // Experimental feature to check for invalid __deps entries.
 // See `EMCC_CHECK_DEPS` in in the environment to try it out.
@@ -728,11 +730,12 @@ function(${args}) {
         }
       }
 
+      let aliasTarget;
       if (LibraryManager.isAlias(snippet)) {
         // Redirection for aliases. We include the parent, and at runtime
         // make ourselves equal to it.  This avoid having duplicate
         // functions with identical content.
-        const aliasTarget = snippet;
+        aliasTarget = snippet;
         if (WASM_EXPORTS.has(aliasTarget)) {
           debugLog(`native alias: ${mangled} -> ${aliasTarget}`);
           nativeAliases[mangled] = aliasTarget;
@@ -884,7 +887,23 @@ function(${args}) {
             .filter((x) => x != '')
             .join('\n') + '\n'
         : '';
-      return depsText + commentText + contentText;
+      if (aliasTarget && !isNativeAlias && !isFunction && !emittedLibraryItems.has(aliasTarget)) {
+        // If `aliasTarget` is not yet emitted, we are in a dependency cycle
+        // where `aliasTarget` is an ancestor on the recursion stack. Defer
+        // emitting `var _alias = _target;` until immediately after `_target`
+        // is defined so `_target` is not referenced before its initialization.
+        (deferredAliases[aliasTarget] ??= []).push({symbol, text: commentText + contentText});
+        return depsText.trim();
+      }
+      function flushDeferred(sym) {
+        emittedLibraryItems.add(sym);
+        let res = '';
+        for (const item of deferredAliases[sym] ?? []) {
+          res += '\n' + item.text + flushDeferred(item.symbol);
+        }
+        return res;
+      }
+      return depsText + commentText + contentText + flushDeferred(symbol);
     }
 
     const JS = addFromLibrary(symbol, 'root reference (e.g. compiled C/C++ code)');

test/test_jslib.py

@@ -604,7 +604,15 @@ def test_jslib_include(self):
   def test_jslib_aliases(self, args):
     create_file('foo.js', '''
       addToLibrary({
-        foo: () => 42,
+        // Create a dependency cycle (foo -> $call_alias -> foo_alias -> foo)
+        // to test that `var _foo_alias = _foo;` is still emitted after `_foo`.
+        $call_alias__deps: ['foo_alias'],
+        $call_alias: () => _foo_alias(),
+        foo__deps: ['$call_alias'],
+        foo: () => {
+          if (!call_alias) return 0;
+          return 42;
+        },
         foo__sig: 'i',
 
         foo_alias: 'foo',