Propagate debugging/output-related options to TranspileAndOptimizeClosureUnaware

PiperOrigin-RevId: 845294545

Author: lauraharker

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

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2025 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 com.google.javascript.jscomp.parsing.parser.FeatureSet;
+import java.nio.file.Path;
+
+class ClosureUnawareOptions {
+  private final CompilerOptions shadowOptions = new CompilerOptions();
+  private final CompilerOptions original;
+
+  static CompilerOptions convert(CompilerOptions original) {
+    var options = new ClosureUnawareOptions(original);
+    return options.toCompilerOptions();
+  }
+
+  private ClosureUnawareOptions(CompilerOptions original) {
+    this.original = original;
+  }
+
+  private CompilerOptions toCompilerOptions() {
+    setTranspilationOptions();
+    setSafeOptimizationAssumptions();
+    copyOutputOptions();
+    copyDebugOptions();
+    return shadowOptions;
+  }
+
+  private void setTranspilationOptions() {
+    // TODO: b/421971366 add transpilation support.
+    shadowOptions.setOutputFeatureSet(FeatureSet.ES_NEXT);
+
+    // currently we have no plans to automatically detect required polyfills.
+    shadowOptions.setRewritePolyfills(false);
+  }
+
+  private void setSafeOptimizationAssumptions() {
+    shadowOptions.setFoldConstants(true);
+  }
+
+  private void copyOutputOptions() {
+    shadowOptions.setPrettyPrint(original.isPrettyPrint());
+    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() {
+    shadowOptions.setTracerMode(original.getTracerMode());
+    shadowOptions.setDevMode(original.devMode);
+
+    shadowOptions.setPrintSourceAfterEachPass(original.printSourceAfterEachPass);
+    shadowOptions.setFilesToPrintAfterEachPassRegexList(
+        original.filesToPrintAfterEachPassRegexList);
+    shadowOptions.setPrintInputDelimiter(original.printInputDelimiter);
+    shadowOptions.setInputDelimiter(original.inputDelimiter);
+
+    shadowOptions.setDebugLogFilter(original.getDebugLogFilter());
+    Path debugLogDirectory = original.getDebugLogDirectory();
+    if (debugLogDirectory != null) {
+      shadowOptions.setDebugLogDirectory(
+          debugLogDirectory.resolve("./TranspileAndOptimizeClosureUnaware"));
+    }
+  }
+}

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

@@ -43,9 +43,7 @@ public void process(Node externs, Node root) {
       return;
     }
 
-    var shadowOptions = new CompilerOptions();
-    // TODO: b/421971366 - enable simple optimizations + debugging options + transpilation
-    shadowOptions.setFoldConstants(true);
+    var shadowOptions = ClosureUnawareOptions.convert(original.getOptions());
     // TODO: b/421971366 - enable configuring Mode.TRANSPILE_ONLY.
     NestedCompilerRunner shadowCompiler =
         NestedCompilerRunner.create(

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

@@ -16,9 +16,17 @@
 
 package com.google.javascript.jscomp;
 
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.common.truth.Truth.assertThat;
 import static com.google.javascript.jscomp.CompilerTestCase.srcs;
+import static java.util.stream.Collectors.joining;
 
+import com.google.common.collect.ImmutableList;
 import com.google.javascript.rhino.Node;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -41,13 +49,22 @@ private void process(Node externs, Node root) {
 
   private int inputCount;
   private int outputCount;
+  private Consumer<CompilerOptions> extraOptions;
 
   @Before
   public void setup() {
     disableValidateAstChangeMarking();
     allowExternsChanges();
     this.inputCount = 0;
     this.outputCount = 0;
+    this.extraOptions = options -> {};
+  }
+
+  @Override
+  public CompilerOptions getOptions() {
+    CompilerOptions baseOptions = super.getOptions();
+    extraOptions.accept(baseOptions);
+    return baseOptions;
   }
 
   String createPrettyPrinter(Node n) {
@@ -109,6 +126,95 @@ public void testFoldConstants_multipleClosureUnawareBlocksInFile() {
             expectedClosureUnaware("console.log(3);", "console.log(33);", "console.log(333);")));
   }
 
+  private static String loadFile(Path path) {
+    try (Stream<String> lines = Files.lines(path)) {
+      return lines.collect(joining("\n"));
+    } catch (Exception e) {
+      throw new AssertionError("Failed to load debug log at " + path, e);
+    }
+  }
+
+  private ImmutableList<Path> listFiles(Path dir) {
+    try (Stream<Path> files = Files.list(dir)) {
+      return files.collect(toImmutableList());
+    } catch (Exception e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  @Test
+  public void testSupportsDebugLogging() {
+    enableDebugLogging(true);
+    testNoWarning(closureUnaware("console.log(0 + 1);"));
+
+    Path dir =
+        Path.of(
+            this.getLastCompiler().getOptions().getDebugLogDirectory().toString(),
+            TranspileAndOptimizeClosureUnaware.class.getSimpleName());
+    assertThat(listFiles(dir)).isNotEmpty();
+  }
+
+  @Test
+  public void testSupportsPrintingSourceAfterEachPass() {
+    enableDebugLogging(true);
+    this.extraOptions =
+        (CompilerOptions options) -> {
+          options.setPrintSourceAfterEachPass(true);
+          options.setInputDelimiter("~~test123~ : %name%");
+          options.setPrintInputDelimiter(true);
+        };
+
+    testNoWarning(closureUnaware("console.log(0 + 1);"));
+
+    Path dir =
+        Path.of(
+            this.getLastCompiler().getOptions().getDebugLogDirectory().toString(),
+            TranspileAndOptimizeClosureUnaware.class.getSimpleName());
+    var firstSource = loadFile(dir.resolve("Compiler/source_after_pass/000_parseInputs"));
+    assertThat(firstSource)
+        .isEqualTo(
+            """
+            ~~test123~ : synthetic_base
+            'use strict';
+            ~~test123~ : testcode.shadow0
+            $jscomp_sink_closure_unaware_impl(function(){console.log(0+1)});\
+            """);
+  }
+
+  @Test
+  public void testSupportsPrintingSourceAfterEachPass_withRegexpFilter() {
+    enableDebugLogging(true);
+    this.extraOptions =
+        (CompilerOptions options) -> {
+          options.setPrintSourceAfterEachPass(true);
+          options.setPrettyPrint(true);
+          options.setFilesToPrintAfterEachPassRegexList(ImmutableList.of(".*shadow1"));
+        };
+
+    testNoWarning(
+        srcs(
+            closureUnaware("log('0.0');", "log('0.1');", "log('0.2');"),
+            closureUnaware("log('1.0');", "log('1.1');", "log('1.2');")));
+
+    Path dir =
+        Path.of(
+            this.getLastCompiler().getOptions().getDebugLogDirectory().toString(),
+            TranspileAndOptimizeClosureUnaware.class.getSimpleName());
+    var firstSource = loadFile(dir.resolve("Compiler/source_after_pass/000_parseInputs"));
+    assertThat(firstSource)
+        .isEqualTo(
+            """
+            // testcode0.shadow1
+            $jscomp_sink_closure_unaware_impl(function() {
+              log("0.1");
+            });
+            // testcode1.shadow1
+            $jscomp_sink_closure_unaware_impl(function() {
+              log("1.1");
+            });
+            """);
+  }
+
   private String closureUnaware(String... closureUnaware) {
     String prefix =
         String.format(