In MODULARIZE mode avoid modifying the incoming moduleArg. NFC

src/closure-externs/closure-externs.js

@@ -245,9 +245,8 @@ var moduleArg;
  * Used in MODULARIZE mode.
  * We need to access this after the code we pass to closure so from closure's
  * POV this is "extern".
- * @suppress {duplicate}
  */
-var readyPromise;
+var moduleRtn;
 
 /**
  * This was removed from upstream closure compiler in

src/jsifier.mjs

@@ -744,6 +744,10 @@ var proxiedFunctionTable = [
       includeFile(fileName, shouldPreprocess(fileName));
     }
 
+    if (MODULARIZE) {
+      includeFile('postamble_modularize.js');
+    }
+
     print(
       '//FORWARDED_DATA:' +
         JSON.stringify({

src/postamble_modularize.js

@@ -0,0 +1,41 @@
+// In MODULARIZE mode we wrap the generated code in a factory function
+// and return either the Module itself, or a promise of the module.
+//
+// We assign to the `moduleRtn` global here and configure closure to see
+// this as and extern so it won't get minified.
+
+#if WASM_ASYNC_COMPILATION
+
+#if USE_READY_PROMISE
+moduleRtn = readyPromise;
+#else
+moduleRtn = {};
+#endif
+
+#else  // WASM_ASYNC_COMPILATION
+
+moduleRtn = Module;
+
+#endif // WASM_ASYNC_COMPILATION
+
+#if ASSERTIONS
+// Assertion for attempting to access module properties on the incoming
+// moduleArg.  In the past we used this object as the prototype of the module
+// and assigned properties to it, but now we return a distinct object.  This
+// keeps the instance private until it is ready (i.e the promise has been
+// resolved).
+for (const prop of Object.keys(Module)) {
+  if (!(prop in moduleArg)) {
+    Object.defineProperty(moduleArg, prop, {
+      configurable: true,
+      get() {
+#if WASM_ASYNC_COMPILATION
+        abort(`Access to module property ('${prop}') is no longer possible via the incoming module contructor argument; Instead, use the result of the module promise.`)
+#else
+        abort(`Access to module property ('${prop}') is no longer possible via the module input argument; Instead, use the module constructor return value.`)
+#endif
+      }
+    });
+  }
+}
+#endif

src/shell.js

@@ -10,7 +10,7 @@
 // The Module object: Our interface to the outside world. We import
 // and export values on it. There are various ways Module can be used:
 // 1. Not defined. We create it here
-// 2. A function parameter, function(Module) { ..generated code.. }
+// 2. A function parameter, function(moduleArg) => Promise<Module>
 // 3. pre-run appended it, var Module = {}; ..generated code..
 // 4. External script tag defines var Module.
 // We need to check if Module already exists (e.g. case 3 above).
@@ -21,7 +21,7 @@
 // before the code. Then that object will be used in the code, and you
 // can continue to use Module afterwards as well.
 #if MODULARIZE
-var Module = moduleArg;
+var Module = Object.assign({}, moduleArg);
 #elif USE_CLOSURE_COMPILER
 // if (!Module)` is crucial for Closure Compiler here as it will otherwise replace every `Module` occurrence with a string
 var /** @type {{

test/other/test_unoptimized_code_size.js.size

@@ -1 +1 @@
-55580
+55579

test/other/test_unoptimized_code_size_no_asserts.js.size

@@ -1 +1 @@
-31465
+31464

test/other/test_unoptimized_code_size_strict.js.size

@@ -1 +1 @@
-54468
+54467

test/test_other.py

@@ -6416,11 +6416,11 @@ def test_modularize_sync_compilation(self):
 console.log('before');
 var result = Module();
 // It should be an object.
-console.log(typeof result);
+console.log('typeof result: ' + typeof result);
 // And it should have the exports that Module has, showing it is Module in fact.
-console.log(typeof result._main);
+console.log('typeof _main: ' + typeof result._main);
 // And it should not be a Promise.
-console.log(typeof result.then);
+console.log('typeof result.then: ' + typeof result.then);
 console.log('after');
 ''')
     self.run_process([EMCC, test_file('hello_world.c'),
@@ -6430,12 +6430,25 @@ def test_modularize_sync_compilation(self):
     self.assertContained('''\
 before
 hello, world!
-object
-function
-undefined
+typeof result: object
+typeof _main: function
+typeof result.then: undefined
 after
 ''', self.run_js('a.out.js'))
 
+  def test_modularize_argument_misuse(self):
+    create_file('test.c', '''
+      #include <emscripten.h>
+      EMSCRIPTEN_KEEPALIVE int foo() { return 42; }''')
+
+    create_file('post.js', r'''
+      var arg = { bar: 1 };
+      var promise = Module(arg);
+      arg._foo();''')
+
+    expected = "Aborted(Access to module property ('_foo') is no longer possible via the incoming module contructor argument; Instead, use the result of the module promise"
+    self.do_runf('test.c', expected, assert_returncode=NON_ZERO, emcc_args=['--no-entry', '-sMODULARIZE', '--extern-post-js=post.js'])
+
   def test_export_all_3142(self):
     create_file('src.cpp', r'''
 typedef unsigned int Bit32u;

tools/link.py

@@ -2350,31 +2350,21 @@ def modularize(options):
      shared.target_environment_may_be('web'):
     async_emit = 'async '
 
-  # Return the incoming `moduleArg`.  This is is equivalent to the `Module` var within the
-  # generated code but its not run through closure minification so we can reference it in
-  # the return statement.
-  return_value = 'moduleArg'
-  if settings.WASM_ASYNC_COMPILATION:
-    if settings.USE_READY_PROMISE:
-      return_value = 'readyPromise'
-    else:
-      return_value = '{}'
-
   # TODO: Remove when https://bugs.webkit.org/show_bug.cgi?id=223533 is resolved.
   if async_emit != '' and settings.EXPORT_NAME == 'config':
     diagnostics.warning('emcc', 'EXPORT_NAME should not be named "config" when targeting Safari')
 
   src = '''
 %(maybe_async)sfunction(moduleArg = {}) {
+  var moduleRtn;
 
 %(src)s
 
-  return %(return_value)s
+  return moduleRtn;
 }
 ''' % {
     'maybe_async': async_emit,
     'src': src,
-    'return_value': return_value,
   }
 
   if settings.MINIMAL_RUNTIME and not settings.PTHREADS: