Preserve Pattern flags when used in conditions (#2304)

With this PR, we no longer lose pattern flags when using them with
strict and lenient collection matches.

This fixes #2298 and keeps the original behavior of Groovy's `==~` and
`=~` operators intact by calling Groovy's original logic.

Author: beatbrot

docs/release_notes.adoc

@@ -6,6 +6,10 @@ include::include.adoc[]
 
 == 2.5 (tbd)
 
+=== Misc
+
+* Fix Pattern flags being dropped when `java.util.regex.Pattern` instances are used in Spock regex conditions spockIssue:2298[]
+
 == 2.4 (2025-12-11)
 
 _This is a summary of the highlights of the milestone releases_

spock-core/src/main/java/org/spockframework/runtime/SpockRuntime.java

@@ -18,15 +18,14 @@
 import groovy.lang.Closure;
 import groovy.lang.DelegatesTo;
 import groovy.transform.stc.ClosureParams;
-import groovy.transform.stc.FirstParam;
 import groovy.transform.stc.FromString;
+import org.codehaus.groovy.runtime.InvokerHelper;
 import org.hamcrest.CoreMatchers;
 import org.hamcrest.Matcher;
 import org.hamcrest.collection.IsIterableContainingInAnyOrder;
 import org.opentest4j.MultipleFailuresError;
 import spock.lang.Specification;
 
-import org.spockframework.lang.ISpecificationContext;
 import org.spockframework.runtime.extension.IBlockListener;
 import org.spockframework.runtime.model.BlockInfo;
 import org.spockframework.runtime.model.ExpressionInfo;
@@ -39,7 +38,6 @@
 import java.util.*;
 import java.util.function.Consumer;
 import java.util.function.Function;
-import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
 
@@ -154,8 +152,7 @@ public static Object matchCollectionsAsSet(Object left, Object right) {
     } else if ((left == null) || (right == null)) {
       return (left == null) && (right == null);
     } else {
-      Pattern pattern = Pattern.compile(String.valueOf(right));
-      return pattern.matcher(String.valueOf(left));
+      return InvokerHelper.findRegex(left, right);
     }
   }
 
@@ -173,10 +170,7 @@ public static boolean matchCollectionsInAnyOrder(Object left, Object right) {
     } else if ((left == null) || (right == null)) {
       return (left == null) && (right == null);
     } else {
-      Pattern pattern = Pattern.compile(String.valueOf(right));
-      java.util.regex.Matcher matcher = pattern.matcher(String.valueOf(left));
-
-      return matcher.matches();
+      return InvokerHelper.matchRegex(left, right);
     }
   }
 
@@ -392,8 +386,7 @@ void verify(ErrorCollector errorCollector, @Nullable List<Object> values, @Nulla
         }
         values.set(3, false);
       } else {
-        Pattern pattern = Pattern.compile(String.valueOf(right));
-        java.util.regex.Matcher matcher = pattern.matcher(String.valueOf(left));
+        java.util.regex.Matcher matcher = InvokerHelper.findRegex(left, right);
 
         values.set(idxActual, left);
         values.set(idxExpected, right);

spock-specs/src/test/groovy/org/spockframework/smoke/condition/ConditionEvaluation.groovy

@@ -24,6 +24,9 @@ import spock.lang.Issue
 import spock.lang.Snapshot
 import spock.lang.Snapshotter
 
+import java.util.regex.Matcher
+import java.util.regex.Pattern
+
 import static java.lang.Integer.MAX_VALUE
 import static java.lang.Math.max
 import static java.lang.Math.min
@@ -443,6 +446,29 @@ class ConditionEvaluation extends EmbeddedSpecification {
     a =~ b
   }
 
+  @Issue("https://github.com/spockframework/spock/issues/2298")
+  def "Groovy regex conditions still work"() {
+    given:
+    def patternWithFlags = Pattern.compile(/[abc]oo/, Pattern.CASE_INSENSITIVE)
+    def patternWithInlineFlags = ~/(?i)[abc]oo/
+    def patternWithPartialMatchAndFlags = Pattern.compile(/[abc]o/, Pattern.CASE_INSENSITIVE)
+    def patternWithPartialMatchAndInlineFlags = ~/(?i)[abc]o/
+
+    expect: "The strict collection match still works as regex match"
+    "BOO" ==~ patternWithFlags
+    "BOO" ==~ patternWithInlineFlags
+
+    and: "The lenient collection match still builds a matcher"
+    ("boo" =~ patternWithPartialMatchAndFlags) instanceof Matcher
+    ("boo" =~ patternWithPartialMatchAndInlineFlags) instanceof Matcher
+    ("BOO" =~ /[ABC]o/) instanceof Matcher
+
+    and: "Groovy truth applies to the returned matcher"
+    "boo" =~ patternWithPartialMatchAndFlags
+    "boo" =~ patternWithPartialMatchAndInlineFlags
+    "BOO" =~ /[ABC]O/
+  }
+
   @FailsWith(ConditionFailedWithExceptionError)
   def "regular implicit condition"() {
     expect: