Implement JSCompiler expected diagnostics support in runners.

PiperOrigin-RevId: 897704570

Author: Closure Team

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

@@ -143,6 +143,15 @@ public abstract class AbstractCommandLineRunner<A extends Compiler, B extends Co
           "When using --chunk or --module flags, the --create_source_map flag must contain "
               + "%outname% in the value.");
 
+  static final DiagnosticType EXPECTED_DIAGNOSTIC_NOT_FOUND =
+      DiagnosticType.error(
+          "JSC_EXPECTED_DIAGNOSTIC_NOT_FOUND", "Expected diagnostic not found: {0}");
+
+  static final DiagnosticType AMBIGUOUS_EXPECTATION =
+      DiagnosticType.error(
+          "JSC_AMBIGUOUS_EXPECTATION",
+          "Multiple expected diagnostics matched the error: \"{0}\". Matches: \"{1}\"");
+
   static final String WAITING_FOR_INPUT_WARNING = "The compiler is waiting for input via stdin.";
   // Use an 8MiB buffer since the concatenated TypedAst file can be very large.
   private static final int GZIPPED_TYPEDAST_BUFFER_SIZE = 8 * 1024 * 1024;
@@ -1148,6 +1157,10 @@ protected int doRun() throws IOException {
     Compiler.setLoggingLevel(Level.parse(config.loggingLevel));
 
     compiler = createCompiler();
+    if (!config.expectedDiagnostics.isEmpty()) {
+      compiler.setErrorManager(
+          new VerifyingErrorManager(compiler.getErrorManager(), config.expectedDiagnostics));
+    }
     B options = createOptions();
     setRunOptions(options);
 
@@ -1271,7 +1284,7 @@ protected int doRun() throws IOException {
       try {
         // This is the common case - we're actually compiling something.
         performCompilation(metricsRecorder);
-        result = compiler.getResult();
+
         // If we're finished with compilation (i.e. we're not saving state), /and/ the compiler was
         // restored from a previous state, then we need to re-initialize the set of chunks.
         // TODO(lharker): figure out if this is still needed.
@@ -1287,6 +1300,7 @@ protected int doRun() throws IOException {
         // exception somewhere.
         compiler.generateReport();
       }
+      result = compiler.getResult();
     }
 
     if (createCommonJsModules) {
@@ -1444,7 +1458,7 @@ private void initializeStateBeforeCompilation() {
     } else {
       // parsing!
       compiler.parseForCompilation();
-  }
+    }
   }
 
   private void restoreState(String filename) {
@@ -2577,6 +2591,19 @@ public CommandLineConfig setParseInlineSourceMaps(boolean parseInlineSourceMaps)
       return this;
     }
 
+    private final List<String> expectedDiagnostics = new ArrayList<>();
+
+    /**
+     * Expected diagnostics in the format [(line,col)]CODE:regex. CODE is the JSCompiler
+     * DiagnosticType key. regex matches the description.
+     */
+    @CanIgnoreReturnValue
+    public CommandLineConfig setExpectedDiagnostics(List<String> expectedDiagnostics) {
+      this.expectedDiagnostics.clear();
+      this.expectedDiagnostics.addAll(expectedDiagnostics);
+      return this;
+    }
+
     private String variableMapInputFile = "";
 
     /**

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

@@ -951,6 +951,13 @@ private static class Flags {
                 + "renaming map produced by a previous compilation")
     private String propertyMapInputFile = "";
 
+    @Option(
+        name = "--expected_diagnostics",
+        usage =
+            "Expected diagnostics in the format [(line,col)]CODE:regex. "
+                + "CODE is the JSCompiler DiagnosticType key. regex matches the description.")
+    private List<String> expectedDiagnostics = new ArrayList<>();
+
     @Argument private List<String> arguments = new ArrayList<>();
     private final CmdLineParser parser;
 
@@ -1738,6 +1745,7 @@ private void initConfigFromFlags(String[] args, PrintStream out, PrintStream err
           .setVariableMapOutputFile(flags.variableMapOutputFile)
           .setCreateNameMapFiles(flags.createNameMapFiles)
           .setPropertyMapOutputFile(flags.propertyMapOutputFile)
+          .setExpectedDiagnostics(flags.expectedDiagnostics)
           .setPropertyMapInputFile(flags.propertyMapInputFile)
           .setVariableMapInputFile(flags.variableMapInputFile)
           .setInstrumentationMappingFile(flags.instrumentationMappingOutputFile)

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

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2026 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 java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * An ErrorManager that verifies expected diagnostics and reports missing or unexpected ones.
+ *
+ * <p>It wraps a delegate ErrorManager. Expected diagnostics (passed as regexes) are swallowed if
+ * matched. Unexpected diagnostics are passed to the delegate. At the end of compilation (when
+ * generateReport is called), any unmatched expectations are reported as errors to the delegate.
+ */
+public final class VerifyingErrorManager extends ThreadSafeDelegatingErrorManager {
+
+  private final List<Pattern> unmatchedExpectations;
+  private final LightweightMessageFormatter formatter;
+
+  public VerifyingErrorManager(ErrorManager delegate, List<String> expectedDiagnostics) {
+    super(delegate);
+    this.formatter = LightweightMessageFormatter.withoutSource();
+    this.unmatchedExpectations = new ArrayList<>();
+    for (String exp : expectedDiagnostics) {
+      this.unmatchedExpectations.add(Pattern.compile(exp));
+    }
+  }
+
+  @Override
+  public synchronized void report(CheckLevel level, JSError error) {
+    String formattedError = formatErrorForMatching(level, error);
+
+    Pattern matchedPattern = null;
+    Iterator<Pattern> iterator = unmatchedExpectations.iterator();
+    while (iterator.hasNext()) {
+      Pattern p = iterator.next();
+      if (p.matcher(formattedError).find()) {
+        if (matchedPattern == null) {
+          matchedPattern = p;
+          iterator.remove();
+          continue;
+        }
+
+        if (matchedPattern.toString().equals(p.toString())) {
+          // Allow duplicates that are identical.
+          continue;
+        }
+
+        super.report(
+            CheckLevel.ERROR,
+            JSError.make(
+                AbstractCommandLineRunner.AMBIGUOUS_EXPECTATION,
+                formattedError,
+                matchedPattern.toString(),
+                p.toString()));
+        iterator.remove();
+      }
+    }
+
+    if (matchedPattern == null) {
+      super.report(level, error);
+    }
+  }
+
+  @Override
+  public synchronized void generateReport() {
+    reportMissingExpectations();
+    super.generateReport();
+  }
+
+  private synchronized void reportMissingExpectations() {
+    for (Pattern p : unmatchedExpectations) {
+      super.report(
+          CheckLevel.ERROR,
+          JSError.make(AbstractCommandLineRunner.EXPECTED_DIAGNOSTIC_NOT_FOUND, p.toString()));
+    }
+    unmatchedExpectations.clear();
+  }
+
+  private String formatErrorForMatching(CheckLevel level, JSError error) {
+    return level == CheckLevel.ERROR
+        ? formatter.formatError(error)
+        : formatter.formatWarning(error);
+  }
+}

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

@@ -33,6 +33,7 @@
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.io.Files;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.gson.Gson;
 import com.google.gson.JsonArray;
 import com.google.gson.JsonObject;
@@ -3616,6 +3617,100 @@ public void testTranspileOnlyModeSyntaxError() {
     test("const x = {", RhinoErrorReporter.PARSE_ERROR);
   }
 
+  @Test
+  public void testExpectedDiagnostics_matchErrorAndWarning() {
+    args.add("--jscomp_error=checkTypes");
+    args.add("--jscomp_warning=uselessCode");
+    ImmutableList<JSError> actualErrors =
+        testExpectedDiagnostics(
+            "/** @type {string} */ var x = 1; var y = 1; y;",
+            new String[] {
+              """
+              input0:1:30: ERROR - \\[JSC_TYPE_MISMATCH\\] initializing variable
+              found   : number
+              required: string\
+              """,
+              "input0:1:44: WARNING - \\[JSC_USELESS_CODE\\] Suspicious code. This code lacks"
+                  + " side-effects. Is there a bug?",
+            });
+    assertThat(actualErrors).isEmpty();
+  }
+
+  @Test
+  public void testExpectedDiagnostics_partialMatch() {
+    args.add("--jscomp_error=checkTypes");
+    ImmutableList<JSError> actualErrors =
+        testExpectedDiagnostics(
+            "/** @type {string} */ var x = 1;", new String[] {"JSC_TYPE_MISMATCH"});
+    assertThat(actualErrors).isEmpty();
+  }
+
+  @Test
+  public void testExpectedDiagnostics_regexMatch() {
+    args.add("--jscomp_error=checkTypes");
+    ImmutableList<JSError> actualErrors =
+        testExpectedDiagnostics(
+            "/** @type {string} */ var x = 1;",
+            new String[] {"input0:.* ERROR - \\[JSC_TYPE_MISMATCH\\] .*"});
+    assertThat(actualErrors).isEmpty();
+  }
+
+  @Test
+  public void testExpectedDiagnostics_unmatchedExpectation() {
+    args.add("--jscomp_error=checkTypes");
+    ImmutableList<JSError> actualErrors =
+        testExpectedDiagnostics(
+            "/** @type {string} */ var x = 1;", new String[] {".*JSC_OTHER_ERROR.*"});
+    assertThat(actualErrors).hasSize(2);
+    assertError(actualErrors.get(0))
+        .hasType(AbstractCommandLineRunner.EXPECTED_DIAGNOSTIC_NOT_FOUND);
+    assertError(actualErrors.get(0))
+        .hasMessage("Expected diagnostic not found: .*JSC_OTHER_ERROR.*");
+    assertError(actualErrors.get(1)).hasType(TypeValidator.TYPE_MISMATCH_WARNING);
+  }
+
+  @Test
+  public void testExpectedDiagnostics_ambiguousMatch() {
+    args.add("--jscomp_error=checkTypes");
+    ImmutableList<JSError> actualErrors =
+        testExpectedDiagnostics(
+            "/** @type {string} */ var x = 1;",
+            new String[] {".*JSC_TYPE_MISMATCH.*", ".*initializing variable.*"});
+    assertThat(actualErrors).hasSize(1);
+    assertError(actualErrors.get(0)).hasType(AbstractCommandLineRunner.AMBIGUOUS_EXPECTATION);
+    assertError(actualErrors.get(0))
+        .hasMessage(
+            "Multiple expected diagnostics matched the error: \"input0:1:30: ERROR -"
+                + " [JSC_TYPE_MISMATCH] initializing variable\n"
+                + "found   : number\n"
+                + "required: string\n"
+                + "\". Matches: \".*JSC_TYPE_MISMATCH.*\"");
+  }
+
+  @Test
+  public void testExpectedDiagnostics_identicalExpectations() {
+    args.add("--jscomp_error=checkTypes");
+    ImmutableList<JSError> actualErrors =
+        testExpectedDiagnostics(
+            "/** @type {string} */ var x = 1; /** @type {number} */ var y = 'a';",
+            new String[] {".*JSC_TYPE_MISMATCH.*", ".*JSC_TYPE_MISMATCH.*"});
+    assertThat(actualErrors).isEmpty();
+  }
+
+  @Test
+  public void testExpectedDiagnostics_singleRegexMultipleActuals() {
+    args.add("--jscomp_error=checkTypes");
+
+    ImmutableList<JSError> actualErrors =
+        testExpectedDiagnostics(
+            "/** @type {string} */ var x = 1; /** @type {number} */ var y = 'a';",
+            new String[] {".*JSC_TYPE_MISMATCH.*"});
+    assertThat(actualErrors).hasSize(1);
+    assertError(actualErrors.get(0)).hasType(TypeValidator.TYPE_MISMATCH_WARNING);
+    assertError(actualErrors.get(0))
+        .hasMessage("initializing variable\nfound   : string\nrequired: number");
+  }
+
   /* Helper functions */
 
   private void testSame(String original) {
@@ -3714,6 +3809,7 @@ private void test(String[] original, DiagnosticType warning) {
     }
   }
 
+
   private CommandLineRunner createCommandLineRunner(String[] original) {
     for (int i = 0; i < original.length; i++) {
       args.add("--js");
@@ -3884,6 +3980,24 @@ private Compiler compile(String[] original) {
     return lastCompiler;
   }
 
+  @CanIgnoreReturnValue
+  private ImmutableList<JSError> testExpectedDiagnostics(
+      String input, String[] expectedDiagnostics) {
+    for (String diag : expectedDiagnostics) {
+      args.add("--expected_diagnostics=" + diag);
+    }
+    compile(new String[] {input});
+
+    Compiler compiler = lastCompiler;
+    ImmutableList<JSError> actualDiagnostics =
+        ImmutableList.<JSError>builder()
+            .addAll(compiler.getErrors())
+            .addAll(compiler.getWarnings())
+            .build();
+
+    return actualDiagnostics;
+  }
+
   private Node parse(String[] original) {
     String[] argStrings = args.toArray(new String[] {});
     CommandLineRunner runner = new CommandLineRunner(argStrings);