closure inconsistencies with pre/post scripts

[agordon]

Hello,

I've found two inconsistencies with the closure code.
The problem is due to mixing calling functions by name, or as a key to a hash.

Test-case:

The c program (test.c) for all the tests below:

int main() { return 0; }

Problem 1: the "run" function is incorrectly closure'd.

The "post" code (post.js) calls "run"

console.log("The command below is Module.run()");
Module.run();

Compile and test

$ emcc -O2 --closure 1 --minify 0 -s INVOKE_RUN=0 --post-js post.js -o test

# run
$ node test.js 
The command below is Module.run()

node.js:201
        throw e; // process.nextTick error, or 'error' event on first tick
              ^
TypeError: Object #<Object> has no method 'j'
    at Object.<anonymous> (/home/gordon/temp/emcc_bug/test.js:550:8)
    at Module._compile (module.js:432:26)
    at Object..js (module.js:450:10)
    at Module.load (module.js:351:31)
    at Function._load (module.js:310:12)
    at Array.0 (module.js:470:10)
    at EventEmitter._tickCallback (node.js:192:40)

The end of the compiled "test.js" reveals the problem:

$ tail test.js
  }
}
W([]);
var la = i;
Module.noInitialRun && (la = i);
la && $();
console.log("The command below is Module.run()");
Module.j();

The "run()" function in the post was renamed to "j()", but in the generated javascript, it's actually different:

$ grep "^Module\.run" test.js
Module.run = $;

Problem 2: The important config keys in "Module" are incorrectly closure'd

The pre code (pre.js) sets a preRun callback:

var Module = {
    "The Key below is PreRun": true,
    preRun: function() {
        console.log("Hello from preRun");
    }
};

Compile and test

# Compile without closure
$ emcc -O2 --closure 0 --minify 0 --pre-js pre.js -o test.js test.c 
# Test without closure
$ node test.js 
Hello from preRun

# Compile with closure
$ emcc -O2 --closure 1 --minify 0 --pre-js pre.js -o test.js test.c 
# Test with closure
$ node test.js 
# [nothing is printed, "preRun" was not called]

The reason: the pre-script's "preRun" was renamed to "j":

$ head test.js
var b = !0, i = null, j = !1, k = {
  "The Key below is PreRun": b,
  j: (function() {
    console.log("Hello from preRun");
  })
};
try {
  this.Module = k;
} catch (aa) {
  this.Module = k = {};

but the rest of the generated code still looks for a "preRun" function:

$ grep preRun test.js
    console.log("Hello from preRun");
k.preRun || (k.preRun = []);
  if (k.preRun) {
    typeof k.preRun == "function" && (k.preRun = [ k.preRun ]);
    var d = k.preRun;
    k.preRun = [];

Same thing happens with "noInitialRun" and other configuration keys.

temporary workaround:

1. for the initialization keys, always use strings as keys:

var Module = {
  "preRun" : function (...)
  "NoInitialRun" : true }

1. For the "run", a hack like this would work in the post.js script:

var f = Module['run'];
f();

Regards,
-gordon

[kripken]

Closure is confusing sometimes, yeah. We could improve these specific cases, e.g. do Module.run = Module['run'] in our code, I am pushing that now, but it's hard to solve this in general. In particular I'm not sure what we can do for problem 2.

[aidanhs]

This seems appropriate to put in this issue - closure seems to have problems if you use a fresh object to be the 'this' value. The motivation is including a script file on a page without ending up with a Module on the window object.

return.c:

int main() { return 0; }

preJs.js

this.ret = (function () {
  var root = {
    emscript: function () {
      this.Module = {
        'noInitialRun': true,
        'noExitRuntime': true,
        'preRun': [],
        'postRun': []
      };

postJs.js

    }
  };
  root.emscript();
  root.Module.run();
  return 5;
})();

compile

emscripten/emcc return.c --pre-js preJs.js --post-js postJs.js -O2 --closure 1 --minify 0

test

node -p "require('./a.out.js')"

Throws an error about a function not being defined, specifically

/home/aidanhs/Desktop/emscript/a.out.js:1162
  D.U.ma();
      ^
TypeError: Object #<Object> has no method 'ma'
    at /home/aidanhs/Desktop/emscript/a.out.js:1162:7
    at Object.<anonymous> (/home/aidanhs/Desktop/emscript/a.out.js:1164:2)
    at Module._compile (module.js:456:26)
    at Object.Module._extensions..js (module.js:474:10)
    at Module.load (module.js:356:32)
    at Function.Module._load (module.js:312:12)
    at Module.require (module.js:364:17)
    at require (module.js:380:17)
    at [eval]:1:1
    at Object.<anonymous> ([eval]-wrapper:6:22)

Not entirely sure why it thinks D.U is the module object.

[aidanhs]

Additionally, note how in the generated code this.ret has been renamed as well (which is unfortunate given that the point of this is to export a known name).

It also gets renamed if you change it to var ret (well, it's actually removed) making the advice on the FAQ on "Q. My code breaks with -O2 and above, giving odd errors..?" somewhat unhelpful (given it suggests to to exactly this).

Workaround to everything to just sprinkle ['propname'] everywhere to hamstring the closure compiler, but I couldn't see anywhere where the necessity to do this was noted...

[stale]

This issue has been automatically marked as stale because there has been no activity in the past 2 years. It will be closed automatically if no further activity occurs in the next 7 days. Feel free to re-open at any time if this issue is still relevant.