Place $jscomp$super$this after any hoisted function declarations to preserve normalization when rewriting classes

Currently, the Es6ConvertSuperConstructorCalls generates var declarations as first child of the constructor. This breaks normalization as normalization expects all function declarations to stay hoisted. This CL ensures that.

PiperOrigin-RevId: 623222665

Author: rishipal

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

@@ -223,10 +223,18 @@ private void visitSuper(NodeTraversal t, ConstructorData constructorData) {
           // `this` -> `$jscomp$super$this` throughout the constructor body,
           // except for super() calls.
           updateThisToSuperThis(typeOfThis, constructorBody, superCalls, uniqueSuperThisName);
-          // Start constructor with `var $jscomp$super$this;`
-          constructorBody.addChildToFront(
+          // Start constructor with `var $jscomp$super$this;`, but place it after any hoisted
+          // function declarations
+          Node declaration =
               IR.var(astFactory.createName(uniqueSuperThisName, typeOfThis))
-                  .srcrefTree(constructorBody));
+                  .srcrefTree(constructorBody);
+          Node insertBeforePoint = getInsertBeforePoint(constructorBody);
+          if (insertBeforePoint != null) {
+            declaration.insertBefore(insertBeforePoint);
+          } else {
+            // functionBody only contains hoisted function declarations
+            constructorBody.addChildToBack(declaration);
+          }
           // End constructor with `return $jscomp$super$this;`
           constructorBody.addChildToBack(
               IR.returnNode(astFactory.createName(uniqueSuperThisName, typeOfThis))
@@ -249,6 +257,24 @@ private void visitSuper(NodeTraversal t, ConstructorData constructorData) {
     }
   }
 
+  /**
+   * Gets an insertion point in the function body before which we want to insert the new let
+   * declaration. If there's not good insertion point (e.g. the function is empty or only contains
+   * inner function declarations), return null.
+   */
+  private Node getInsertBeforePoint(Node functionBody) {
+    checkState(functionBody.getParent().isFunction());
+    Node current = functionBody.getFirstChild();
+
+    // Do not insert the let declaration before any hoisted function declarations in this function
+    // body as those function declarations are hoisted by normalization. We must maintain
+    // normalization.
+    while (current != null && NodeUtil.isFunctionDeclaration(current)) {
+      current = current.getNext();
+    }
+    return current;
+  }
+
   /**
    * Change calls to `super` to use `$jscomp.construct` instead.
    *
@@ -299,11 +325,20 @@ private void convertSuperCallsToJsCompConstructCalls(
       // `this` -> `$jscomp$super$this` throughout the constructor body,
       // except for super() calls.
       updateThisToSuperThis(typeOfThis, constructorBody, superCalls, uniqueSuperThisName);
-      // Start constructor with `var $jscomp$super$this;`
-      constructorBody.addChildToFront(
+      // Start constructor with `var $jscomp$super$this;`, but place it after any hoisted
+      // function declarations
+      Node declaration =
           astFactory
               .createSingleVarNameDeclaration(uniqueSuperThisName)
-              .srcrefTree(constructorBody));
+              .srcrefTree(constructorBody);
+      Node insertBeforePoint = getInsertBeforePoint(constructorBody);
+      if (insertBeforePoint != null) {
+        declaration.insertBefore(insertBeforePoint);
+      } else {
+        // functionBody only contains hoisted function declarations
+        constructorBody.addChildToBack(declaration);
+      }
+
       // End constructor with `return $jscomp$super$this;`
       constructorBody.addChildToBack(
           astFactory

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

@@ -1444,6 +1444,36 @@ public void testExtendNativeClass_withExplicitConstructor() {
             ""));
   }
 
+  @Test
+  public void testExtendNativeClass_withExplicitConstructor_withInnerFunction() {
+    test(
+        lines(
+            "class FooPromise extends Promise {",
+            "  /** @param {string} msg */",
+            "  constructor(callbackArg, msg) {",
+            "    function inner() {}", // hoisted, normalized
+            "    super(callbackArg);",
+            "    this.msg = msg;",
+            "  }",
+            "}"),
+        lines(
+            "/**",
+            " * @constructor",
+            " */",
+            "let FooPromise = function(callbackArg, msg) {",
+            // stays hoisted
+            "  function inner() {}",
+            // declaration created after function declaration
+            "  var $jscomp$super$this$m1146332801$0;",
+            "  $jscomp$super$this$m1146332801$0 =",
+            "      $jscomp.construct(Promise, [callbackArg], this.constructor);",
+            "  $jscomp$super$this$m1146332801$0.msg = msg;",
+            "  return $jscomp$super$this$m1146332801$0;",
+            "}",
+            "$jscomp.inherits(FooPromise, Promise);",
+            ""));
+  }
+
   @Test
   public void testExtendNativeClass_withImplicitConstructor() {
     test(