Down level compile memo (tooling)

[Jack-Works]

Moved from bakkot/do-expressions-v2#9. About how to compile this to ES2021 correctly.

I wrote a memo https://blog.jackworks.dev/2021/memo-transfrom-do-expressions/ to make sure I got things right before I actually start the coding. Please point out any edge case I missed thanks!

[nicolo-ribaudo]

Not mentioned in the memo, but be careful with super.* when wrapping do expressions with yield with a generator iife!

[Jack-Works]

@nicolo-ribaudo hi can you give me a code example?

[nicolo-ribaudo]

class A extends B {
  *method() {
    let res = do {
      yield super.foo();
    }
  }
}

This doesn't work if you transform it as

class A extends B {
  *method() {
    var _Completion;

    let res = ((yield* function*(){
      _Completion = yield super.foo();
      return _completion;
    }.call(this, arguments)), _Completion)
  }
}

because super. changes its meaning when moved inside a different function.

[Jack-Works]

Thanks, it's a nice catch!

Uncaught SyntaxError: 'super' keyword unexpected here

I'll think about how to handle this correctly. Are there any other similar syntax elements that cannot / will change meaning if I do this? I know function.sent proposal might be but it's not landed yet.

[nicolo-ribaudo]

I think only new.target and arguments (but this one is easier, just pass arguments to .call).

[Jack-Works]

I don't have a clue on how to fix super.* calls in this pattern. I cannot hoist those super.* access cause they might have side effects. Maybe hoist them as a function?

class A extends B {
  *method() {
    var _Completion;
    var _super_foo = (...args) => super.foo(...args)

    let res = ((yield* function*(){
      _Completion = yield _super_foo();
      return _completion;
    }.call(this, arguments)), _Completion)
  }
}

[nicolo-ribaudo]

Yeah Babel does something similar: https://babeljs.io/repl#?browsers=chrome%2080&build=&builtIns=false&spec=false&loose=false&code_lz=MYGwhgzhAECC0FMAeAXBA7AJjAQtA3gFDTQBUAtgigBYD2mAFAJQHEnQhXQBOCMAvNEy1W7dgDNa3aAwDcslgCNeYANay2YgJ4BLBCEzQIAVwAOCbgDpJtZhrEBfNk4dA&debug=false&forceAllTransforms=false&shippedProposals=true&circleciRepo=&evaluate=false&fileSize=false&timeTravel=false&sourceType=module&lineWrap=true&presets=env%2Cstage-1&prettier=false&targets=&version=7.13.11&externalPlugins=

(but it's broken because it doesn't inject the generator)

[Jack-Works]

I think only new.target and arguments (but this one is easier, just pass arguments to .call).

Consider this code:

function x(a, b) {
    function y(a, b) {
        arguments[1] = 2
    }
    y.call(this, arguments)
    console.log(b)
}

The assignment doesn't "popup" to the outer scope so it's a wrong transformation. I think I can ban it as a TypeScript error and use this wrong transformation since no one use arguments today.

[Jack-Works]

@nicolo-ribaudo hi thanks! I have fixed it in my memo. And I add another section Part 0 to see if we can conver it without a function wrapper.

For example for the common case:

const rnd = do {
    let tmp = rand()
    tmp * tmp;
}

We can convert it into

let _a
const rnd = ((_a = rand()), _a * _a);

[Jack-Works]

Wait, how can I down-level compile do expressions in the class fields position? 🤔

class X {
    #a = do {
        if (super.x) a; else b;
    }
}

Maybe into this?

var _super_x, completion_value
class X {
    #a = ((_super_x = () => super.x), (() => { ... })(), completion_value)
}

[nicolo-ribaudo]

That might cause problems if the do-expression contains a new X itself. I think the sacred thing to do is to store _super_x and completion_value as private fields.

[Jack-Works]

so if it is not a private field but a public field, I think it is not acceptable to introduce a new private field for code that not using a private field (cause down-level compiling are based on WeakMap)

class X {
    #a_super_x = () => super.x
    #a_completion_value
    a = (((setCompletionValue) => { ... })(x => this.#a_completion_value = x), this.#a_completion_value)
}

[Jack-Works]

hmm, I think I need to revisit my compiling method. it seems like my memo don't work for class private/public fields

[Jack-Works]

Is there a non-static version for https://github.com/tc39/proposal-class-static-block? If so I can compile this easily into things like

class X {
    a;
    init block {
        // ...
        this.a = completion_a
    }
}