Suppress untranspilable feature warnings in @closureUnaware transpilation

Also update TODO about copying CompilerOptions for @closureUnaware.

PiperOrigin-RevId: 856761304

Author: lauraharker

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

@@ -33,6 +33,8 @@ private ClosureUnawareOptions(CompilerOptions original) {
   }
 
   private CompilerOptions toCompilerOptions() {
+    // TODO: b/473813461 - refactor to make sure this class doesn't accidentally skip copying
+    // any options.
     setTranspilationOptions();
     setSafeOptimizationAssumptions();
     copyOutputOptions();
@@ -53,6 +55,17 @@ private void setTranspilationOptions() {
     shadowOptions.setEs6SubclassTranspilation(
         CompilerOptions.Es6SubclassTranspilation.SAFE_REFLECT_CONSTRUCT);
     shadowOptions.setOutputFeatureSet(original.getOutputFeatureSet());
+
+    // To aid rollout of @closureUnaware transpilation, ignore warnings about untranspilable
+    // features for now. (Any project using @closureUnaware today (i.e. early 2026) gets zero
+    // transpilation, so rolling out with these suppressions is an incremental improvement.)
+
+    // DiagnosticGroups.CANNOT_TRANSPILE_FEATURE: features for which the compiler theoretically
+    // might support transpilation, but does not currently.
+    shadowOptions.setWarningLevel(DiagnosticGroups.CANNOT_TRANSPILE_FEATURE, CheckLevel.OFF);
+    // DiagnosticGroups.UNSTRANSPILABLE_FEATURES: features JSCompiler will never transpile, like
+    // regex syntax.
+    shadowOptions.setWarningLevel(DiagnosticGroups.UNSTRANSPILABLE_FEATURES, CheckLevel.OFF);
   }
 
   private void setSafeOptimizationAssumptions() {
@@ -71,8 +84,6 @@ private void copyOutputOptions() {
     shadowOptions.setGeneratePseudoNames(original.generatePseudoNames);
     shadowOptions.setErrorHandler(original.errorHandler);
     shadowOptions.setErrorFormat(original.errorFormat);
-
-    // TODO: lharker - is there any use in propagating the VariableMap & PropertyMap?
   }
 
   private void copyDebugOptions() {

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

@@ -539,6 +539,39 @@ function tag(strings, ...values) {
             """));
   }
 
+  @Test
+  public void bigintLiteral_passedThroughUntranspiled() {
+    setLanguageOut(CompilerOptions.LanguageMode.ECMASCRIPT5);
+
+    test(closureUnaware("return 123n + 456n;"), expectedClosureUnaware("return 579n;"));
+  }
+
+  @Test
+  public void untranspilableRegexFeature_passedThroughUntranspiled() {
+    setLanguageOut(CompilerOptions.LanguageMode.ECMASCRIPT_2015);
+
+    // ES2018 feature: https://github.com/tc39/proposal-regexp-dotall-flag
+    // ES2022 feature: https://github.com/tc39/proposal-regexp-match-indices
+    testSame(closureUnaware("return /a/sd"));
+  }
+
+  @Test
+  public void computedGetterSetter_inEs5Out_passedThroughUntranspiled() {
+    setLanguageOut(CompilerOptions.LanguageMode.ECMASCRIPT5);
+    // JSCompiler does not support transpiling computed getters/setters in object literals down to
+    // ES5. For closureUnaware, verify they are passed through unchanged.
+    testSame(
+        closureUnaware(
+            """
+            return {
+              get [x()]() {
+                return 1;
+              },
+              set [x()](a) {}
+            };
+            """));
+  }
+
   private static String loadFile(Path path) {
     try (Stream<String> lines = Files.lines(path)) {
       return lines.collect(joining("\n"));