Decompose class extends calls

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

@@ -0,0 +1,173 @@
+/*
+ * Copyright 2018 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.javascript.jscomp;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.javascript.jscomp.deps.ModuleNames;
+import com.google.javascript.jscomp.parsing.parser.FeatureSet;
+import com.google.javascript.jscomp.parsing.parser.FeatureSet.Feature;
+import com.google.javascript.rhino.IR;
+import com.google.javascript.rhino.Node;
+
+/**
+ * Extracts ES6 class extends expressions and creates an alias.
+ *
+ * <p>Example: Before:
+ *
+ * <p><code>class Foo extends Bar() {}</code>
+ *
+ * <p>After:
+ *
+ * <p><code>
+ *   const $jscomp$classextends$var0 = Bar();
+ *   class Foo extends $jscomp$classextends$var0 {}
+ * </code>
+ *
+ * <p>This must be done before {@link Es6ConvertSuper}, because that pass only handles extends
+ * clauses which are simple NAME or GETPROP nodes.
+ */
+public final class Es6RewriteClassExtendsExpressions extends NodeTraversal.AbstractPostOrderCallback
+    implements HotSwapCompilerPass {
+
+  static final String CLASS_EXTENDS_VAR = "$classextends$var";
+
+  private final AbstractCompiler compiler;
+  private int classExtendsVarCounter = 0;
+  private static final FeatureSet features = FeatureSet.BARE_MINIMUM.with(Feature.CLASSES);
+
+  Es6RewriteClassExtendsExpressions(AbstractCompiler compiler) {
+    this.compiler = compiler;
+  }
+
+  @Override
+  public void process(Node externs, Node root) {
+    // TODO(bradfordcsmith): Do we really need to run this on externs?
+    TranspilationPasses.processTranspile(compiler, externs, features, this);
+    TranspilationPasses.processTranspile(compiler, root, features, this);
+  }
+
+  @Override
+  public void hotSwapScript(Node scriptRoot, Node originalRoot) {
+    TranspilationPasses.hotSwapTranspile(compiler, scriptRoot, features, this);
+  }
+
+  @Override
+  public void visit(NodeTraversal t, Node n, Node parent) {
+    if (n.isClass() && needsExtendsDecomposing(n)) {
+      if (canDecomposeSimply(n)) {
+        extractExtends(t, n);
+      } else {
+        decomposeInIIFE(t, n);
+      }
+    }
+  }
+
+  private boolean needsExtendsDecomposing(Node classNode) {
+    checkArgument(classNode.isClass());
+    if (classNode.getSecondChild().isEmpty() || classNode.getSecondChild().isQualifiedName()) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Find common cases where we can safely decompose class extends expressions which are not
+   * qualified names. Enables transpilation of complex extends expressions.
+   *
+   * <p>We can only decompose the expression in a limited set of cases to avoid changing evaluation
+   * order of side-effect causing statements.
+   */
+  private boolean canDecomposeSimply(Node classNode) {
+    Node enclosingStatement = checkNotNull(NodeUtil.getEnclosingStatement(classNode), classNode);
+    if (enclosingStatement == classNode) {
+      // `class Foo extends some_expression {}`
+      // can always be converted to
+      // ```
+      // const tmpvar = some_expression;
+      // class Foo extends tmpvar {}
+      // ```
+      return true;
+    } else {
+      Node classNodeParent = classNode.getParent();
+      if (NodeUtil.isNameDeclaration(enclosingStatement)
+          && classNodeParent.isName()
+          && classNodeParent.isFirstChildOf(enclosingStatement)) {
+        // `const Foo = class extends some_expression {}, maybe_other_var;`
+        // can always be converted to
+        // ```
+        // const tmpvar = some_expression;
+        // const Foo = class extends tmpvar {}, maybe_other_var;
+        // ```
+        return true;
+      } else if (enclosingStatement.isExprResult()
+          && classNodeParent.isOnlyChildOf(enclosingStatement)
+          && classNodeParent.isAssign()
+          && classNode.isSecondChildOf(classNodeParent)) {
+        // `lhs = class extends some_expression {};`
+        Node lhsNode = classNodeParent.getFirstChild();
+        // We can extract a temporary variable for some_expression as long as lhs expression
+        // has no side effects.
+        return !NodeUtil.mayHaveSideEffects(lhsNode);
+      } else {
+        return false;
+      }
+    }
+  }
+
+  private void extractExtends(NodeTraversal t, Node classNode) {
+    String name =
+        ModuleNames.fileToJsIdentifier(classNode.getStaticSourceFile().getName())
+            + CLASS_EXTENDS_VAR
+            + (classExtendsVarCounter++);
+
+    Node statement = NodeUtil.getEnclosingStatement(classNode);
+    Node originalExtends = classNode.getSecondChild();
+    originalExtends.replaceWith(IR.name(name).useSourceInfoFrom(originalExtends));
+    Node extendsAlias =
+        IR.constNode(IR.name(name), originalExtends)
+            .useSourceInfoIfMissingFromForTree(originalExtends);
+    statement.getParent().addChildBefore(extendsAlias, statement);
+    NodeUtil.addFeatureToScript(NodeUtil.getEnclosingScript(classNode), Feature.CONST_DECLARATIONS);
+    t.reportCodeChange(classNode);
+  }
+
+  /**
+   * When a class is used in an expressions where adding an alias as the previous statement might
+   * change execution order of a side-effect causing statement, wrap the class in an IIFE so that
+   * decomposition can happen safely.
+   */
+  private void decomposeInIIFE(NodeTraversal t, Node classNode) {
+    // converts
+    // `class X extends something {}`
+    // to
+    // `(function() { return class X extends something {}; })()`
+    Node functionBody = IR.block();
+    Node function = IR.function(IR.name(""), IR.paramList(), functionBody);
+    Node call = NodeUtil.newCallNode(function);
+    classNode.replaceWith(call);
+    functionBody.addChildToBack(IR.returnNode(classNode));
+    call.useSourceInfoIfMissingFromForTree(classNode);
+    // NOTE: extractExtends() will end up reporting the change for the new function, so we only
+    //     need to report the change to the enclosing scope
+    t.reportCodeChange(call);
+    // Now do the extends expression extraction within the IIFE
+    extractExtends(t, classNode);
+  }
+}

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

@@ -51,6 +51,7 @@ public final class PassNames {
   public static final String DISAMBIGUATE_PRIVATE_PROPERTIES = "disambiguatePrivateProperties";
   public static final String DISAMBIGUATE_PROPERTIES = "disambiguateProperties";
   public static final String ES6_EXTRACT_CLASSES = "Es6ExtractClasses";
+  public static final String ES6_REWRITE_CLASS_EXTENDS = "Es6ExtractClassExtends";
   public static final String EXPLOIT_ASSIGN = "exploitAssign";
   public static final String EXPORT_TEST_FUNCTIONS = "exportTestFunctions";
   public static final String EXTERN_EXPORTS = "externExports";

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

@@ -112,6 +112,7 @@ static void addPreTypecheckTranspilationPasses(
               Feature.REGEXP_FLAG_U,
               Feature.REGEXP_FLAG_Y));
       passes.add(es6NormalizeShorthandProperties);
+      passes.add(es6RewriteClassExtends);
       passes.add(es6ConvertSuper);
       passes.add(es6RenameVariablesInParamLists);
       passes.add(es6SplitVariableDeclarations);
@@ -274,6 +275,19 @@ protected FeatureSet featureSet() {
         }
       };
 
