Update async await transpilation to avoid captures of super

[ChadKillingsworth]

Closes #3101

MS Edge 17 does not properly honor captures of super in arrow functions. Avoid this pattern when transpiling async/await.

[brad4d]

I don't think we can make this change.
I believe we initially tried just saving the value of super.foo, but ran into runtime failures because the value of super.foo changed between the point where we'd saved it and the point where we needed to evaluate it.

Is there some workaround for the MS edge bug we could generate here?
What does it do when you reference super() inside an arrow function?
Does an exception get thrown or is the value "wrong" in some way?

[ChadKillingsworth]

What does it do when you reference super() inside an arrow function? Does an exception get thrown or is the value "wrong" in some way?

In an arrow function in Edge, it looks like super === this. There is no exception - just an infinite loop of recursive calls. It's nasty.

Is there some workaround for the MS edge bug we could generate here?

I can keep looking for other options. One option is to replace the reference to super with the extends clause name. But that would also then require Es6RewriteClassExtendsExpressions for transpilation even during ES2015 out.

[ChadKillingsworth]

@brad4d I think I may have found a workable solution: Use Object.getPrototypeOf.

I only switch to this technique if classes are not being transpiled. This avoids a dependence on Object.getPrototypeOf for IE < 10.

[ChadKillingsworth]

I tested this on both Chrome and MS Edge in a project where I'm trying to land ES6 out.

[brad4d]

Couldn't we just get the prototype directly from this?

() => Object.getPrototypeOf(this).m;

[ChadKillingsworth]

Unfortunately not. See the comments in the following snippet:

class Base {
  static foo() { console.log('base foo'); }
  bar() { console.log('base bar'); }
}

class Child extends Base {
  static foo() {
    console.log(Object.getPrototypeOf(this), Object.getPrototypeOf(this).foo);
    Object.getPrototypeOf(this).foo.call(this);
  }

  bar() {
    console.log(Object.getPrototypeOf(this), Object.getPrototypeOf(this).bar);
    Object.getPrototypeOf(this).bar(); // logs out "base bar" appropriately
    Object.getPrototypeOf(this).bar.call(this); // infinitely loops and locks up the Chrome tab!
  }
}

[brad4d]

Ah, I see my mistake.
I meant to say Object.getPrototypeOf(Object.getPrototypeOf(this))

I wonder which is the safer choice in the face of code that mucks around with prototypes?
Is it more likely that this.constructor isn't pointing at the right thing or that an additional object has been inserted into the prototype chain?

[brad4d]

Discussed this with @concavelenz
We agree that it seems more correct and slightly safer to call Object.getPrototypeOf() twice to get up to the superclass prototype rather than relying on this.constructor.

Would you be willing to make that change?

[ChadKillingsworth]

Of course - done.

[brad4d]

@ChadKillingsworth
I like your solution. Very clean.

Is there some reason why we can't just do Object.getPrototypeOf(this) for the non-static case?
See also comment on code.

[ChadKillingsworth]

Classes and super references are tricky to transpile. I was able to simplify static references to super though.

[brad4d]

Do you have any link we could insert here pointing to the MS Edge bug?
We'd really like to be able to track when the MS Edge bug gets fixed, or if it's already fixed and we're just stuck because of installed browsers not getting the fix.

[ChadKillingsworth]

I created one and added the link

[brad4d]

Imported and sent for internal review and testing.