Add an option to transpile ES6 constructors using Reflect.construct polyfill when the superclass is not statically analyzable.

This controls whether `super()` calls in transpiled ES6 classes should use `$jscomp.construct` (a wrapper around `Reflect.construct`) when the superclass is not statically known to be an ES5-style function.

The default transpilation will fail if subclassing a (non-transpiled) ES6 class, such as a class loaded at runtime from a different pre-minified bundle.

Ideally we would always set this option. For now, I just plan to enable it for @closureUnaware transpilation.

PiperOrigin-RevId: 852503810

Author: lauraharker

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

@@ -878,6 +878,13 @@ public static enum OutputJs {
    */
   private LanguageMode injectPolyfillsNewerThan = null;
 
+  /**
+   * Whether to emit the safe but slower/more verbose transpilation of class super, when the
+   * compiler cannot statically determine whether the superclass is an ES6 class.
+   */
+  private Es6SubclassTranspilation es6SubclassTranspilation =
+      Es6SubclassTranspilation.CONCISE_UNSAFE;
+
   /** Whether to instrument reentrant functions for AsyncContext. */
   private boolean instrumentAsyncContext = false;
 
@@ -2789,6 +2796,35 @@ public boolean getInstrumentAsyncContext() {
     return this.instrumentAsyncContext;
   }
 
+  /**
+   * Configures the transpiled output for ES6 classes when targeting ES5.
+   *
+   * <p>This is needed for transpilation of ES6 classes that extend some unknown superclass, in case
+   * that superclass is still a native ES6 class at runtime (not transpiled to ES5).
+   *
+   * <p>The default is {@link Es6SubclassTranspilation#CONCISE_UNSAFE}, which assumes that if a
+   * superclass in an extends clause cannot be statically analyzed, it's safe to assume it is an ES5
+   * class.
+   *
+   * <p>The "safe" behavior relies on {@code $jscomp.construct}, which is our wrapper for {@code
+   * Reflect.construct}. This is correct, but has the disadvantage of pulling in more helper
+   * utilities into the compiled output and of the transpiled output being slightly larger.
+   *
+   * <p>TODO: b/36789413 - always enable the "safe" transpilation.
+   */
+  public enum Es6SubclassTranspilation {
+    CONCISE_UNSAFE,
+    SAFE_REFLECT_CONSTRUCT
+  }
+
+  public void setEs6SubclassTranspilation(Es6SubclassTranspilation es6SubclassTranspilation) {
+    this.es6SubclassTranspilation = es6SubclassTranspilation;
+  }
+
+  public Es6SubclassTranspilation getEs6SubclassTranspilation() {
+    return this.es6SubclassTranspilation;
+  }
+
   /** Sets list of libraries to always inject, even if not needed. */
   public void setForceLibraryInjection(Iterable<String> libraries) {
     this.forceLibraryInjection = ImmutableList.copyOf(libraries);
@@ -2985,6 +3021,7 @@ public String toString() {
         .add("errorFormat", errorFormat)
         .add("errorHandler", errorHandler)
         .add("es6ModuleTranspilation", es6ModuleTranspilation)
+        .add("es6SubclassTranspilation", es6SubclassTranspilation)
         .add("exportLocalPropertyDefinitions", exportLocalPropertyDefinitions)
         .add("exportTestFunctions", exportTestFunctions)
         .add("externExportsPath", externExportsPath)

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

@@ -21,6 +21,7 @@
 import static com.google.javascript.jscomp.AstFactory.type;
 
 import com.google.common.collect.Iterables;
+import com.google.javascript.jscomp.CompilerOptions.Es6SubclassTranspilation;
 import com.google.javascript.jscomp.GlobalNamespace.Name;
 import com.google.javascript.jscomp.GlobalNamespace.Ref;
 import com.google.javascript.jscomp.colors.Color;
@@ -62,8 +63,10 @@ private static final class ConstructorData {
   private GlobalNamespace globalNamespace;
   private final StaticScope transpilationNamespace;
   private final UniqueIdSupplier uniqueIdSupplier;
+  private final Es6SubclassTranspilation es6SubclassTranspilation;
 
-  public Es6ConvertSuperConstructorCalls(AbstractCompiler compiler) {
+  public Es6ConvertSuperConstructorCalls(
+      AbstractCompiler compiler, Es6SubclassTranspilation es6SubclassTranspilation) {
     this.compiler = compiler;
     this.astFactory = compiler.createAstFactory();
     this.transpilationNamespace = compiler.getTranspilationNamespace();
@@ -73,6 +76,7 @@ public Es6ConvertSuperConstructorCalls(AbstractCompiler compiler) {
     var runtimeJsLibManager = compiler.getRuntimeJsLibManager();
     this.jscompInherits = runtimeJsLibManager.getJsLibField("$jscomp.inherits");
     this.jscompConstruct = runtimeJsLibManager.getJsLibField("$jscomp.construct");
+    this.es6SubclassTranspilation = es6SubclassTranspilation;
   }
 
   @Override
@@ -305,12 +309,17 @@ private void rewriteSuperAndPreserveReturnedThis(
     // 1. We must use the value it returns, if defined, as the 'this' value in the constructor
     //    we're currently transpiling, and we must also return it from this constructor.
     // 2. It may be an ES6 class defined outside of the sources we can see.
-    //
+    if (es6SubclassTranspilation == Es6SubclassTranspilation.SAFE_REFLECT_CONSTRUCT) {
+      // To safely extend the ES5 classes we're generating here, we must use
+      // `$jscomp.construct`, which is our wrapper around `Reflect.construct`.
+      rewriteSuperCallsToJsCompConstructCalls(
+          constructor, superCalls, superClassNameNode, thisType, uniqueSuperThisName);
+      return;
+    }
     // The code below works as long as the class we're extending is an ES5 class, but will
     // break if we're extending an ES6 class (#2), because it calls the superclass constructor
     // without using `new` or `Reflect.construct()`
-    // TODO(b/36789413): We should use $jscomp.construct() here to avoid breakage when extending
-    // an ES6 class.
+    // TODO(b/36789413): we should always use `$jscomp.construct`.
     Node constructorBody = checkNotNull(constructor.getChildAtIndex(2));
     Node firstStatement = constructorBody.getFirstChild();
     Node firstSuperCall = superCalls.get(0);

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

@@ -23,6 +23,7 @@
 
 import com.google.auto.value.AutoBuilder;
 import com.google.common.base.Preconditions;
+import com.google.javascript.jscomp.CompilerOptions.Es6SubclassTranspilation;
 import com.google.javascript.jscomp.colors.Color;
 import com.google.javascript.jscomp.colors.StandardColors;
 import com.google.javascript.jscomp.js.RuntimeJsLibManager.JsLibField;
@@ -50,11 +51,13 @@ public final class Es6RewriteClass implements NodeTraversal.Callback, CompilerPa
   private final StaticScope transpilationNamespace;
   private final JsLibField jscompInherits;
 
-  public Es6RewriteClass(AbstractCompiler compiler) {
+  public Es6RewriteClass(
+      AbstractCompiler compiler, Es6SubclassTranspilation es6SubclassTranspilation) {
     this.compiler = compiler;
     this.astFactory = compiler.createAstFactory();
     this.transpilationNamespace = compiler.getTranspilationNamespace();
-    this.convertSuperConstructorCalls = new Es6ConvertSuperConstructorCalls(compiler);
+    this.convertSuperConstructorCalls =
+        new Es6ConvertSuperConstructorCalls(compiler, es6SubclassTranspilation);
     this.jscompInherits = compiler.getRuntimeJsLibManager().getJsLibField("$jscomp.inherits");
   }
 

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

@@ -265,7 +265,10 @@ public static void addRewritePolyfillPass(PassListBuilder passes) {
   static final PassFactory es6RewriteClass =
       PassFactory.builder()
           .setName("Es6RewriteClass")
-          .setInternalFactory(Es6RewriteClass::new)
+          .setInternalFactory(
+              (compiler) ->
+                  new Es6RewriteClass(
+                      compiler, compiler.getOptions().getEs6SubclassTranspilation()))
           .build();
 
   static final PassFactory getEs6RewriteDestructuring(ObjectDestructuringRewriteMode rewriteMode) {

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

@@ -20,6 +20,7 @@
 import static com.google.javascript.jscomp.TypedScopeCreator.DYNAMIC_EXTENDS_WITHOUT_JSDOC;
 import static com.google.javascript.rhino.testing.NodeSubject.assertNode;
 
+import com.google.javascript.jscomp.CompilerOptions.Es6SubclassTranspilation;
 import com.google.javascript.jscomp.CompilerOptions.LanguageMode;
 import com.google.javascript.jscomp.colors.Color;
 import com.google.javascript.jscomp.colors.StandardColors;
@@ -47,6 +48,8 @@ public final class Es6RewriteClassTest extends CompilerTestCase {
           .addJSCompLibraries()
           .build();
 
+  private Es6SubclassTranspilation es6SubclassTranspilation;
+
   public Es6RewriteClassTest() {
     super(EXTERNS_BASE);
   }
@@ -62,6 +65,7 @@ public void customSetUp() throws Exception {
     replaceTypesWithColors();
     enableMultistageCompilation();
     setGenericNameReplacements(Es6NormalizeClasses.GENERIC_NAME_REPLACEMENTS);
+    es6SubclassTranspilation = Es6SubclassTranspilation.CONCISE_UNSAFE;
   }
 
   private static PassFactory makePassFactory(
@@ -74,7 +78,9 @@ protected CompilerPass getProcessor(final Compiler compiler) {
     PhaseOptimizer optimizer = new PhaseOptimizer(compiler, null);
     optimizer.addOneTimePass(makePassFactory("es6NormalizeClasses", Es6NormalizeClasses::new));
     optimizer.addOneTimePass(makePassFactory("es6ConvertSuper", Es6ConvertSuper::new));
-    optimizer.addOneTimePass(makePassFactory("es6RewriteClass", Es6RewriteClass::new));
+    optimizer.addOneTimePass(
+        makePassFactory(
+            "es6RewriteClass", (c) -> new Es6RewriteClass(compiler, es6SubclassTranspilation)));
     return optimizer;
   }
 
@@ -245,6 +251,29 @@ public void testAnonymousWithSuper() {
         """);
   }
 
+  @Test
+  public void testAnonymousWithSuper_reflectConstruct() {
+    es6SubclassTranspilation = Es6SubclassTranspilation.SAFE_REFLECT_CONSTRUCT;
+    enableClosurePass();
+    ignoreWarnings(FunctionTypeBuilder.RESOLVED_TAG_EMPTY, TypeCheck.POSSIBLE_INEXISTENT_PROPERTY);
+    test(
+        """
+        goog.forwardDeclare('D')
+        f(class extends D { f() { super.g() } })
+        """,
+        """
+        goog.forwardDeclare('D')
+        /** @constructor
+         */
+        const CLASS_DECL$0 = function() {
+          return $jscomp.construct(D, arguments, this.constructor);
+        };
+        $jscomp.inherits(CLASS_DECL$0, D);
+        CLASS_DECL$0.prototype.f = function() { D.prototype.g.call(this); };
+        f(CLASS_DECL$0)
+        """);
+  }
+
   @Test
   public void testComplexBaseWithConditional() {
     test(
@@ -622,6 +651,21 @@ public void testExtendsWithImplicitConstructorNoTypeInfo() {
             """));
   }
 
+  @Test
+  public void testExtendsWithImplicitConstructor_knownSuperclass_doesNotEs6SubclassTranspilation() {
+    es6SubclassTranspilation = Es6SubclassTranspilation.SAFE_REFLECT_CONSTRUCT;
+    test(
+        "class D {} class C extends D {}",
+        """
+        /** @constructor */
+        let D = function() {};
+        /** @constructor
+         */
+        let C = function() { D.apply(this, arguments); };
+        $jscomp.inherits(C, D);
+        """);
+  }
+
   @Test
   public void testExtendsWithSpreadsPassedToSuper() {
     test(
@@ -717,6 +761,31 @@ function f() {
             """));
   }
 
+  @Test
+  public void testExtends_nonGlobalClass_usingReflectConstruct() {
+    es6SubclassTranspilation = Es6SubclassTranspilation.SAFE_REFLECT_CONSTRUCT;
+    test(
+        srcs(
+            """
+            function f() {
+              class C {}
+              class D extends C {}
+            }
+            """),
+        expected(
+            """
+            function f() {
+              /** @constructor */
+              let C = function() {};
+              /** @constructor */
+              let D = function() {
+                return $jscomp.construct(C, arguments, this.constructor);
+              };
+              $jscomp.inherits(D, C);
+            }
+            """));
+  }
+
   @Test
   public void testExtendsExternsClass() {
     test(
@@ -1333,6 +1402,47 @@ class C extends D {
         """);
   }
 
+  @Test
+  public void testAlternativeSuperCalls_withUnknownSuperclass_es6SubclassTranspilation() {
+    // Class being extended is unknown, so we must assume super() could change the value of `this`.
+    enableClosurePass();
+    ignoreWarnings(FunctionTypeBuilder.RESOLVED_TAG_EMPTY);
+    es6SubclassTranspilation = Es6SubclassTranspilation.SAFE_REFLECT_CONSTRUCT;
+    test(
+        """
+        goog.forwardDeclare('D');
+        class C extends D {
+          /** @param {string} strArg
+           * @param {number} n */
+          constructor(strArg, n) {
+            if (n >= 0) {
+              super('positive: ' + strArg);
+            } else {
+              super('negative: ' + strArg);
+            }
+            this.n = n;
+          }
+        }
+        """,
+        """
+        goog.forwardDeclare('D');
+        /** @constructor */
+        let C = function(strArg, n) {
+          var $jscomp$super$this$m1146332801$0;
+          if (n >= 0) {
+            $jscomp$super$this$m1146332801$0 =
+                $jscomp.construct(D, ["positive: " + strArg], this.constructor);
+          } else {
+            $jscomp$super$this$m1146332801$0 =
+                $jscomp.construct(D, ["negative: " + strArg], this.constructor);
+          }
+          $jscomp$super$this$m1146332801$0.n = n;
+          return $jscomp$super$this$m1146332801$0;
+        }
+        $jscomp.inherits(C, D);
+        """);
+  }
+
   @Test
   public void testComputedSuper() {
     test(
@@ -2070,6 +2180,27 @@ public void testInheritFromExterns() {
             """));
   }
 
+  @Test
+  public void testInheritFromExterns_withReflectConstruct() {
+    es6SubclassTranspilation = Es6SubclassTranspilation.SAFE_REFLECT_CONSTRUCT;
+    test(
+        externs(
+            EXTERNS_BASE
+                + """
+                /** @constructor */ function ExternsClass() {}
+                ExternsClass.m = function() {};
+                """),
+        srcs("class CodeClass extends ExternsClass {}"),
+        expected(
+            """
+            /** @constructor */
+            let CodeClass = function() {
+              return $jscomp.construct(ExternsClass, arguments, this.constructor);
+            };
+            $jscomp.inherits(CodeClass,ExternsClass)
+            """));
+  }
+
   // Make sure we don't crash on this code.
   // https://github.com/google/closure-compiler/issues/752
   @Test