Move modularization code into JS files. NFC

Its much easier to generate JS code using out JS template system than
emitting directly from python.

Split out from emscripten-core#23261

Author: sbc100

src/modularize_suffix.js

@@ -0,0 +1,71 @@
+// Export using a UMD style export, or ES6 exports if selected
+#if EXPORT_ES6
+export default {{{ EXPORT_NAME }}};
+#elif !MINIMAL_RUNTIME
+if (typeof exports === 'object' && typeof module === 'object') {
+  module.exports = {{{ EXPORT_NAME }}};
+  // This default export looks redundant, but it allows TS to import this
+  // commonjs style module.
+  module.exports.default = {{{ EXPORT_NAME }}};
+} else if (typeof define === 'function' && define['amd'])
+  define([], () => {{{ EXPORT_NAME }}});
+#endif
+
+
+#if PTHREADS
+
+// Create code for detecting if we are running in a pthread.
+// Normally this detection is done when the module is itself run but
+// when running in MODULARIZE mode we need use this to know if we should
+// run the module constructor on startup (true only for pthreads).
+#if ENVIRONMENT_MAY_BE_WEB || ENVIRONMENT_MAY_BE_WORKER
+var isPthread = globalThis.self?.name?.startsWith('em-pthread');
+#if ENVIRONMENT_MAY_BE_NODE
+// In order to support both web and node we also need to detect node here.
+var isNode = {{{ nodeDetectionCode() }}};
+if (isNode) isPthread = {{{ nodePthreadDetection() }}}
+#endif
+#else ENVIRONMENT_MAY_BE_NODE
+var isPthread = {{{ nodePthreadDetection() }}}
+// When running as a pthread, construct a new instance on startup
+#endif
+
+#if MODULARIZE == 'instance'
+isPthread && init();
+#else
+isPthread && {{{ EXPORT_NAME }}}();
+#endif
+
+#endif // PTHREADS
+
+#if WASM_WORKERS
+
+// Same as above for for WASM_WORKERS
+// Normally this detection is done when the module is itself run but
+// when running in MODULARIZE mode we need use this to know if we should
+// run the module constructor on startup (true only for pthreads).
+#if ENVIRONMENT_MAY_BE_WEB || ENVIRONMENT_MAY_BE_WORKER
+var isWW = globalThis.self?.name == 'em-ww';
+// In order to support both web and node we also need to detect node here.
+#if ENVIRONMENT_MAY_BE_NODE
+#if !PTHREADS
+var isNode = {{{ nodeDetectionCode() }}};
+#endif
+if (isNode) isWW = {{{ nodeWWDetection() }}};
+#endif
+#elif ENVIRONMENT_MAY_BE_NODE
+var isWW = {{{ nodeWWDetection() }}};
+#endif
+
+#if AUDIO_WORKLET
+isWW ||= typeof AudioWorkletGlobalScope !== 'undefined';
+// When running as a wasm worker, construct a new instance on startup
+#endif
+
+#if MODULARIZE == 'instance'
+isWW && init();
+#else
+isWW && {{{ EXPORT_NAME }}}();
+#endif
+
+#endif // WASM_WORKERS

src/parseTools.mjs

@@ -1097,6 +1097,41 @@ function nodeDetectionCode() {
   return "typeof process == 'object' && process.versions?.node && process.type != 'renderer'";
 }
 
