Make the J2clOpts pass more effective when there are transitive dependencies in constant intialization.

[rluble]

Constants that need to be hoisted sometimes are initialized by calling getters of other constants that need to be hoisted. These getters are non-trivial, e.g.

  (func $getConst1_<once>_@X (result (ref null $A))
    (block (result (ref null $A))
      (if (i32.eqz (ref.is_null (global.get $$const1@X)))
        (then
          (return (global.get $$const1@X))
        )
      )
      (global.set $$const1@X (struct.new $A (i32.const 2)))
      (global.get $$const1@X)
    )

  (func $getConst2_<once>_@X (result (ref null $A))
    (block (result (ref null $A))
      (if (i32.eqz (ref.is_null (global.get $$const2@X)))
        (then
          (return (global.get $$const2@X))
        )
      )
      (global.set $$const2@X  .... expression with (call $getConst1_<once>_@X)  ....))
      (global.get $$const2@X)
    )

and can only be simplified after the constants they initialize are hoisted. After the constant is hoisted the getter can be inlined and constants that depend on it for their initialization can now be hoisted.

Before this pass, inilining would happen after the pass was run by a subsquent run of the inliner (likely as part of -O3), requiring as many runs of this pass, interleaved with the inliner, as the depth in the call sequence.

By having a simpler inliner run as part of the loop in this pass, the pass becomes more effective and more independent of the call depths.

[gkdn]

_ No description provided. _

Let's put some detailed description of what and why we are doing for future reference.

[rluble]

I think all the comments were addressed. Let me know if there is anything else.

[gkdn]

re. tests: It s kind of difficult to check all the coverage but do you mind double checking we have have coverage for

• Having TrivialOnceFunctionCollector is important
• we can handle multiple depth of call in single run

[gkdn]

If escaping is fixed, this comment is now stale.

[rluble]

Updated j2cl-inline.wast to show that without the inlining it has the same result as before.

[gkdn]

LGTM minus the comments. (one of them ended up being hidden behind resolved comments)

[rluble]

re. tests: It s kind of difficult to check all the coverage but do you mind double checking we have have coverage for

• Having TrivialOnceFunctionCollector is important
• we can handle multiple depth of call in single run

Both of those are already reflected in j2cl.wat.

The module at line 156 shows a transitive inline and hoisting that is 3 deep.
The module at line 209 shows inlining of once functions that do not have constants to hoist anymore, i.e. the effect of collecting.
The module at line 318 shows a more complex pattern (similar that what we generate) where constants are hoisted, the bodies are cleanup, collected and transitively inlined.

[gkdn]

Sorry post an LGTM earlier but didn't notice I can mark it as approved. Thanks.