From 09b497291f0f3750717d4b56d513a0736a9c2f08 Mon Sep 17 00:00:00 2001
From: Paul King <paulk@asert.com.au>
Date: Thu, 27 Aug 2026 11:30:17 +1000
Subject: [PATCH 1/5] GROOVY-12306: apply error tolerance to type checking and
 visitor errors

The configured error tolerance was only enforced for errors reported through
SourceUnit#addError. Errors reported through ClassCodeVisitorSupport#addError
went straight to ErrorCollector#addErrorAndContinue and so were unbounded,
which meant `groovyc -t 1` had no effect on the most common error class in
@CompileStatic code: type checking errors reported in full however low the
tolerance was set.

Route the base ClassCodeVisitorSupport#addError through the tolerance-aware
ErrorCollector#addError. StaticTypeCheckingVisitor overrides addError for
its own error de-duplication and needs the same treatment, but only for the
source unit's own collector: the temporary collectors it pushes for
speculative checks must continue to collect without bailing out, since their
errors are routinely discarded once a candidate is ruled in or out.

ClassCompletionVerifierTest counts every error the verifier reports, so it
now asks for the unlimited tolerance it always relied on rather than the
fail-fast tolerance of 1 that SourceUnit#create(String,String) selects.

Assisted-by: Claude Opus 5 (1M context) via Claude Code
---
 .../groovy/ast/ClassCodeVisitorSupport.java   |  11 +-
 .../stc/StaticTypeCheckingVisitor.java        |  14 ++-
 .../classgen/ClassCompletionVerifierTest.java |   4 +-
 .../groovy/control/ErrorToleranceTest.groovy  | 108 ++++++++++++++++++
 4 files changed, 134 insertions(+), 3 deletions(-)
 create mode 100644 src/test/groovy/org/codehaus/groovy/control/ErrorToleranceTest.groovy

diff --git a/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java b/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java
index 82c0ccdde4a..7b17bec9318 100644
--- a/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java
+++ b/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java
@@ -40,6 +40,7 @@
 import org.codehaus.groovy.ast.stmt.WhileStatement;
 import org.codehaus.groovy.ast.stmt.YieldStatement;
 import org.codehaus.groovy.control.SourceUnit;
+import org.codehaus.groovy.control.messages.Message;
 import org.codehaus.groovy.syntax.SyntaxException;
 import org.codehaus.groovy.transform.ErrorCollecting;
 
@@ -495,6 +496,12 @@ protected void visitStatementAnnotations(Statement statement) {
     /**
      * Adds an error message associated with an AST node to the source unit.
      * Errors are accumulated and reported after visitation completes.
+     * <p>
+     * The error counts towards the configured
+     * {@link org.codehaus.groovy.control.CompilerConfiguration#getTolerance() error tolerance},
+     * so visitation may be cut short once that many errors have been collected (GROOVY-12306).
+     * Use {@link org.codehaus.groovy.control.ErrorCollector#addErrorAndContinue(Message)}
+     * directly to report an error which must never bail out.
      *
      * @param error the error message to report
      * @param node the AST node associated with the error location
@@ -502,6 +509,8 @@ protected void visitStatementAnnotations(Statement statement) {
      */
     @Override
     public void addError(final String error, final ASTNode node) {
-        getSourceUnit().addErrorAndContinue(new SyntaxException(error + '\n', node));
+        SourceUnit source = getSourceUnit();
+        source.getErrorCollector().addError(
+                Message.create(new SyntaxException(error + '\n', node), source));
     }
 }
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
index ac48070d093..6bbfd265d66 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
@@ -117,8 +117,10 @@
 import org.codehaus.groovy.control.ErrorCollector;
 import org.codehaus.groovy.control.ResolveVisitor;
 import org.codehaus.groovy.control.SourceUnit;
+import org.codehaus.groovy.control.messages.Message;
 import org.codehaus.groovy.control.messages.WarningMessage;
 import org.codehaus.groovy.runtime.DefaultGroovyMethods;
+import org.codehaus.groovy.syntax.SyntaxException;
 import org.codehaus.groovy.syntax.Token;
 import org.codehaus.groovy.syntax.TokenUtil;
 import org.codehaus.groovy.transform.RecordTypeASTTransformation;
