Run any transpilation pass only if the specific features worked on by that pass exist in the script

This CL completes go/avoid-unnecessary-transpile.

PiperOrigin-RevId: 555691979

Author: rishipal

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

@@ -18,6 +18,7 @@
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
 import static com.google.common.base.Strings.isNullOrEmpty;
 
 import com.google.common.collect.ImmutableSet;
@@ -307,6 +308,14 @@ public void validateStatement(Node n, boolean isAmbient) {
         violation("Expected statement but was " + n.getToken() + ".", n);
         return;
       default:
+        if (n.isModuleBody() && compiler.getOptions().skipNonTranspilationPasses) {
+          checkState(
+              !compiler.getOptions().wrapGoogModulesForWhitespaceOnly,
+              "Modules can exist in transpiler only if setWrapGoogModulesForWhitespaceOnly is"
+                  + " false");
+          validateModuleContents(n);
+          return;
+        }
         violation("Expected statement but was " + n.getToken() + ".", n);
     }
   }
@@ -2259,6 +2268,7 @@ private void validateMaximumChildCount(Node n, int i) {
 
   private void validateFeature(Feature feature, Node n) {
     FeatureSet allowbleFeatures = compiler.getAllowableFeatures();
+    // Checks that feature present in the AST is recorded in the compiler's featureSet.
     if (!n.isFromExterns() && !allowbleFeatures.has(feature)) {
       // Skip this check for externs because we don't need to complete transpilation on externs,
       // and currently only transpile externs so that we can typecheck ES6+ features in externs.
@@ -2269,6 +2279,7 @@ private void validateFeature(Feature feature, Node n) {
       return;
     }
     FeatureSet scriptFeatures = NodeUtil.getFeatureSetOfScript(currentScript);
+    // Checks that feature present in the AST is recorded in the SCRIPT node's featureSet.
     if (scriptFeatures == null || !NodeUtil.getFeatureSetOfScript(currentScript).has(feature)) {
       violation("SCRIPT node should be marked as containing feature " + feature, currentScript);
     }

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

@@ -35,7 +35,8 @@ public final class Es6ConvertSuper extends NodeTraversal.AbstractPostOrderCallba
   private final AbstractCompiler compiler;
   private final AstFactory astFactory;
   private final SynthesizeExplicitConstructors constructorSynthesizer;
-  private static final FeatureSet transpiledFeatures = FeatureSet.BARE_MINIMUM.with(Feature.SUPER);
+  private static final FeatureSet FEATURES_TO_RUN_FOR =
+      FeatureSet.BARE_MINIMUM.with(Feature.SUPER, Feature.CLASSES);
 
   public Es6ConvertSuper(AbstractCompiler compiler) {
     this.compiler = compiler;
@@ -223,8 +224,8 @@ private void visitSuperPropertyAccess(Node node, Node parent, Node enclosingMemb
   @Override
   public void process(Node externs, Node root) {
     // Might need to synthesize constructors for ambient classes in .d.ts externs
-    TranspilationPasses.processTranspile(compiler, externs, transpiledFeatures, this);
-    TranspilationPasses.processTranspile(compiler, root, transpiledFeatures, this);
+    TranspilationPasses.processTranspile(compiler, externs, FEATURES_TO_RUN_FOR, this);
+    TranspilationPasses.processTranspile(compiler, root, FEATURES_TO_RUN_FOR, this);
+    // TODO(rishipal): mark super feature as transpiled away
   }
-
 }

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

@@ -156,6 +156,7 @@ public void process(Node externs, Node root) {
   public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) {
     if (n.isScript()) {
       FeatureSet scriptFeatures = NodeUtil.getFeatureSetOfScript(n);
+      // This will ensure that we run this only when features exist in the script
       return scriptFeatures.containsAtLeastOneOf(featuresToTriggerRunningPass);
     }
     switch (n.getToken()) {

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

@@ -59,6 +59,7 @@ public void process(Node externs, Node root) {
   public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) {
     if (n.isScript()) {
       FeatureSet scriptFeatures = NodeUtil.getFeatureSetOfScript(n);
+      // Runs only if features exist in the script
       return scriptFeatures == null || scriptFeatures.contains(Feature.EXPONENT_OP);
     }
     return true;

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

@@ -44,6 +44,7 @@ public void process(Node externs, Node root) {
   public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) {
     if (n.isScript()) {
       FeatureSet scriptFeatures = NodeUtil.getFeatureSetOfScript(n);
+      // runs only if logical assignment present
       return scriptFeatures == null || scriptFeatures.contains(Feature.LOGICAL_ASSIGNMENT);
     }
     return true;

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

@@ -104,6 +104,7 @@ private class ArrowRewriteCallBack implements NodeTraversal.Callback {
     public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) {
       if (n.isScript()) {
         FeatureSet scriptFeatures = NodeUtil.getFeatureSetOfScript(n);
+        // ensures we don't run unless script contains the feature
         return scriptFeatures == null || scriptFeatures.contains(Feature.NULL_COALESCE_OP);
       }
       return true;

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

@@ -71,6 +71,7 @@ public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) {
         // Set the TmpVarNameCreator to be used when rewriting optional chains in this script.
         rewriterBuilder.setTmpVarNameCreator(getTmpVarNameCreatorForInput.apply(t.getInput()));
         FeatureSet scriptFeatures = NodeUtil.getFeatureSetOfScript(n);
+        // ensures that the pass early exits if script does not contain the feature
         return scriptFeatures == null || scriptFeatures.contains(Feature.OPTIONAL_CHAINING);
       }
       return true;

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

@@ -16,6 +16,7 @@
 
 package com.google.javascript.jscomp;
 
+import static com.google.common.base.Preconditions.checkState;
 
 import com.google.javascript.jscomp.CompilerOptions.ChunkOutputType;
 import com.google.javascript.jscomp.Es6RewriteDestructuring.ObjectDestructuringRewriteMode;
@@ -62,7 +63,12 @@ public static void addEs6RewriteImportPathPass(PassListBuilder passes) {
     passes.maybeAdd(es6RelativizeImportPaths);
   }
 
-  /** Adds transpilation passes that should run at the beginning of the optimization phase */
+  /**
+   * Adds transpilation passes that should run at the beginning of the optimization phase. Passes
+   * added in this method either use {@code TranspilationPasses.processTranspile} or early-exit by
+   * checking their feature in the script's featureset. So they will only get run if the feature
+   * they're responsible for removing exists in the script.
+   */
   public static void addEarlyOptimizationTranspilationPasses(
       PassListBuilder passes, CompilerOptions options) {
 
@@ -224,14 +230,21 @@ public static void addEarlyOptimizationTranspilationPasses(
     }
   }
 
-  /** Adds transpilation passes that should not be run until after normalization has been done. */
+  /**
+   * Adds transpilation passes that should not be run until after normalization has been done.
+   * Passes added in this method either use {@code TranspilationPasses.processTranspile} or
+   * early-exit by checking their feature in the script's featureset. So they will only get run if
+   * the feature they're responsible for removing exists in the script.
+   */
   public static void addPostNormalizationTranspilationPasses(
       PassListBuilder passes, CompilerOptions options) {
     // TODO(b/197349249): Move passes from `addEarlyOptimizationTranspilationPasses()` to here
     // until that method can be deleted as a no-op.
     if (options.needsTranspilationOf(Feature.GENERATORS)) {
       passes.maybeAdd(rewriteGenerators);
     }
+    // This pass must run at the end of all transpiler passes. It validates that only supported
+    // features remain in the compiler's featureSet
     passes.maybeAdd(
         TranspilationPasses.createPostTranspileUnsupportedFeaturesRemovedCheck(
             "postTranspileUnsupportedFeaturesRemovedCheck"));
@@ -441,44 +454,46 @@ static final PassFactory getEs6RewriteDestructuring(ObjectDestructuringRewriteMo
           .build();
 
   /**
-   * @param script The SCRIPT node representing a JS file
-   * @return If the file has any features not in {@code supportedFeatures}
+   * Returns true if the script's featureSet contains any feature from the given featureSet.
+   *
+   * <p>The script's featureSet gets accurately maintained during transpile. It can be relied upon
+   * to check if a feature exists in the AST or not.
    */
-  static boolean doesScriptHaveUnsupportedFeatures(Node script, FeatureSet supportedFeatures) {
+  static boolean doesScriptHaveAnyOfTheseFeatures(Node script, FeatureSet featureSet) {
     FeatureSet features = NodeUtil.getFeatureSetOfScript(script);
-    return features != null && !supportedFeatures.contains(features);
+    return features != null && features.containsAtLeastOneOf(featureSet);
   }
 
   /**
-   * Process transpilations if the input language needs transpilation from certain features, on any
-   * JS file that has features not present in the compiler's output language mode.
+   * Runs the given transpilation callbacks on every source script if the given {@code
+   * featuresToRunFor} are unsupported in the output language and exist in that script.
    *
    * @param compiler An AbstractCompiler
-   * @param combinedRoot The combined root for all JS files.
-   * @param featureSet Ignored
-   * @param callbacks The callbacks that should be invoked if a file has ES2015 features.
+   * @param combinedRoot The combined root for all JS files
+   * @param featuresToRunFor features for which these callbacks run
+   * @param callbacks The callbacks that should be invoked if a file has output-unsupported
+   *     features.
    * @deprecated Please use a regular NodeTraversal object directly, using `shouldTraverse` to skip
    *     SCRIPT node if desired.
    */
   @Deprecated
   static void processTranspile(
       AbstractCompiler compiler,
       Node combinedRoot,
-      FeatureSet featureSet,
+      FeatureSet featuresToRunFor,
       NodeTraversal.Callback... callbacks) {
     FeatureSet languageOutFeatures = compiler.getOptions().getOutputFeatureSet();
+    if (languageOutFeatures.contains(featuresToRunFor)) {
+      // all featuresToRunFor are supported by languageOut and don't need to get transpiled.
+      return;
+    }
+
     for (Node singleRoot = combinedRoot.getFirstChild();
         singleRoot != null;
         singleRoot = singleRoot.getNext()) {
-
-      // Only run the transpilation if this file has features not in the compiler's target output
-      // language. For example, if this file is purely ES6 and the output language is ES6, don't
-      // run any transpilation passes on it.
-      // TODO(lharker): We could save time by being more selective about what files we transpile.
-      // e.g. if a file has async functions but not `**`, don't run `**` transpilation on it.
-      // Right now we know what features were in a file at parse time, but not what features were
-      // added to that file by other transpilation passes.
-      if (doesScriptHaveUnsupportedFeatures(singleRoot, languageOutFeatures)) {
+      checkState(singleRoot.isScript());
+      // only run the callbacks if any feature from the given featureSet exists in the script
+      if (doesScriptHaveAnyOfTheseFeatures(singleRoot, featuresToRunFor)) {
         for (NodeTraversal.Callback callback : callbacks) {
           NodeTraversal.traverse(compiler, singleRoot, callback);
         }