[bugfix] fn:matches/analyze-string: raise XPST0017 for XPath 4.0 lookaround

The previous isXQuery40 = context.getXQueryVersion() >= 40 guard was
dead on this XQuery 3.1 branch: getXQueryVersion() never returns 40
here, so a pattern using (*positive_lookahead:...) or similar XPath 4.0
syntax silently fell through to Saxon's XP30 regex compiler and produced
opaque FORX0002 errors.

Replace the guard with an explicit XPST0017 "XPath 4.0 lookaround syntax
is not yet implemented in this XQuery 3.1 build" exception in both
FunMatches.matchXmlRegex and FunAnalyzeString.analyzeString. The XQ4
translation/dispatch path stays available on v2/xq4-core-functions;
when 4.0 lands on develop, swap the throw for the translateXPath4Lookaround
call in one spot per file.

validateXPathRegex is now called with isXQuery40=false explicitly, since
this branch only runs the 3.1 dialect.

Adds RegexXPath4NotImplementedTest covering both fn:matches and
fn:analyze-string error paths plus a plain-pattern smoke check.

Addresses Juri's review comment on PR eXist-db#6344 (preferred middle ground:
keep the version check, but raise a clear "not implemented yet" error
rather than silently dead-coding the branch).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: joewiz

exist-core/src/main/java/org/exist/xquery/functions/fn/FunAnalyzeString.java

@@ -125,18 +125,21 @@ public Sequence eval(final Sequence[] args, final Sequence contextSequence) thro
         }
     }
 
