Add CompilerOptions.setInjectPolyfillsNewerThan

PiperOrigin-RevId: 723255441

Author: lauraharker

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

@@ -862,6 +862,28 @@ public static enum OutputJs {
   /** Isolates injected polyfills from the global scope. */
   private boolean isolatePolyfills = false;
 
+  /**
+   * Configures polyfill injection of all polyfills newer than the given language mode, regardless
+   * of whether they are actually referenced in the code being compiled.
+   *
+   * <p>How is this different from --inject_library? --inject_library takes a specific JS file
+   * defined in the jscomp/js package, and injects that and all of its dependencies. This option
+   * takes a language mode.
+   *
+   * <p>For example, the common use of `--inject_library` is passing `--inject_library=es6_runtime`.
+   * es6_runtime.js is a file that contains both all the ES6 polyfills and also ES6 transpilation
+   * utilities (library code referenced by transpiled code). So
+   *
+   * <ul>
+   *   <li>es6_runtime includes transpilation utilities, not just polyfills.
+   *       `--inject_polyfills_newer_than=ES5` will not add transpilation utilities, just the
+   *       polyfills,
+   *   <li>if someone forgot to add a new polyfill to es6_runtime.js, then `--inject_library` will
+   *       not add it, but `--inject_polyfills_newer_than=ES5` will add it.
+   * </ul>
+   */
+  private LanguageMode injectPolyfillsNewerThan = null;
+
   /** Whether to instrument reentrant functions for AsyncContext. */
   private boolean instrumentAsyncContext = false;
 
@@ -2610,6 +2632,14 @@ public boolean getIsolatePolyfills() {
     return this.isolatePolyfills;
   }
 
+  public void setInjectPolyfillsNewerThan(LanguageMode injectPolyfillsNewerThan) {
+    this.injectPolyfillsNewerThan = injectPolyfillsNewerThan;
+  }
+
+  LanguageMode getInjectPolyfillsNewerThan() {
+    return this.injectPolyfillsNewerThan;
+  }
+
   /** Sets whether to isolate polyfills from the global scope. */
   public void setInstrumentAsyncContext(boolean instrumentAsyncContext) {
     this.instrumentAsyncContext = instrumentAsyncContext;

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

@@ -154,14 +154,14 @@ protected PassListBuilder getTranspileOnlyPasses() {
 
     TranspilationPasses.addTranspilationRuntimeLibraries(passes);
 
-    if (options.needsTranspilationFrom(ES2015)) {
-      if (options.getRewritePolyfills()) {
+    if (options.needsTranspilationFrom(ES2015) && options.getRewritePolyfills()) {
         if (options.getIsolatePolyfills()) {
           throw new IllegalStateException(
               "Polyfill isolation cannot be used in transpileOnly mode");
         }
         TranspilationPasses.addRewritePolyfillPass(passes);
-      }
+    } else if (options.getInjectPolyfillsNewerThan() != null) {
+      TranspilationPasses.addRewritePolyfillPass(passes);
     }
 
     passes.maybeAdd(injectRuntimeLibraries);
@@ -883,7 +883,9 @@ private PassListBuilder getEarlyOptimizationPasses() {
 
     TranspilationPasses.addTranspilationRuntimeLibraries(passes);
 
-    if (options.rewritePolyfills || options.getIsolatePolyfills()) {
+    if (options.rewritePolyfills
+        || options.getIsolatePolyfills()
+        || options.getInjectPolyfillsNewerThan() != null) {
       TranspilationPasses.addRewritePolyfillPass(passes);
     }
 
@@ -2392,7 +2394,9 @@ public void process(Node externs, Node root) {
                       // If we are forcing injection of some library code, don't remove polyfills.
                       // Otherwise, we might end up removing polyfills the user specifically asked
                       // to include.
-                      .removeUnusedPolyfills(options.forceLibraryInjection.isEmpty())
+                      .removeUnusedPolyfills(
+                          options.forceLibraryInjection.isEmpty()
+                              && options.getInjectPolyfillsNewerThan() == null)
                       .assumeGettersArePure(options.getAssumeGettersArePure())
                       .build())
           .build();

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

@@ -21,10 +21,14 @@
 import com.google.auto.value.AutoValue;
 import com.google.common.base.Splitter;
 import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableMultimap;
 import com.google.common.collect.ImmutableSet;
 import com.google.javascript.jscomp.AbstractCompiler.LifeCycleStage;
+import com.google.javascript.jscomp.CompilerOptions.LanguageMode;
+import com.google.javascript.jscomp.parsing.parser.FeatureSet;
+import com.google.javascript.jscomp.parsing.parser.FeatureSet.Feature;
 import com.google.javascript.rhino.Node;
 import java.util.ArrayDeque;
 import java.util.List;
@@ -93,11 +97,17 @@ static final class Polyfills {
     private final ImmutableMap<String, Polyfill> statics;
     // Set of suffixes of qualified names.
     private final ImmutableSet<String> suffixes;
+    // Map of all polyfills, keyed by their native version (the first ECMAScript spec version in
+    // which they are defined)
+    private final ImmutableMultimap<String, Polyfill> byNativeVersion;
 
     private Polyfills(
-        ImmutableMultimap<String, Polyfill> methods, ImmutableMap<String, Polyfill> statics) {
+        ImmutableMultimap<String, Polyfill> methods,
+        ImmutableMap<String, Polyfill> statics,
+        ImmutableMultimap<String, Polyfill> byNativeVersion) {
       this.methods = methods;
       this.statics = statics;
+      this.byNativeVersion = byNativeVersion;
       this.suffixes =
           ImmutableSet.copyOf(
               statics.keySet().stream()
@@ -119,6 +129,7 @@ private Polyfills(
     static Polyfills fromTable(String table) {
       ImmutableMultimap.Builder<String, Polyfill> methods = ImmutableMultimap.builder();
       ImmutableMap.Builder<String, Polyfill> statics = ImmutableMap.builder();
+      ImmutableMultimap.Builder<String, Polyfill> byNativeVersion = ImmutableMultimap.builder();
       for (String line : Splitter.on('\n').omitEmptyStrings().split(table)) {
         List<String> tokens = Splitter.on(' ').omitEmptyStrings().splitToList(line.trim());
         if (tokens.size() == 1 && tokens.get(0).isEmpty()) {
@@ -142,10 +153,46 @@ static Polyfills fromTable(String table) {
         } else {
           statics.put(symbol, polyfill);
         }
+        byNativeVersion.put(nativeVersionStr, polyfill);
       }
-      return new Polyfills(methods.build(), statics.buildOrThrow());
+      return new Polyfills(methods.build(), statics.buildOrThrow(), byNativeVersion.build());
     }
 
+    ImmutableList<Polyfill> getPolyfillsNewerThan(LanguageMode languageMode) {
+      FeatureSet featureSet = languageMode.toFeatureSet();
+      ImmutableList.Builder<Polyfill> result = ImmutableList.builder();
+
+      for (String nativeVersionStr : byNativeVersion.keySet()) {
+        FeatureSet polyfillNativeFeatureSet = getPolyfillSupportedFeatureSet(nativeVersionStr);
+        if (!featureSet.contains(polyfillNativeFeatureSet)) {
+          result.addAll(byNativeVersion.get(nativeVersionStr));
+        }
+      }
+      return result.build();
+    }
+  }
+
+  /**
+   * Converts a polyfill native version string as passed to $jscomp.polyfill, e.g. "es6", to a
+   * FeatureSet.
+   */
+  static FeatureSet getPolyfillSupportedFeatureSet(String nativeVersionStr) {
+    FeatureSet polyfillSupportFeatureSet = FeatureSet.valueOf(nativeVersionStr);
+    // Safari has been really slow to implement these regex features, even though it has
+    // kept on top of the features we polyfill, so we want to ignore the regex features
+    // when deciding whether the polyfill should be considered "already supported" in the
+    // target environment.
+    // NOTE: This special case seems reasonable for now, but if further divergence occurs
+    // we should consider doing a more direct solution by having the polyfill definitions
+    // report names of `FeatureSet` values representing browser `FeatureSet` year instead of
+    // spec release year.
+    polyfillSupportFeatureSet =
+        polyfillSupportFeatureSet.without(
+            Feature.REGEXP_FLAG_S,
+            Feature.REGEXP_LOOKBEHIND,
+            Feature.REGEXP_NAMED_GROUPS,
+            Feature.REGEXP_UNICODE_PROPERTY_ESCAPE);
+    return polyfillSupportFeatureSet;
   }
 
   @AutoValue

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

@@ -16,12 +16,17 @@
 
 package com.google.javascript.jscomp;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.collect.ImmutableList.toImmutableList;
+
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.javascript.jscomp.CompilerOptions.LanguageMode;
 import com.google.javascript.jscomp.PolyfillUsageFinder.Polyfill;
 import com.google.javascript.jscomp.PolyfillUsageFinder.PolyfillUsage;
 import com.google.javascript.jscomp.PolyfillUsageFinder.Polyfills;
 import com.google.javascript.jscomp.parsing.parser.FeatureSet;
-import com.google.javascript.jscomp.parsing.parser.FeatureSet.Feature;
 import com.google.javascript.jscomp.resources.ResourceLoader;
 import com.google.javascript.rhino.IR;
 import com.google.javascript.rhino.Node;
@@ -53,6 +58,7 @@ public class RewritePolyfills implements CompilerPass {
   private final boolean injectPolyfills;
   private final boolean isolatePolyfills;
   private Set<String> libraries;
+  private final LanguageMode injectPolyfillsNewerThan;
 
   /**
    * @param injectPolyfills if true, injects $jscomp.polyfill initializations into the first input.
@@ -61,25 +67,31 @@ public class RewritePolyfills implements CompilerPass {
    *     IsolatePolyfills} to prevent their deletion.
    */
   public RewritePolyfills(
-      AbstractCompiler compiler, boolean injectPolyfills, boolean isolatePolyfills) {
+      AbstractCompiler compiler,
+      boolean injectPolyfills,
+      boolean isolatePolyfills,
+      LanguageMode injectPolyfillsNewerThan) {
     this(
         compiler,
         Polyfills.fromTable(
             ResourceLoader.loadTextResource(RewritePolyfills.class, "js/polyfills.txt")),
         injectPolyfills,
-        isolatePolyfills);
+        isolatePolyfills,
+        injectPolyfillsNewerThan);
   }
 
   @VisibleForTesting
   RewritePolyfills(
       AbstractCompiler compiler,
       Polyfills polyfills,
       boolean injectPolyfills,
-      boolean isolatePolyfills) {
+      boolean isolatePolyfills,
+      LanguageMode injectPolyfillsNewerThan) {
     this.compiler = compiler;
     this.polyfills = polyfills;
     this.injectPolyfills = injectPolyfills;
     this.isolatePolyfills = isolatePolyfills;
+    this.injectPolyfillsNewerThan = injectPolyfillsNewerThan;
   }
 
   @Override
@@ -96,22 +108,42 @@ public void process(Node externs, Node root) {
       compiler.reportChangeToEnclosingScope(jscompLookupMethodDecl);
     }
 
-    if (!this.injectPolyfills) {
+    if (!this.injectPolyfills && this.injectPolyfillsNewerThan == null) {
       // Nothing left to do. Probably this pass only needed to run because --isolate_polyfills is
       // enabled but not --rewrite_polyfills.
       return;
     }
+    if (this.injectPolyfills) {
+      this.libraries = new LinkedHashSet<>();
+      new PolyfillUsageFinder(compiler, polyfills).traverseExcludingGuarded(root, this::inject);
+    }
 
-    this.libraries = new LinkedHashSet<>();
-    new PolyfillUsageFinder(compiler, polyfills).traverseExcludingGuarded(root, this::inject);
-
-    if (libraries.isEmpty()) {
-      return;
+    final ImmutableList<String> librariesToInject;
+    if (this.injectPolyfillsNewerThan != null) {
+      ImmutableList<Polyfill> polyfillsToInject =
+          polyfills.getPolyfillsNewerThan(this.injectPolyfillsNewerThan);
+      librariesToInject =
+          polyfillsToInject.stream()
+              // Skip polyfills that have no associated library. This is true for language
+              // features like `Proxy` and `String.raw` that have no associated polyfill, hence
+              // there's
+              // nothing to inject here.
+              .filter(p -> !p.library.isEmpty())
+              .map(p -> p.library)
+              .collect(toImmutableList());
+    } else {
+      librariesToInject = ImmutableList.copyOf(this.libraries);
     }
 
+    this.injectAll(librariesToInject, /* forceInjection= */ this.injectPolyfillsNewerThan != null);
+  }
+
+  private void injectAll(Iterable<String> librariesToInject, boolean forceInjection) {
     Node lastNode = null;
-    for (String library : libraries) {
-      lastNode = compiler.ensureLibraryInjected(library, false);
+    for (String library : librariesToInject) {
+      checkNotNull(library);
+      checkState(!library.isEmpty(), "unexpected empty library");
+      lastNode = compiler.ensureLibraryInjected(library, forceInjection);
     }
     if (lastNode != null) {
       Node parent = lastNode.getParent();
@@ -153,20 +185,8 @@ private void removeUnneededPolyfills(Node parent, Node runtimeEnd) {
       if (JSCOMP_POLYFILL.matches(name)) {
         final String nativeVersionStr = name.getNext().getNext().getNext().getString();
         polyfillSupportFeatureSet = FeatureSet.valueOf(nativeVersionStr);
-        // Safari has been really slow to implement these regex features, even though it has
-        // kept on top of the features we polyfill, so we want to ignore the regex features
-        // when deciding whether the polyfill should be considered "already supported" in the
-        // target environment.
-        // NOTE: This special case seems reasonable for now, but if further divergence occurs
-        // we should consider doing a more direct solution by having the polyfill definitions
-        // report names of `FeatureSet` values representing browser `FeatureSet` year instead of
-        // spec release year.
         polyfillSupportFeatureSet =
-            polyfillSupportFeatureSet.without(
-                Feature.REGEXP_FLAG_S,
-                Feature.REGEXP_LOOKBEHIND,
-                Feature.REGEXP_NAMED_GROUPS,
-                Feature.REGEXP_UNICODE_PROPERTY_ESCAPE);
+            PolyfillUsageFinder.getPolyfillSupportedFeatureSet(nativeVersionStr);
       }
     }
     return polyfillSupportFeatureSet;

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

@@ -311,7 +311,8 @@ static final PassFactory getEs6RewriteDestructuring(ObjectDestructuringRewriteMo
                   new RewritePolyfills(
                       compiler,
                       compiler.getOptions().getRewritePolyfills(),
-                      compiler.getOptions().getIsolatePolyfills()))
+                      compiler.getOptions().getIsolatePolyfills(),
+                      compiler.getOptions().getInjectPolyfillsNewerThan()))
           .build();
 
   static final PassFactory instrumentAsyncContext =

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

@@ -45,6 +45,7 @@ public final class RewritePolyfillsTest extends CompilerTestCase {
   private final List<String> polyfillTable = new ArrayList<>();
   private boolean isolatePolyfills = false;
   private boolean injectPolyfills = true;
+  private LanguageMode injectPolyfillsNewerThan = null;
 
   private void addLibrary(String name, String from, String to, @Nullable String library) {
     if (library != null) {
@@ -61,6 +62,7 @@ public void setUp() throws Exception {
     super.setUp();
     injectableLibraries.clear();
     polyfillTable.clear();
+    injectPolyfillsNewerThan = null;
     setLanguageOut(LanguageMode.ECMASCRIPT5);
   }
 
@@ -70,7 +72,8 @@ protected CompilerPass getProcessor(Compiler compiler) {
         compiler,
         Polyfills.fromTable(Joiner.on("\n").join(polyfillTable)),
         injectPolyfills,
-        isolatePolyfills);
+        isolatePolyfills,
+        injectPolyfillsNewerThan);
   }
 
   @Override
@@ -590,4 +593,29 @@ public void testNoCodeChangesIfInjectionDisabled() {
     allowExternsChanges();
     testSame("'x'.endsWith('y');");
   }
+
+  @Test
+  public void testForceInject_es5_addsES6AndES8() {
+    injectPolyfillsNewerThan = LanguageMode.ECMASCRIPT5;
+    addLibrary("String.prototype.endsWith", "es6", "es5", "es6/string/endswith");
+    addLibrary("Object.values", "es8", "es3", "es6/object/values");
+
+    testInjects("", "es6/string/endswith", "es6/object/values");
+  }
+
+  @Test
+  public void testForceInject_es2015_addsES8Polyfill() {
+    injectPolyfillsNewerThan = LanguageMode.ECMASCRIPT5;
+    addLibrary("Object.values", "es8", "es3", "es6/object/values");
+
+    testInjects("", "es6/object/values");
+  }
+
+  @Test
+  public void testForceInject_es2015_skipsEs2015Polyfills() {
+    injectPolyfillsNewerThan = LanguageMode.ECMASCRIPT_2015;
+    addLibrary("String.prototype.endsWith", "es6", "es5", "es6/string/endswith");
+
+    testDoesNotInject("");
+  }
 }