@@ -7123,7 +7125,17 @@ private static SetterInfo removeSetterInfo(final Expression exp) {
     public void addError(final String msg, final ASTNode node) {
         Long err = ((long) node.getLineNumber()) << 16 + node.getColumnNumber();
         if ((DEBUG_GENERATED_CODE && node.getLineNumber() < 0) || !typeCheckingContext.reportedErrors.contains(err)) {
-            typeCheckingContext.getErrorCollector().addErrorAndContinue(msg + '\n', node, getSourceUnit());
+            SourceUnit source = getSourceUnit();
+            ErrorCollector collector = typeCheckingContext.getErrorCollector();
+            Message message = Message.create(new SyntaxException(msg + '\n', node), source);
+            // GROOVY-12306: only the source unit's own collector enforces the error tolerance.
+            // The temporary collectors pushed for speculative checks must never bail out, as
+            // their errors are routinely discarded once a candidate is ruled in or out.
+            if (collector == source.getErrorCollector()) {
+                collector.addError(message);
+            } else {
+                collector.addErrorAndContinue(message);
+            }
             typeCheckingContext.reportedErrors.add(err);
         }
     }
diff --git a/src/test/groovy/org/codehaus/groovy/classgen/ClassCompletionVerifierTest.java b/src/test/groovy/org/codehaus/groovy/classgen/ClassCompletionVerifierTest.java
index 989c726736e..d17a30a5249 100644
--- a/src/test/groovy/org/codehaus/groovy/classgen/ClassCompletionVerifierTest.java
+++ b/src/test/groovy/org/codehaus/groovy/classgen/ClassCompletionVerifierTest.java
@@ -48,7 +48,9 @@
 
 final class ClassCompletionVerifierTest {
 
-    private final SourceUnit sourceUnit = SourceUnit.create("dummy.groovy", "");
+    // GROOVY-12306: these tests collect and count every error the verifier reports, so they need
+    // unlimited tolerance; the two-argument SourceUnit.create factory asks for fail-fast (1)
+    private final SourceUnit sourceUnit = SourceUnit.create("dummy.groovy", "", 0);
     private final ClassCompletionVerifier verifier = new ClassCompletionVerifier(sourceUnit);
 
     @Test
diff --git a/src/test/groovy/org/codehaus/groovy/control/ErrorToleranceTest.groovy b/src/test/groovy/org/codehaus/groovy/control/ErrorToleranceTest.groovy
new file mode 100644
index 00000000000..ceb0cde9ac4
--- /dev/null
+++ b/src/test/groovy/org/codehaus/groovy/control/ErrorToleranceTest.groovy
@@ -0,0 +1,108 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 org.codehaus.groovy.control
+
+import org.junit.jupiter.api.Test
+
+import static org.junit.jupiter.api.Assertions.assertEquals
+
+/**
+ * Tests {@link CompilerConfiguration#setTolerance(int)}, the number of non-fatal
+ * errors collected before compilation is abandoned.
+ */
+final class ErrorToleranceTest {
+
+    private static final int MANY = 14
+
+    /**
+     * Static type-checking errors, one per method. These are raised via
+     * {@code StaticTypeCheckingVisitor#addError}, which overrides the base
+     * {@code ClassCodeVisitorSupport} reporting used below.
+     */
+    private static String typeCheckingErrors(int count) {
+        def methods = (0..<count).collect { "    def m$it() { new Object().nope$it() }" }
+        "@groovy.transform.CompileStatic\nclass Subject {\n${methods.join('\n')}\n}\n"
+    }
+
+    /**
+     * Class resolution errors, one per field. These are raised by {@link ResolveVisitor}
+     * via {@code ClassCodeVisitorSupport#addError}, a different reporting path and a
+     * different compile phase to the type-checking errors above.
+     */
+    private static String resolutionErrors(int count) {
+        def fields = (0..<count).collect { "    NoSuchType$it field$it" }
+        "class Subject {\n${fields.join('\n')}\n}\n"
+    }
+
+    private static int errorCount(String source, Integer tolerance = null) {
+        def config = new CompilerConfiguration()
+        if (tolerance != null) config.tolerance = tolerance
+        def unit = new CompilationUnit(config, null, new GroovyClassLoader(ErrorToleranceTest.class.classLoader))
+        unit.addSource('Subject.groovy', source)
+        try {
+            unit.compile()
+            0
+        } catch (MultipleCompilationErrorsException e) {
+            e.errorCollector.errorCount
+        }
+    }
+
+    // GROOVY-12306: tolerance was ignored for type-checking errors, which reported in full
+    // however low it was set, so there was no way to ask the compiler to stop after the first
+    @Test
+    void testTypeCheckingErrorsHonourTolerance() {
+        assertEquals(1, errorCount(typeCheckingErrors(MANY), 1))
+        assertEquals(3, errorCount(typeCheckingErrors(MANY), 3))
+    }
+
+    // the same must hold for errors reported through the base ClassCodeVisitorSupport path
+    @Test
+    void testResolutionErrorsHonourTolerance() {
+        assertEquals(1, errorCount(resolutionErrors(MANY), 1))
+        assertEquals(3, errorCount(resolutionErrors(MANY), 3))
+    }
+
+    // GROOVY-12306: zero means unlimited, the setting to reach for when every error is wanted
+    @Test
+    void testZeroToleranceMeansUnlimited() {
+        assertEquals(MANY, errorCount(typeCheckingErrors(MANY), 0))
+        assertEquals(MANY, errorCount(resolutionErrors(MANY), 0))
+    }
+
+    // a negative tolerance is meaningless as a count, so it is treated as unlimited too
+    @Test
+    void testNegativeToleranceMeansUnlimited() {
+        assertEquals(MANY, errorCount(typeCheckingErrors(MANY), -1))
+    }
+
+    // the default is unchanged by GROOVY-12306, and now applies to both kinds of error
+    @Test
+    void testDefaultToleranceAppliesToBothErrorKinds() {
+        assertEquals(CompilerConfiguration.DEFAULT_TOLERANCE, new CompilerConfiguration().tolerance)
+        assertEquals(CompilerConfiguration.DEFAULT_TOLERANCE, errorCount(typeCheckingErrors(MANY)))
+        assertEquals(CompilerConfiguration.DEFAULT_TOLERANCE, errorCount(resolutionErrors(MANY)))
+    }
+
+    // fewer errors than the tolerance are all reported, whichever path raised them
+    @Test
+    void testAllErrorsReportedBelowTolerance() {
+        assertEquals(3, errorCount(typeCheckingErrors(3), 10))
+        assertEquals(3, errorCount(resolutionErrors(3), 10))
+    }
+}

From e865c87d1306dc89a15b88c9d46f5ffbdb6da3bb Mon Sep 17 00:00:00 2001
From: Paul King <paulk@asert.com.au>
Date: Thu, 27 Aug 2026 11:30:25 +1000
Subject: [PATCH 2/5] GROOVY-12306: treat a tolerance of zero as unlimited

There was no way to ask the compiler to report every error. `groovyc -t 0`
was silently discarded, because CompilationOptions could not tell a supplied
zero from the option being absent, leaving the default of 10 in place; and
even when set, a tolerance of zero would have bailed out on the first error
rather than collecting them all.

Treat a tolerance of zero or less as unlimited in ErrorCollector, and hold
the command-line option in a boxed Integer so that an explicit zero reaches
the configuration. Name the default as CompilerConfiguration.DEFAULT_TOLERANCE
rather than repeating the literal, and state it in the option help, which
previously gave no hint that the option was bounded by default.

The option itself has been undocumented since it was added in GROOVY-11194,
so add it to the groovyc option table too.

Assisted-by: Claude Opus 5 (1M context) via Claude Code
---
 .../groovy/control/CompilerConfiguration.java | 24 +++++++++++++++----
 .../groovy/control/ErrorCollector.java        |  6 ++++-
 .../groovy/tools/FileSystemCompiler.java      |  7 +++---
 src/spec/doc/tools-groovyc.adoc               |  1 +
 .../groovy/tools/FileSystemCompilerTest.java  | 18 ++++++++++++++
 5 files changed, 47 insertions(+), 9 deletions(-)

diff --git a/src/main/java/org/codehaus/groovy/control/CompilerConfiguration.java b/src/main/java/org/codehaus/groovy/control/CompilerConfiguration.java
index 31f89f89303..ca8977e671b 100644
--- a/src/main/java/org/codehaus/groovy/control/CompilerConfiguration.java
+++ b/src/main/java/org/codehaus/groovy/control/CompilerConfiguration.java
@@ -188,6 +188,14 @@ public class CompilerConfiguration {
      */
     public static final String DEFAULT_SOURCE_ENCODING = "UTF-8";
 
+    /**
+     * The default number of non-fatal errors tolerated before compilation is aborted.
+     *
+     * @see #setTolerance(int)
+     * @since 6.0.0
+     */
+    public static final int DEFAULT_TOLERANCE = 10;
+
     /**
      *  A convenience for getting a default configuration.  Do not modify it!
      *  See {@link #CompilerConfiguration(Properties)} for an example on how to
@@ -561,7 +569,7 @@ public void setLogClassgenStackTraceMaxDepth(int logClassgenStackTraceMaxDepth)
     public CompilerConfiguration() {
         classpath = new LinkedList<>();
 
-        tolerance = 10;
+        tolerance = DEFAULT_TOLERANCE;
         minimumRecompilationInterval = 100;
         warningLevel = WarningMessage.LIKELY_ERRORS;
         parameters = getBooleanSafe("groovy.parameters");
@@ -935,8 +943,8 @@ public void configure(final Properties configuration) throws ConfigurationExcept
         text = configuration.getProperty("groovy.output.debug");
         if (text != null) setDebug("true".equalsIgnoreCase(text));
 
-        numeric = 10;
-        text = configuration.getProperty("groovy.errors.tolerance", "10");
+        numeric = DEFAULT_TOLERANCE;
+        text = configuration.getProperty("groovy.errors.tolerance", Integer.toString(DEFAULT_TOLERANCE));
         try {
             numeric = Integer.parseInt(text);
         } catch (NumberFormatException e) {
@@ -1122,7 +1130,9 @@ public void setParameters(final boolean parameters) {
     }
 
     /**
-     * Returns the requested error tolerance.
+     * Returns the requested error tolerance. Zero or less means unlimited.
+     *
+     * @see #setTolerance(int)
      */
     public int getTolerance() {
         return this.tolerance;
@@ -1131,7 +1141,11 @@ public int getTolerance() {
     /**
      * Sets the error tolerance, which is the number of
      * non-fatal errors (per unit) that should be tolerated before
-     * compilation is aborted.
+     * compilation is aborted. Defaults to {@value #DEFAULT_TOLERANCE}.
+     * <p>
+     * A value of zero or less means unlimited: every error is collected and
+     * reported, and compilation is never cut short by the error count alone
+     * (GROOVY-12306).
      */
     public void setTolerance(final int tolerance) {
         this.tolerance = tolerance;
diff --git a/src/main/java/org/codehaus/groovy/control/ErrorCollector.java b/src/main/java/org/codehaus/groovy/control/ErrorCollector.java
index 8229da6cdf1..74e74162af1 100644
--- a/src/main/java/org/codehaus/groovy/control/ErrorCollector.java
+++ b/src/main/java/org/codehaus/groovy/control/ErrorCollector.java
@@ -122,11 +122,15 @@ public void addErrorAndContinue(final Message message) {
      * Adds a non-fatal error to the message set, which may cause a failure if the error threshold is exceeded.
      * The message is not required to have a source line and column specified, but it is best practice to try
      * and include that information.
+     * <p>
+     * A {@link CompilerConfiguration#getTolerance() tolerance} of zero or less means unlimited:
+     * every error is collected and the threshold never triggers a failure (GROOVY-12306).
      */
     public void addError(final Message message) throws CompilationFailedException {
         addErrorAndContinue(message);
 
-        if (errors != null && errors.size() >= configuration.getTolerance()) {
+        int tolerance = configuration.getTolerance();
+        if (tolerance > 0 && errors != null && errors.size() >= tolerance) {
             failIfErrors();
         }
     }
diff --git a/src/main/java/org/codehaus/groovy/tools/FileSystemCompiler.java b/src/main/java/org/codehaus/groovy/tools/FileSystemCompiler.java
index ba6da860a15..161e3459a7d 100644
--- a/src/main/java/org/codehaus/groovy/tools/FileSystemCompiler.java
+++ b/src/main/java/org/codehaus/groovy/tools/FileSystemCompiler.java
@@ -538,8 +538,9 @@ public static class CompilationOptions {
         @Option(names = {"-cf", "--configscript"}, paramLabel = "<script>", description = "A script for tweaking the configuration options")
         private String configScript;
 
-        @Option(names = {"-t", "--tolerance"}, description = "The number of non-fatal errors to allow before bailing")
-        private int tolerance;
+        @Option(names = {"-t", "--tolerance"}, paramLabel = "<count>",
+                description = "The number of non-fatal errors to allow before bailing (default: 10; 0 for unlimited)")
+        private Integer tolerance;
 
         @Option(names = {"-h", "--help"}, usageHelp = true, description = "Show this help message and exit")
         private boolean helpRequested;
@@ -585,7 +586,7 @@ public CompilerConfiguration toCompilerConfiguration() throws IOException {
             if (checkOnly) {
                 configuration.setTargetPhase(Phases.INSTRUCTION_SELECTION);
             }
-            if (tolerance > 0) {
+            if (tolerance != null) {
                 configuration.setTolerance(tolerance);
             }
 
diff --git a/src/spec/doc/tools-groovyc.adoc b/src/spec/doc/tools-groovyc.adoc
index d47d22f6f75..95db0ba797a 100644
--- a/src/spec/doc/tools-groovyc.adoc
+++ b/src/spec/doc/tools-groovyc.adoc
@@ -53,6 +53,7 @@ a number of command line switches:
 | -j | --jointCompilation* | Enables joint compilation | groovyc -j A.groovy B.java
 | -b | --basescript | Base class name for scripts (must derive from Script)|
 | | --configscript | Advanced compiler configuration script | groovyc --configscript config/config.groovy src/Person.groovy
+| -t | --tolerance | The number of non-fatal errors to collect before compilation is abandoned. Defaults to `10`; use `0` for unlimited. | groovyc -t 0 Person.groovy
 | -Jproperty=value | | Properties to be passed to `javac` if joint compilation is enabled | groovyc -j -Jtarget=1.6 -Jsource=1.6 A.groovy B.java
 | -Fflag | | Flags to be passed to `javac` if joint compilation is enabled | groovyc -j -Fnowarn A.groovy B.java
 | -pa | --parameters | Generates metadata for reflection on method parameter names. Requires Java 8+. | groovyc --parameters Person.groovy
diff --git a/src/test/groovy/org/codehaus/groovy/tools/FileSystemCompilerTest.java b/src/test/groovy/org/codehaus/groovy/tools/FileSystemCompilerTest.java
index 02195b0350a..3c6185ff640 100644
--- a/src/test/groovy/org/codehaus/groovy/tools/FileSystemCompilerTest.java
+++ b/src/test/groovy/org/codehaus/groovy/tools/FileSystemCompilerTest.java
@@ -43,6 +43,7 @@
 import java.util.List;
 import java.util.Map;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -212,6 +213,23 @@ public void testCheckCommandLineOption(@TempDir Path dir) throws Exception {
         assertTrue(Files.exists(dir.resolve("CliCheckDemo.class")), "sanity: without --check the class file is written");
     }
 
+    // GROOVY-12306: -t 0 asks for unlimited error reporting; it used to be discarded as
+    // indistinguishable from the option being absent, silently leaving the default in place
+    @Test
+    public void testToleranceCommandLineOption() throws Exception {
+        assertEquals(CompilerConfiguration.DEFAULT_TOLERANCE, parseTolerance(),
+                "an absent -t must leave the compiler default in place");
+        assertEquals(0, parseTolerance("-t", "0"));
+        assertEquals(0, parseTolerance("--tolerance", "0"));
+        assertEquals(3, parseTolerance("-t", "3"));
+    }
+
+    private static int parseTolerance(String... args) throws Exception {
+        FileSystemCompiler.CompilationOptions options = new FileSystemCompiler.CompilationOptions();
+        FileSystemCompiler.configureParser(options).parseArgs(args);
+        return options.toCompilerConfiguration().getTolerance();
+    }
+
     @Test
     public void testDeleteRecursiveDoesNotFollowSymlink() throws Exception {
         File base = Files.createTempDirectory("deleteRecursiveSymlink").toFile();

From ff20545cfeb1df4c17c0d0cc91289f5cc1447994 Mon Sep 17 00:00:00 2001
From: Paul King <paulk@asert.com.au>
Date: Thu, 27 Aug 2026 11:30:30 +1000
Subject: [PATCH 3/5] GROOVY-12306: add a tolerance attribute to the groovyc
 Ant task

The error tolerance could be set on the groovyc command line and through the
CompilerConfiguration API, but the <groovyc> Ant task offered no way to reach
it short of a compiler configuration script.

Add a tolerance attribute. Both the forked and in-process paths run the same
assembled argument list through the FileSystemCompiler parser, so emitting
the option once covers both. An unset attribute emits nothing and leaves the
compiler default in place, while an explicit zero is passed through as the
request for unlimited error reporting that it is.

Assisted-by: Claude Opus 5 (1M context) via Claude Code
---
 .../java/org/codehaus/groovy/ant/Groovyc.java | 27 ++++++
 .../src/spec/doc/groovyc-ant-task.adoc        |  3 +
 .../groovy/ant/GroovycToleranceTest.java      | 83 +++++++++++++++++++
 3 files changed, 113 insertions(+)
 create mode 100644 subprojects/groovy-ant/src/test/groovy/org/codehaus/groovy/ant/GroovycToleranceTest.java

diff --git a/subprojects/groovy-ant/src/main/java/org/codehaus/groovy/ant/Groovyc.java b/subprojects/groovy-ant/src/main/java/org/codehaus/groovy/ant/Groovyc.java
index ddb053f9d40..0a281313294 100644
--- a/subprojects/groovy-ant/src/main/java/org/codehaus/groovy/ant/Groovyc.java
+++ b/subprojects/groovy-ant/src/main/java/org/codehaus/groovy/ant/Groovyc.java
@@ -238,6 +238,7 @@ public class Groovyc extends MatchingTask {
     private boolean forceLookupUnnamedFiles;
     private String scriptBaseClass;
     private String configscript;
+    private Integer tolerance;
 
     // GROOVY-11995: forked-mode JVM args / system properties
     private final Commandline jvmArgs = new Commandline();
@@ -828,6 +829,28 @@ public void setConfigscript(final String configscript) {
         this.configscript = configscript;
     }
 
+    /**
+     * Get the number of non-fatal errors tolerated before compilation is aborted.
+     *
+     * @return the error tolerance, or {@code null} to use the compiler default
+     * @since 6.0.0
+     */
+    public Integer getTolerance() {
+        return tolerance;
+    }
+
+    /**
+     * Set the number of non-fatal errors tolerated before compilation is aborted.
+     * Zero means unlimited. When unset, the compiler default of
+     * {@value CompilerConfiguration#DEFAULT_TOLERANCE} applies.
+     *
+     * @param tolerance the error tolerance
+     * @since 6.0.0
+     */
+    public void setTolerance(final int tolerance) {
+        this.tolerance = tolerance;
+    }
+
     /**
      * Set the stub directory into which the Java source stub
      * files should be generated. The directory need not exist
@@ -1318,6 +1341,10 @@ private void doNormalCommandLineList(List<String> commandLineList, List<String>
             commandLineList.add("--configscript");
             commandLineList.add(configscript);
         }
+        if (tolerance != null) {
+            commandLineList.add("-t");
+            commandLineList.add(String.valueOf(tolerance));
+        }
     }
 
     private void addSourceFiles(List<String> commandLineList) {
diff --git a/subprojects/groovy-ant/src/spec/doc/groovyc-ant-task.adoc b/subprojects/groovy-ant/src/spec/doc/groovyc-ant-task.adoc
index 559d970494a..f321ca172e8 100644
--- a/subprojects/groovy-ant/src/spec/doc/groovyc-ant-task.adoc
+++ b/subprojects/groovy-ant/src/spec/doc/groovyc-ant-task.adoc
@@ -129,6 +129,9 @@ you need to set this flag to true. Defaults to false. |No
 
 |configscript |Set the configuration file used to customize the compilation configuration. |No
 
+|tolerance |The number of non-fatal errors to collect before compilation is abandoned.
+Zero means unlimited. Defaults to 10. |No
+
 |parameters |Generates metadata for reflection on method parameter names on JDK 8 and above.
 Defaults to false. |No
 
diff --git a/subprojects/groovy-ant/src/test/groovy/org/codehaus/groovy/ant/GroovycToleranceTest.java b/subprojects/groovy-ant/src/test/groovy/org/codehaus/groovy/ant/GroovycToleranceTest.java
new file mode 100644
index 00000000000..f2f54d4593b
--- /dev/null
+++ b/subprojects/groovy-ant/src/test/groovy/org/codehaus/groovy/ant/GroovycToleranceTest.java
@@ -0,0 +1,83 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 org.codehaus.groovy.ant;
+
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.types.Path;
+import org.codehaus.groovy.control.CompilerConfiguration;
+import org.codehaus.groovy.tools.FileSystemCompiler;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+/**
+ * GROOVY-12306: the {@code tolerance} attribute of the {@code <groovyc>} task must reach the
+ * compiler. Both the forked and in-process paths run the arguments assembled here through the
+ * {@link FileSystemCompiler} parser, so covering the assembled command line covers both.
+ */
+final class GroovycToleranceTest {
+
+    @Test
+    void toleranceIsOmittedWhenTheAttributeIsUnset() throws Exception {
+        assertFalse(commandLineFor(null).contains("-t"), "no tolerance attribute means no -t argument");
+        assertEquals(CompilerConfiguration.DEFAULT_TOLERANCE, toleranceFor(null));
+    }
+
+    @Test
+    void toleranceAttributeReachesTheCompilerConfiguration() throws Exception {
+        assertEquals(5, toleranceFor(5));
+        assertEquals(1, toleranceFor(1));
+    }
+
+    // zero is meaningful rather than absent: it asks for unlimited error reporting
+    @Test
+    void zeroToleranceIsPassedThroughRatherThanTreatedAsUnset() throws Exception {
+        List<String> commandLine = commandLineFor(0);
+        assertEquals("0", commandLine.get(commandLine.indexOf("-t") + 1));
+        assertEquals(0, toleranceFor(0));
+    }
+
+    private static int toleranceFor(Integer tolerance) throws Exception {
+        List<String> commandLine = commandLineFor(tolerance);
+        FileSystemCompiler.CompilationOptions options = new FileSystemCompiler.CompilationOptions();
+        FileSystemCompiler.configureParser(options).parseArgs(commandLine.toArray(new String[0]));
+        return options.toCompilerConfiguration().getTolerance();
+    }
+
+    private static List<String> commandLineFor(Integer tolerance) throws Exception {
+        Project project = new Project();
+        project.init();
+        Groovyc task = new Groovyc();
+        task.setProject(project);
+        if (tolerance != null) {
+            task.setTolerance(tolerance);
+        }
+        List<String> commandLineList = new ArrayList<>();
+        Method method = Groovyc.class.getDeclaredMethod(
+                "doNormalCommandLineList", List.class, List.class, Path.class);
+        method.setAccessible(true);
+        method.invoke(task, commandLineList, new ArrayList<String>(), new Path(project));
+        return commandLineList;
+    }
+}

From fc4b9356cc6a4f3e260791ad161c433985dd22b0 Mon Sep 17 00:00:00 2001
From: Paul King <paulk@asert.com.au>
Date: Thu, 27 Aug 2026 11:48:36 +1000
Subject: [PATCH 4/5] GROOVY-12306: additional cleanup

---
 .../codehaus/groovy/control/SourceUnit.java   | 43 ++++---------------
 1 file changed, 9 insertions(+), 34 deletions(-)

diff --git a/src/main/java/org/codehaus/groovy/control/SourceUnit.java b/src/main/java/org/codehaus/groovy/control/SourceUnit.java
index fc78c9ad217..b7016f0ad81 100644
--- a/src/main/java/org/codehaus/groovy/control/SourceUnit.java
+++ b/src/main/java/org/codehaus/groovy/control/SourceUnit.java
@@ -133,49 +133,24 @@ public ModuleNode getAST() {
     }
 
     /**
-     * Convenience routine, primarily for use by the InteractiveShell,
-     * that returns true if parse() failed with an unexpected EOF.
+     * Legacy Antlr 2 error reporting method no longer in use.
+     * Similar in intent to {@code getErrorCollector().hasErrors()}, which should be used instead.
+     *
+     * @return true if any error was collected while parsing
+     * @deprecated since 6.0.0, use {@link #getErrorCollector()} and
+     *         {@link ErrorCollector#hasErrors()} instead.
      */
+    @Deprecated(since = "6.0.0")
     public boolean failedWithUnexpectedEOF() {
-        // Implementation note - there are several ways for the Groovy compiler
-        // to report an unexpected EOF. Perhaps this implementation misses some.
-        // If you find another way, please add it.
-        if (getErrorCollector().hasErrors()) {
-            /*
-            Message last = (Message) getErrorCollector().getLastError();
-            Throwable cause = null;
-            if (last instanceof SyntaxErrorMessage) {
-                cause = ((SyntaxErrorMessage) last).getCause().getCause();
-            }
-            if (cause != null) {
-                if (cause instanceof groovyjarjarantlr.NoViableAltException) {
-                    return isEofToken(((groovyjarjarantlr.NoViableAltException) cause).token);
-                } else if (cause instanceof groovyjarjarantlr.NoViableAltForCharException) {
-                    char badChar = ((groovyjarjarantlr.NoViableAltForCharException) cause).foundChar;
-                    return badChar == groovyjarjarantlr.CharScanner.EOF_CHAR;
-                } else if (cause instanceof groovyjarjarantlr.MismatchedCharException) {
-                    char badChar = (char) ((groovyjarjarantlr.MismatchedCharException) cause).foundChar;
-                    return badChar == groovyjarjarantlr.CharScanner.EOF_CHAR;
-                } else if (cause instanceof groovyjarjarantlr.MismatchedTokenException) {
-                    return isEofToken(((groovyjarjarantlr.MismatchedTokenException) cause).token);
-                }
-            }
-            */
-            return true;
-        }
-        return false;
+        return getErrorCollector().hasErrors();
     }
 
-    /*protected boolean isEofToken(groovyjarjarantlr.Token token) {
-        return token.getType() == groovyjarjarantlr.Token.EOF_TYPE;
-    }*/
-
     //---------------------------------------------------------------------------
     // FACTORIES
 
     /**
      * A convenience routine to create a standalone SourceUnit on a String
-     * with defaults for almost everything that is configurable.
+     * with defaults for almost everything that is configurable but with tolerance set to 1.
      */
     public static SourceUnit create(String name, String source) {
         CompilerConfiguration configuration = new CompilerConfiguration();

From 109fa297c89c0de5e757808b337da40f8874fffd Mon Sep 17 00:00:00 2001
From: Paul King <paulk@asert.com.au>
Date: Thu, 27 Aug 2026 12:49:02 +1000
Subject: [PATCH 5/5] GROOVY-12306: compatibility note

---
 COMPATIBILITY.md | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/COMPATIBILITY.md b/COMPATIBILITY.md
index b9905a42381..616d19e054a 100644
--- a/COMPATIBILITY.md
+++ b/COMPATIBILITY.md
@@ -368,6 +368,52 @@ compilation but does not exempt the method from an enclosing class's
 `@TypeChecked` checking; only `@TypeChecked(TypeCheckingMode.SKIP)`
 does that.
 
+### Groovy 6 — error tolerance applies to type checking errors (GROOVY-12306)
+
+The compiler's error tolerance — the number of non-fatal errors collected
+before compilation is abandoned, `CompilerConfiguration.getTolerance()`,
+`groovyc -t` — is now enforced for every error kind. It previously covered
+only errors reported through `SourceUnit#addError` (parse and class
+generation); errors reported through `ClassCodeVisitorSupport#addError`,
+which includes all static type checking errors, went straight to
+`ErrorCollector#addErrorAndContinue` and were unbounded.
+
+The default is unchanged at 10 (now named
+`CompilerConfiguration.DEFAULT_TOLERANCE`). A tolerance of zero or less
+now means unlimited, which is the setting to reach for when every error
+is wanted; previously zero was indistinguishable from the option being
+absent on the command line, and would have bailed out on the first error
+if set through the API.
+
+**Who is affected.** Any compilation reporting more than the tolerance in
+type checking errors. Where 40 such errors were previously all reported,
+10 are now reported and compilation stops. Pass `-t 0` on the groovyc
+command line, set `tolerance="0"` on the Ant `<groovyc>` task, or set
+`configuration.tolerance = 0` in a compiler configuration script (the
+route Gradle users have, via `groovyOptions.configurationScript`) to
+restore full reporting.
+
+This is not limited to the compiler front ends: it applies to any caller
+driving a `ClassCodeVisitorSupport` subclass over a `SourceUnit` and
+counting the errors it collects — static analysers, IDE integrations and
+AST transformation test harnesses among them. Note in particular that
+`SourceUnit.create(String, String)` selects a tolerance of **1**, so a
+visitor driven over a source unit from that factory now stops at the
+first error. Use the three-argument overload to state the tolerance the
+caller actually wants.
+
+**What is unchanged.** The default of 10, so parse and class generation
+errors behave exactly as before. The temporary error collectors that
+`StaticTypeCheckingVisitor` pushes for speculative checks are also
+unaffected — they must keep collecting without bailing out, because their
+errors are routinely discarded once a candidate is ruled in or out, so
+tolerance is enforced only against the source unit's own collector.
+
+Completeness remains per-phase, as it always has been: `failIfErrors()`
+runs at the end of each phase, so a single type checking error anywhere
+in the compilation still suppresses every class generation error,
+whatever the tolerance.
+
 ## The binary-compatibility check
 
 The [`subprojects/binary-compatibility/`](subprojects/binary-compatibility)