+function nodePthreadDetection() {
+  // Under node we detect that we are running in a pthread by checking the
+  // workerData property.
+  if (EXPORT_ES6) {
+    return "(await import('worker_threads')).workerData === 'em-pthread'";
+  } else {
+    return "require('worker_threads').workerData === 'em-pthread'";
+  }
+}
+
+function nodeWWDetection() {
+  // Under node we detect that we are running in a wasm worker by checking the
+  // workerData property.
+  if (EXPORT_ES6) {
+    return "(await import('worker_threads')).workerData === 'em-ww'";
+  } else {
+    return "require('worker_threads').workerData === 'em-ww'";
+  }
+}
+
+function declareInstanceExports() {
+  const allExports = Array.from(EXPORTED_FUNCTIONS.keys()).concat(
+    Array.from(EXPORTED_RUNTIME_METHODS.keys()),
+  );
+  const mangledExports = allExports.map((e) => `__exp_${e}`);
+  const mangledExportsAs = allExports.map((e) => `__exp_${e} as ${e}`);
+  // Declare a top level var for each export so that code in the init function
+  // can assign to it and update the live module bindings.
+  if (allExports.length == 0) return '';
+  let rtn = 'var ' + mangledExports.join(', ') + ';\n';
+  // Export the functions with their original name.
+  rtn += 'export {' + mangledExportsAs.join(', ') + '};\n';
+  return rtn;
+}
+
 addToCompileTimeContext({
   ATEXITS,
   ATPRERUNS,
@@ -1169,4 +1204,6 @@ addToCompileTimeContext({
   storeException,
   to64,
   toIndexType,
+  nodePthreadDetection,
+  nodeWWDetection,
 });

tools/link.py

@@ -2445,24 +2445,6 @@ def phase_binaryen(target, options, wasm_target):
     write_file(final_js, js)
 
 
-def node_pthread_detection():
-  # Under node we detect that we are running in a pthread by checking the
-  # workerData property.
-  if settings.EXPORT_ES6:
-    return "(await import('worker_threads')).workerData === 'em-pthread';\n"
-  else:
-    return "require('worker_threads').workerData === 'em-pthread'\n"
-
-
-def node_ww_detection():
-  # Under node we detect that we are running in a wasm worker by checking the
-  # workerData property.
-  if settings.EXPORT_ES6:
-    return "(await import('worker_threads')).workerData === 'em-ww';\n"
-  else:
-    return "require('worker_threads').workerData === 'em-ww'\n"
-
-
 def modularize():
   global final_js
   logger.debug(f'Modularizing, assigning to var {settings.EXPORT_NAME}')
@@ -2513,60 +2495,7 @@ def modularize():
   if settings.SOURCE_PHASE_IMPORTS:
     src = f"import source wasmModule from './{settings.WASM_BINARY_FILE}';\n\n" + src
 
-  # Export using a UMD style export, or ES6 exports if selected
-  if settings.EXPORT_ES6:
-    src += 'export default %s;\n' % settings.EXPORT_NAME
-  elif not settings.MINIMAL_RUNTIME:
-    src += '''\
-if (typeof exports === 'object' && typeof module === 'object') {
-  module.exports = %(EXPORT_NAME)s;
-  // This default export looks redundant, but it allows TS to import this
-  // commonjs style module.
-  module.exports.default = %(EXPORT_NAME)s;
-} else if (typeof define === 'function' && define['amd'])
-  define([], () => %(EXPORT_NAME)s);
-''' % {'EXPORT_NAME': settings.EXPORT_NAME}
-
-  if settings.PTHREADS:
-    # Create code for detecting if we are running in a pthread.
-    # Normally this detection is done when the module is itself run but
-    # when running in MODULARIZE mode we need use this to know if we should
-    # run the module constructor on startup (true only for pthreads).
-    if settings.ENVIRONMENT_MAY_BE_WEB or settings.ENVIRONMENT_MAY_BE_WORKER:
-      src += "var isPthread = globalThis.self?.name?.startsWith('em-pthread');\n"
-      # In order to support both web and node we also need to detect node here.
-      if settings.ENVIRONMENT_MAY_BE_NODE:
-        src += f'var isNode = {node_detection_code()};\n'
-        src += f'if (isNode) isPthread = {node_pthread_detection()}\n'
-    elif settings.ENVIRONMENT_MAY_BE_NODE:
-      src += f'var isPthread = {node_pthread_detection()}\n'
-    src += '// When running as a pthread, construct a new instance on startup\n'
-    if settings.MODULARIZE == 'instance':
-      src += 'isPthread && init();\n'
-    else:
-      src += 'isPthread && %s();\n' % settings.EXPORT_NAME
-
-  if settings.WASM_WORKERS:
-    # Same as above for for WASM_WORKERS
-    # Normally this detection is done when the module is itself run but
-    # when running in MODULARIZE mode we need use this to know if we should
-    # run the module constructor on startup (true only for pthreads).
-    if settings.ENVIRONMENT_MAY_BE_WEB or settings.ENVIRONMENT_MAY_BE_WORKER:
-      src += "var isWW = globalThis.self?.name == 'em-ww';\n"
-      # In order to support both web and node we also need to detect node here.
-      if settings.ENVIRONMENT_MAY_BE_NODE:
-        if not settings.PTHREADS:
-          src += f'var isNode = {node_detection_code()};\n'
-        src += f'if (isNode) isWW = {node_ww_detection()}\n'
-    elif settings.ENVIRONMENT_MAY_BE_NODE:
-      src += f'var isWW = {node_ww_detection()}\n'
-    if settings.AUDIO_WORKLET:
-      src += "isWW ||= typeof AudioWorkletGlobalScope !== 'undefined';\n"
-    src += '// When running as a wasm worker, construct a new instance on startup\n'
-    if settings.MODULARIZE == 'instance':
-      src += 'isWW && init();\n'
-    else:
-      src += 'isWW && %s();\n' % settings.EXPORT_NAME
+  src += building.read_and_preprocess(utils.path_from_root('src/modularize_suffix.js'), expand_macros=True)
 
   final_js += '.modular.js'
   write_file(final_js, src)