Update async await transpilation to avoid captures of super when using ES2015 output.

MS Edge 17 does not properly capture references to `super` in an arrow function.
Closes google#3101

Author: ChadKillingsworth

src/com/google/javascript/jscomp/RewriteAsyncFunctions.java

@@ -124,6 +124,7 @@ void recordAsyncArgumentsReplacementWasDone() {
   private final AbstractCompiler compiler;
   private static final FeatureSet transpiledFeatures =
       FeatureSet.BARE_MINIMUM.with(Feature.ASYNC_FUNCTIONS);
+  private boolean needsSuperTranspilation = false;
 
   public RewriteAsyncFunctions(AbstractCompiler compiler) {
     checkNotNull(compiler);
@@ -134,6 +135,7 @@ public RewriteAsyncFunctions(AbstractCompiler compiler) {
 
   @Override
   public void process(Node externs, Node root) {
+    needsSuperTranspilation = compiler.getOptions().needsTranspilationFrom(FeatureSet.ES6);
     TranspilationPasses.processTranspile(compiler, externs, transpiledFeatures, this);
     TranspilationPasses.processTranspile(compiler, root, transpiledFeatures, this);
     TranspilationPasses.maybeMarkFeaturesAsTranspiledAway(compiler, transpiledFeatures);
@@ -244,9 +246,21 @@ private void convertAsyncFunction(NodeTraversal t, LexicalContext functionContex
       NodeUtil.addFeatureToScript(t.getCurrentFile(), Feature.CONST_DECLARATIONS);
     }
     for (String replacedMethodName : functionContext.replacedSuperProperties) {
+      // MS Edge 17 cannot properly capture references to "super" in an arrow function.
+      // If we are not transpiling classes, switch to using Object.getPrototypeOf(this)
+      // as a replacement for super.
+      // If we are transpiling classes, the super reference will be handled elsewhere.
+      Node superReference;
+      if (needsSuperTranspilation) {
+        superReference = IR.superNode();
+      } else {
+        superReference = IR.call(
+            IR.getprop(IR.name("Object"), IR.string("getPrototypeOf")), IR.thisNode());
+      }
+
       // const super$get$x = () => super.x;
       Node arrowFunction = IR.arrowFunction(
-          IR.name(""), IR.paramList(), IR.getprop(IR.superNode(), IR.string(replacedMethodName)));
+          IR.name(""), IR.paramList(), IR.getprop(superReference, IR.string(replacedMethodName)));
       compiler.reportChangeToChangeScope(arrowFunction);
       NodeUtil.addFeatureToScript(t.getCurrentFile(), Feature.ARROW_FUNCTIONS);
 

test/com/google/javascript/jscomp/RewriteAsyncFunctionsTest.java

@@ -142,6 +142,39 @@ public void testInnerSuperReference() {
             "}"));
   }
 
+  @Test
+  public void testInnerSuperCallEs2015Out() {
+    setLanguageOut(LanguageMode.ECMASCRIPT_2015);
+    test(
+        lines(
+            "class A {",
+            "  m() {",
+            "    return this;",
+            "  }",
+            "}",
+            "class X extends A {",
+            "  async m() {",
+            "    return super.m();",
+            "  }",
+            "}"),
+        lines(
+            "class A {",
+            "  m() {",
+            "    return this;",
+            "  }",
+            "}",
+            "class X extends A {",
+            "  m() {",
+            "    const $jscomp$async$this = this;",
+            "    const $jscomp$async$super$get$m = () => Object.getPrototypeOf(this).m;",
+            "    return $jscomp.asyncExecutePromiseGeneratorFunction(",
+            "        function* () {",
+            "          return $jscomp$async$super$get$m().call($jscomp$async$this);",
+            "        });",
+            "  }",
+            "}"));
+  }
+
   @Test
   public void testNestedArrowFunctionUsingThis() {
     test(