Add ES2022 configuration to JSCompiler.

PiperOrigin-RevId: 839794371

Author: trevorade

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

@@ -3132,6 +3132,9 @@ public enum LanguageMode {
     /** ECMAScript standard approved in 2021. */
     ECMASCRIPT_2021,
 
+    /** ECMAScript standard approved in 2022. */
+    ECMASCRIPT_2022,
+
     /** ECMAScript features from the upcoming standard. */
     ECMASCRIPT_NEXT,
 
@@ -3215,6 +3218,7 @@ public FeatureSet toFeatureSet() {
         case ECMASCRIPT_2019 -> FeatureSet.ES2019_MODULES;
         case ECMASCRIPT_2020 -> FeatureSet.ES2020_MODULES;
         case ECMASCRIPT_2021 -> FeatureSet.ES2021_MODULES;
+        case ECMASCRIPT_2022 -> FeatureSet.ES2022_MODULES;
         case ECMASCRIPT_NEXT -> FeatureSet.ES_NEXT;
         case NO_TRANSPILE, UNSTABLE -> FeatureSet.ES_UNSTABLE;
         case UNSUPPORTED -> FeatureSet.ES_UNSUPPORTED;

src/com/google/javascript/jscomp/parsing/Config.java

@@ -54,6 +54,7 @@ public enum LanguageMode {
     ECMASCRIPT_2019(FeatureSet.ES2019_MODULES),
     ECMASCRIPT_2020(FeatureSet.ES2020_MODULES),
     ECMASCRIPT_2021(FeatureSet.ES2021_MODULES),
+    ECMASCRIPT_2022(FeatureSet.ES2022_MODULES),
     // NOTE: When adding a new language level here, also update latestEcmaScript() below to return
     // it.
     ES_NEXT(FeatureSet.ES_NEXT),

src/com/google/javascript/jscomp/parsing/ParserRunner.java

@@ -163,6 +163,7 @@ private static com.google.javascript.jscomp.parsing.parser.Parser.Config newPars
               ECMASCRIPT_2019,
               ECMASCRIPT_2020,
               ECMASCRIPT_2021,
+              ECMASCRIPT_2022,
               ES_NEXT,
               UNSTABLE,
               UNSUPPORTED ->

src/com/google/javascript/jscomp/parsing/parser/FeatureSet.java

@@ -85,11 +85,16 @@ public final class FeatureSet implements Serializable {
 
   public static final FeatureSet ES2021 = ES2021_MODULES.without(Feature.MODULES);
 
-  // NOTE: when ES2022 / ES2023 are added, the BROWSER_2024 FeatureSet defined below should be
-  // updated to include them.
+  public static final FeatureSet ES2022_MODULES =
+      ES2021_MODULES.with(LangVersion.ES2022.features());
+
+  public static final FeatureSet ES2022 = ES2022_MODULES.without(Feature.MODULES);
+
+  // NOTE: when ES2023 is added, the BROWSER_2024 and BROWSER_2025 FeatureSets defined below should
+  // be updated to include it.
 
   // Set of all fully supported features, even those part of language versions not fully supported
-  public static final FeatureSet ES_NEXT = ES2021_MODULES.with(LangVersion.ES_NEXT.features());
+  public static final FeatureSet ES_NEXT = ES2022_MODULES.with(LangVersion.ES_NEXT.features());
 
   // Set of features fully supported in checks, even those not fully supported in optimizations
   public static final FeatureSet ES_UNSTABLE = ES_NEXT.with(LangVersion.ES_UNSTABLE.features());
@@ -154,21 +159,23 @@ public final class FeatureSet implements Serializable {
           Feature.REGEXP_LOOKBEHIND);
 
   public static final FeatureSet BROWSER_2023 =
-      ES2021_MODULES.without(
+      ES2022_MODULES.without(
           // IMPORTANT: There is special casing for this feature and the ones excluded for
           // BROWSER_2020 above in RewritePolyfills.
           // If future Browser FeatureSet Year definitions have to remove any other features, then
           // we need to change the way that is done to avoid incorrect inclusion of polyfills.
           // Chrome 62 (2017). Firefox 78 (2020). Safari 16.4 (2023).
-          Feature.REGEXP_LOOKBEHIND);
+          Feature.REGEXP_LOOKBEHIND,
+          // Chrome 94 (2021). Firefox 93 (2021). Safari 16.4 (2023).
+          Feature.CLASS_STATIC_BLOCK);
 
   // Note: Only "Hashbang Grammar" is an ES2023 syntax feature. Its versions are:
   // Chrome 74 (2019). Firefox 67 (2019). Safari 13.1 (2020).
-  public static final FeatureSet BROWSER_2024 = ES2021_MODULES;
+  public static final FeatureSet BROWSER_2024 = ES2022_MODULES;
 
   // Note: Only "RegExp `v` flag" is an ES2024 syntax feature. Its versions are:
   // Chrome 112 (2023). Firefox 116 (2023). Safari 17 (2023).
-  public static final FeatureSet BROWSER_2025 = ES2021_MODULES;
+  public static final FeatureSet BROWSER_2025 = ES2022_MODULES;
 
   public static final FeatureSet ALL = ES_UNSUPPORTED.with(LangVersion.TYPESCRIPT.features());
 
@@ -182,6 +189,7 @@ private enum LangVersion {
     ES2019,
     ES2020,
     ES2021,
+    ES2022,
     ES_NEXT,
     ES_UNSTABLE,
     ES_UNSUPPORTED,
@@ -292,9 +300,15 @@ public enum Feature {
     NUMERIC_SEPARATOR("numeric separator", LangVersion.ES2021),
     LOGICAL_ASSIGNMENT("Logical assignments", LangVersion.ES2021),
 
+    // ES 2022 adds https://github.com/tc39/proposal-class-fields
+    PUBLIC_CLASS_FIELDS("Public class fields", LangVersion.ES2022),
+
+    // ES 2022 adds https://github.com/tc39/proposal-class-static-block
+    CLASS_STATIC_BLOCK("Class static block", LangVersion.ES2022),
+
     // ES 2022 adds https://github.com/tc39/proposal-regexp-match-indices
     // Note: Untranspilable.
-    REGEXP_FLAG_D("RegExp flag 'd'", LangVersion.ES_NEXT),
+    REGEXP_FLAG_D("RegExp flag 'd'", LangVersion.ES2022),
 
     // ES_NEXT: Features that are fully supported, but part of a language version that is not yet
     // fully supported
@@ -311,11 +325,6 @@ public enum Feature {
     // incorrectly prune those polyfills.
     ES_UNSTABLE_RUNTIME("es_unstable runtime", LangVersion.ES_UNSTABLE),
 
-    PUBLIC_CLASS_FIELDS("Public class fields", LangVersion.ES_NEXT), // Part of ES2022
-
-    // ES 2022 adds https://github.com/tc39/proposal-class-static-block
-    CLASS_STATIC_BLOCK("Class static block", LangVersion.ES_UNSTABLE),
-
     // ES_UNSUPPORTED: Features that we can parse, but not yet supported in all checks
 
     // ES 2022 adds https://github.com/tc39/proposal-class-fields
@@ -377,6 +386,9 @@ public String version() {
     if (ES2021_MODULES.contains(this)) {
       return "es_2021";
     }
+    if (ES2022_MODULES.contains(this)) {
+      return "es_2022";
+    }
     if (ES_NEXT.contains(this)) {
       return "es_next";
     }
@@ -530,6 +542,7 @@ public static FeatureSet valueOf(String name) {
       case "es_2019" -> ES2019;
       case "es_2020" -> ES2020;
       case "es_2021" -> ES2021;
+      case "es_2022" -> ES2022;
       case "es_next" -> ES_NEXT;
       case "es_unstable" -> ES_UNSTABLE;
       case "es_unsupported" -> ES_UNSUPPORTED;

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

@@ -106,7 +106,7 @@ public void testMinimumBrowserFeatureSetYearRequiredFor() {
   public void testMinimumBrowserFeatureSetYearRequiredFor_returnsUnspecifiedIfUnsupported() {
     // Newer features, in particular anything in ES_NEXT, may not be part of a browser featureset
     // year yet.
-    assertThat(BrowserFeaturesetYear.minimumRequiredFor(Feature.PUBLIC_CLASS_FIELDS)).isNull();
+    assertThat(BrowserFeaturesetYear.minimumRequiredFor(Feature.ES_NEXT_RUNTIME)).isNull();
   }
 
   @Test

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

@@ -248,20 +248,21 @@ public void testEs2022RegexFlagD() {
         "const a = /^(?<half>.*).\\k<half>$/d;",
         UNTRANSPILABLE_FEATURE_PRESENT,
         """
-        Cannot convert feature "RegExp flag 'd'" to targeted output language. Feature requires\
-         at minimum ES_NEXT. Consider targeting a more modern output.\
+        Cannot convert feature "RegExp flag 'd'" to targeted output language. Feature requires at \
+        minimum ECMASCRIPT_2022. Consider targeting a more modern output.\
         """);
   }
 
   @Test
   public void testEs2022RegexFlagD_usingBrowserFeaturesetYear() {
-    browserFeaturesetYear = BrowserFeaturesetYear.YEAR_2024;
+    browserFeaturesetYear = BrowserFeaturesetYear.YEAR_2022;
     testError(
         "const a = /^(?<half>.*).\\k<half>$/d;",
         UNTRANSPILABLE_FEATURE_PRESENT,
         """
-        Cannot convert feature "RegExp flag 'd'" to targeted output language. Feature requires\
-         at minimum ES_NEXT, which is not yet supported by any browser featureset year.\
+        Cannot convert feature "RegExp flag 'd'" to targeted output language. Feature requires at \
+        minimum browser featureset year 2023. Consider targeting a more modern output.
+        Current browser featureset year: 2022\
         """);
   }
 

test/com/google/javascript/jscomp/parsing/ParserTest.java

@@ -6127,8 +6127,10 @@ public void testClassComputedField_es2020_warnsForCodeOutsideClosureUnawareRange
         // This warning is expected - it is used to halt compilation during parsing when
         // closure-unaware code is present when it should not be.
         "@closureUnaware annotation is not allowed in this compilation",
-        "This language feature is only supported for ES_NEXT mode or better: Public class"
-            + " fields");
+        """
+        This language feature is only supported for ECMASCRIPT_2022 mode or better: \
+        Public class fields\
+        """);
 
     expectFeatures(Feature.CLASSES, Feature.PUBLIC_CLASS_FIELDS);
   }

test/com/google/javascript/jscomp/parsing/parser/FeatureSetTest.java

@@ -50,7 +50,8 @@ public void testEsOrdering() {
     assertFS(FeatureSet.ALL).contains(FeatureSet.ES_UNSUPPORTED);
     assertFS(FeatureSet.ES_UNSUPPORTED).contains(FeatureSet.ES_UNSTABLE);
     assertFS(FeatureSet.ES_UNSTABLE).contains(FeatureSet.ES_NEXT);
-    assertFS(FeatureSet.ES_NEXT).contains(FeatureSet.ES2021);
+    assertFS(FeatureSet.ES_NEXT).contains(FeatureSet.ES2022);
+    assertFS(FeatureSet.ES2022).contains(FeatureSet.ES2021);
     assertFS(FeatureSet.ES2021).contains(FeatureSet.ES2020);
     assertFS(FeatureSet.ES2020).contains(FeatureSet.ES2019);
     assertFS(FeatureSet.ES2019).contains(FeatureSet.ES2018);
@@ -64,6 +65,7 @@ public void testEsOrdering() {
 
   @Test
   public void testEsModuleOrdering() {
+    assertFS(FeatureSet.ES2022_MODULES.without(Feature.MODULES)).equals(FeatureSet.ES2022);
     assertFS(FeatureSet.ES2021_MODULES.without(Feature.MODULES)).equals(FeatureSet.ES2021);
     assertFS(FeatureSet.ES2020_MODULES.without(Feature.MODULES)).equals(FeatureSet.ES2020);
     assertFS(FeatureSet.ES2019_MODULES.without(Feature.MODULES)).equals(FeatureSet.ES2019);
@@ -92,6 +94,8 @@ public void testVersionForDebugging() {
     assertThat(FeatureSet.ES2020_MODULES.version()).isEqualTo("es_2020");
     assertThat(FeatureSet.ES2021.version()).isEqualTo("es_2021");
     assertThat(FeatureSet.ES2021_MODULES.version()).isEqualTo("es_2021");
+    assertThat(FeatureSet.ES2022.version()).isEqualTo("es_2022");
+    assertThat(FeatureSet.ES2022_MODULES.version()).isEqualTo("es_2022");
     assertThat(FeatureSet.ALL.version()).isEqualTo("all");
   }
 
@@ -120,6 +124,7 @@ public void testValueOf() {
     assertFS(FeatureSet.valueOf("es_2019")).equals(FeatureSet.ES2019);
     assertFS(FeatureSet.valueOf("es_2020")).equals(FeatureSet.ES2020);
     assertFS(FeatureSet.valueOf("es_2021")).equals(FeatureSet.ES2021);
+    assertFS(FeatureSet.valueOf("es_2022")).equals(FeatureSet.ES2022);
     assertFS(FeatureSet.valueOf("es_next")).equals(FeatureSet.ES_NEXT);
     assertFS(FeatureSet.valueOf("es_unstable")).equals(FeatureSet.ES_UNSTABLE);
     assertFS(FeatureSet.valueOf("es_unsupported")).equals(FeatureSet.ES_UNSUPPORTED);