+  static final HotSwapPassFactory es6RewriteClassExtends =
+      new HotSwapPassFactory(PassNames.ES6_REWRITE_CLASS_EXTENDS) {
+        @Override
+        protected HotSwapCompilerPass create(AbstractCompiler compiler) {
+          return new Es6RewriteClassExtendsExpressions(compiler);
+        }
+
+        @Override
+        protected FeatureSet featureSet() {
+          return ES2018;
+        }
+      };
+
   static final HotSwapPassFactory es6ExtractClasses =
       new HotSwapPassFactory(PassNames.ES6_EXTRACT_CLASSES) {
         @Override

src/com/google/javascript/rhino/Node.java

@@ -1622,12 +1622,18 @@ public final boolean isDescendantOf(Node node) {
     return false;
   }
 
+  public final boolean isOnlyChildOf(Node possibleParent) {
+    return possibleParent == getParent() && getPrevious() == null & getNext() == null;
+  }
+
   public final boolean isFirstChildOf(Node possibleParent) {
     return possibleParent == getParent() && getPrevious() == null;
   }
 
   public final boolean isSecondChildOf(Node possibleParent) {
-    return getPrevious().isFirstChildOf(possibleParent);
+    Node previousNode = getPrevious();
+
+    return previousNode != null && previousNode.isFirstChildOf(possibleParent);
   }
 
   /**