-    private void analyzeString(final MemTreeBuilder builder, final String input, String pattern, final String flags) throws XPathException {
-        final boolean isXQuery40 = context.getXQueryVersion() >= 40;
+    private void analyzeString(final MemTreeBuilder builder, final String input, final String pattern, final String flags) throws XPathException {
         final Configuration config = context.getBroker().getBrokerPool().getSaxonConfiguration();
 
-        // XQ4: translate (*positive_lookahead:...) etc. to Java regex
-        if (isXQuery40 && org.exist.xquery.regex.RegexUtil.hasXPath4Lookaround(pattern)) {
-            pattern = org.exist.xquery.regex.RegexUtil.translateXPath4Lookaround(pattern);
+        // XPath 4.0 lookaround syntax is not yet implemented in eXist's XQuery 3.1 runtime.
+        // When XQuery 4.0 lands (v2/xq4-core-functions), replace this guard with the
+        // translateXPath4Lookaround() dispatch path.
+        if (org.exist.xquery.regex.RegexUtil.hasXPath4Lookaround(pattern)) {
+            throw new XPathException(this, ErrorCodes.XPST0017,
+                    "XPath 4.0 lookaround syntax in regex patterns (e.g. (*positive_lookahead:...)) "
+                            + "is not yet implemented in this XQuery 3.1 build. Rewrite the regex without lookaround.");
         }
 
-        // Pre-validate: reject constructs not valid in XPath regex
+        // Pre-validate: reject constructs not valid in XPath 3.1 regex
         if (!org.exist.xquery.regex.RegexUtil.hasLiteral(flags)) {
-            org.exist.xquery.regex.RegexUtil.validateXPathRegex(this, pattern, isXQuery40);
+            org.exist.xquery.regex.RegexUtil.validateXPathRegex(this, pattern, false);
         }
 
         final List<String> warnings = new ArrayList<>(1);

exist-core/src/main/java/org/exist/xquery/functions/fn/FunMatches.java

@@ -525,34 +525,20 @@ private Sequence evalGeneric(final Sequence contextSequence, final Item contextI
     }
 
 
-    private boolean matchXmlRegex(String string, String pattern, final String flags) throws XPathException {
-        final boolean isXQuery40 = context.getXQueryVersion() >= 40;
-
-
-        // XQ4: translate (*positive_lookahead:...) etc. to Java regex (?=...) syntax
-        if (isXQuery40 && org.exist.xquery.regex.RegexUtil.hasXPath4Lookaround(pattern)) {
-            pattern = org.exist.xquery.regex.RegexUtil.translateXPath4Lookaround(pattern);
+    private boolean matchXmlRegex(String string, final String pattern, final String flags) throws XPathException {
+        // XPath 4.0 lookaround syntax is not yet implemented in eXist's XQuery 3.1 runtime.
+        // When XQuery 4.0 lands (v2/xq4-core-functions), replace this guard with the
+        // translateXPath4Lookaround / Java-regex dispatch path.
+        if (org.exist.xquery.regex.RegexUtil.hasXPath4Lookaround(pattern)) {
+            throw new XPathException(this, ErrorCodes.XPST0017,
+                    "XPath 4.0 lookaround syntax in regex patterns (e.g. (*positive_lookahead:...)) "
+                            + "is not yet implemented in this XQuery 3.1 build. Rewrite the regex without lookaround.");
         }
 
-        // Pre-validate: reject constructs that are not valid in XPath regex
+        // Pre-validate: reject constructs that are not valid in XPath 3.1 regex
         // but that Saxon's XP30 mode accepts (Java/Perl extensions)
         if (!hasLiteral(flags)) {
-            org.exist.xquery.regex.RegexUtil.validateXPathRegex(this, pattern, isXQuery40);
-        }
-
-        // XQ4: patterns with \b, \B, or lookaround need Java regex since
-        // Saxon's XP30 mode doesn't support these XPath 4.0 extensions
-        if (isXQuery40 && org.exist.xquery.regex.RegexUtil.needsXQuery40JavaRegex(pattern)) {
-            try {
-                final String javaPattern = org.exist.xquery.regex.RegexUtil.translateRegexp(
-                        this, pattern, flags.contains("x"), flags.contains("i"));
-                final int javaFlags = org.exist.xquery.regex.RegexUtil.parseFlags(this, flags);
-                return Pattern.compile(javaPattern, javaFlags).matcher(string).find();
-            } catch (final PatternSyntaxException e) {
-                throw new XPathException(this, ErrorCodes.FORX0002,
-                        "Invalid regular expression: " + e.getMessage(),
-                        new StringValue(this, pattern), e);
-            }
+            org.exist.xquery.regex.RegexUtil.validateXPathRegex(this, pattern, false);
         }
 
         try {

exist-core/src/test/java/org/exist/xquery/functions/fn/RegexXPath4NotImplementedTest.java

@@ -0,0 +1,107 @@
+/*
+ * eXist-db Open Source Native XML Database
+ * Copyright (C) 2001 The eXist-db Authors
+ *
+ * info@exist-db.org
+ * http://www.exist-db.org
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package org.exist.xquery.functions.fn;
+
+import org.exist.source.Source;
+import org.exist.source.StringSource;
+import org.exist.storage.BrokerPool;
+import org.exist.storage.DBBroker;
+import org.exist.test.ExistEmbeddedServer;
+import org.exist.xquery.CompiledXQuery;
+import org.exist.xquery.ErrorCodes;
+import org.exist.xquery.XPathException;
+import org.exist.xquery.XQuery;
+import org.exist.xquery.XQueryContext;
+import org.junit.ClassRule;
+import org.junit.Test;
+
+import java.util.Optional;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * fn:matches and fn:analyze-string raise XPST0017 with a "not yet implemented"
+ * message when an XPath 4.0 lookaround construct (e.g. (*positive_lookahead:...))
+ * appears in the pattern. Previously the XQ4 dispatch branch was silently
+ * inactive on the XQ 3.1 runtime, so such patterns fell through to Saxon and
+ * produced opaque regex errors.
+ */
+public class RegexXPath4NotImplementedTest {
+
+    @ClassRule
+    public static final ExistEmbeddedServer existEmbeddedServer = new ExistEmbeddedServer(true, true);
+
+    @Test
+    public void matchesLookaroundRaisesNotImplemented() {
+        assertNotImplemented("fn:matches('foobar', '(*positive_lookahead:foo)bar')");
+    }
+
+    @Test
+    public void analyzeStringLookaroundRaisesNotImplemented() {
+        assertNotImplemented("fn:analyze-string('foobar', '(*positive_lookahead:foo)bar')");
+    }
+
+    @Test
+    public void matchesPlainPatternStillWorks() throws Exception {
+        assertEquals("true", executeStringValue("fn:matches('foobar', 'foo')"));
+    }
+
+    private void assertNotImplemented(final String query) {
+        try {
+            executeStringValue(query);
+            fail("Expected XPST0017 for XPath 4.0 lookaround");
+        } catch (final Exception e) {
+            final XPathException xpe = unwrap(e);
+            assertNotNull("Expected an XPathException, got: " + e, xpe);
+            assertEquals(ErrorCodes.XPST0017, xpe.getErrorCode());
+            assertTrue("Expected 'not yet implemented' message, got: " + xpe.getMessage(),
+                    xpe.getMessage().contains("not yet implemented"));
+        }
+    }
+
+    private static XPathException unwrap(final Throwable t) {
+        Throwable cur = t;
+        while (cur != null) {
+            if (cur instanceof XPathException xpe) {
+                return xpe;
+            }
+            cur = cur.getCause();
+        }
+        return null;
+    }
+
+    private String executeStringValue(final String query) throws Exception {
+        final Source source = new StringSource(query);
+        final BrokerPool brokerPool = existEmbeddedServer.getBrokerPool();
+        final XQuery xquery = brokerPool.getXQueryService();
+
+        try (final DBBroker broker = brokerPool.get(
+                Optional.of(brokerPool.getSecurityManager().getSystemSubject()))) {
+            final XQueryContext context = new XQueryContext(brokerPool);
+            final CompiledXQuery compiled = xquery.compile(context, source);
+            return xquery.execute(broker, compiled, null).getStringValue();
+        }
+    }
+}