Implement XQuery 4.0 parser with version gating and feature flag

exist-core/src/main/java/org/exist/xquery/CastExpression.java

@@ -84,13 +84,15 @@ public Sequence eval(final Sequence contextSequence, final Item contextItem) thr
             }
         }
 
-        // Should be handled by the parser
-        if (requiredType == Type.ANY_ATOMIC_TYPE || (requiredType == Type.NOTATION && expression.returnsType() != Type.NOTATION)) {
+        // XPST0080: cannot cast to abstract or special types
+        if (requiredType == Type.ANY_ATOMIC_TYPE || requiredType == Type.ANY_SIMPLE_TYPE
+                || requiredType == Type.ANY_TYPE || requiredType == Type.UNTYPED
+                || (requiredType == Type.NOTATION && expression.returnsType() != Type.NOTATION)) {
             throw new XPathException(this, ErrorCodes.XPST0080, "cannot cast to " + Type.getTypeName(requiredType));
         }
 
-        if (requiredType == Type.ANY_SIMPLE_TYPE || expression.returnsType() == Type.ANY_SIMPLE_TYPE || requiredType == Type.UNTYPED || expression.returnsType() == Type.UNTYPED) {
-            throw new XPathException(this, ErrorCodes.XPST0051, "cannot cast to " + Type.getTypeName(requiredType));
+        if (expression.returnsType() == Type.ANY_SIMPLE_TYPE || expression.returnsType() == Type.UNTYPED) {
+            throw new XPathException(this, ErrorCodes.XPST0051, "cannot cast from " + Type.getTypeName(expression.returnsType()));
         }
 
         final Sequence result;

exist-core/src/main/java/org/exist/xquery/CastableExpression.java

@@ -93,11 +93,13 @@ public Sequence eval(Sequence contextSequence, Item contextItem) throws XPathExc
                 {context.getProfiler().message(this, Profiler.START_SEQUENCES, "CONTEXT ITEM", contextItem.toSequence());}
         }
 
-        if (requiredType == Type.ANY_ATOMIC_TYPE || (requiredType == Type.NOTATION && expression.returnsType() != Type.NOTATION))
+        if (requiredType == Type.ANY_ATOMIC_TYPE || requiredType == Type.ANY_SIMPLE_TYPE
+                || requiredType == Type.ANY_TYPE || requiredType == Type.UNTYPED
+                || (requiredType == Type.NOTATION && expression.returnsType() != Type.NOTATION))
             {throw new XPathException(this, ErrorCodes.XPST0080, "cannot convert to " + Type.getTypeName(requiredType));}
 
-        if (requiredType == Type.ANY_SIMPLE_TYPE || expression.returnsType() == Type.ANY_SIMPLE_TYPE || requiredType == Type.UNTYPED || expression.returnsType() == Type.UNTYPED)
-            {throw new XPathException(this, ErrorCodes.XPST0051, "cannot convert to " + Type.getTypeName(requiredType));}
+        if (expression.returnsType() == Type.ANY_SIMPLE_TYPE || expression.returnsType() == Type.UNTYPED)
+            {throw new XPathException(this, ErrorCodes.XPST0051, "cannot convert from " + Type.getTypeName(expression.returnsType()));}
 
         Sequence result;
         //See : http://article.gmane.org/gmane.text.xml.xquery.general/1413

exist-core/src/main/java/org/exist/xquery/ChoiceCastExpression.java

@@ -0,0 +1,137 @@
+/*
+ * 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;
+
+import org.exist.dom.persistent.DocumentSet;
+import org.exist.xquery.util.ExpressionDumper;
+import org.exist.xquery.value.*;
+
+/**
+ * Implements cast as (T1 | T2 | ...) from XQuery 4.0.
+ * Tries each target type in order and returns the first successful cast.
+ */
+public class ChoiceCastExpression extends AbstractExpression {
+
+    private final int[] targetTypes;
+    private final Cardinality cardinality;
+    private Expression expression;
+
+    public ChoiceCastExpression(final XQueryContext context, final Expression expr,
+                                final int[] targetTypes, final Cardinality cardinality) {
+        super(context);
+        this.targetTypes = targetTypes;
+        this.cardinality = cardinality;
+        this.expression = expr;
+    }
+
+    @Override
+    public void analyze(final AnalyzeContextInfo contextInfo) throws XPathException {
+        contextInfo.setParent(this);
+        expression.analyze(contextInfo);
+    }
+
+    @Override
+    public Sequence eval(final Sequence contextSequence, final Item contextItem) throws XPathException {
+        final Sequence seq = Atomize.atomize(expression.eval(contextSequence, contextItem));
+        if (seq.isEmpty()) {
+            if (cardinality.atLeastOne()) {
+                throw new XPathException(this, ErrorCodes.XPTY0004,
+                        "Type error: empty sequence is not allowed here");
+            }
+            return Sequence.EMPTY_SEQUENCE;
+        }
+        if (seq.hasMany()) {
+            throw new XPathException(this, ErrorCodes.XPTY0004,
+                    "cardinality error: sequence with more than one item is not allowed here");
+        }
+
+        final Item item = seq.itemAt(0);
+        XPathException lastError = null;
+
+        for (final int targetType : targetTypes) {
+            try {
+                return item.convertTo(targetType);
+            } catch (final XPathException e) {
+                lastError = e;
+            }
+        }
+
+        throw new XPathException(this, ErrorCodes.FORG0001,
+                "Cannot cast " + Type.getTypeName(item.getType()) +
+                " to any of the choice types", lastError);
+    }
+
+    @Override
+    public int returnsType() {
+        return Type.ANY_ATOMIC_TYPE;
+    }
+
+    @Override
+    public Cardinality getCardinality() {
+        return Cardinality.ZERO_OR_ONE;
+    }
+
+    @Override
+    public void dump(final ExpressionDumper dumper) {
+        expression.dump(dumper);
+        dumper.display(" cast as (");
+        for (int i = 0; i < targetTypes.length; i++) {
+            if (i > 0) {
+                dumper.display(" | ");
+            }
+            dumper.display(Type.getTypeName(targetTypes[i]));
+        }
+        dumper.display(")");
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        sb.append(expression.toString()).append(" cast as (");
+        for (int i = 0; i < targetTypes.length; i++) {
+            if (i > 0) {
+                sb.append(" | ");
+            }
+            sb.append(Type.getTypeName(targetTypes[i]));
+        }
+        sb.append(")");
+        return sb.toString();
+    }
+
+    @Override
+    public int getDependencies() {
+        return expression.getDependencies() | Dependency.CONTEXT_ITEM;
+    }
+
+    @Override
+    public void setContextDocSet(final DocumentSet contextSet) {
+        super.setContextDocSet(contextSet);
+        expression.setContextDocSet(contextSet);
+    }
+
+    @Override
+    public void resetState(final boolean postOptimization) {
+        super.resetState(postOptimization);
+        expression.resetState(postOptimization);
+    }
+
+}

exist-core/src/main/java/org/exist/xquery/ChoiceCastableExpression.java

@@ -0,0 +1,128 @@
+/*
+ * 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;
+
+import org.exist.dom.persistent.DocumentSet;
+import org.exist.xquery.util.ExpressionDumper;
+import org.exist.xquery.value.*;
+
+/**
+ * Implements castable as (T1 | T2 | ...) from XQuery 4.0.
+ * Returns true if the value can be cast to any of the target types.
+ */
+public class ChoiceCastableExpression extends AbstractExpression {
+
+    private final int[] targetTypes;
+    private final Cardinality requiredCardinality;
+    private final Expression expression;
+
+    public ChoiceCastableExpression(final XQueryContext context, final Expression expr,
+                                    final int[] targetTypes, final Cardinality requiredCardinality) {
+        super(context);
+        this.expression = expr;
+        this.targetTypes = targetTypes;
+        this.requiredCardinality = requiredCardinality;
+    }
+
+    @Override
+    public int returnsType() {
+        return Type.BOOLEAN;
+    }
+
+    @Override
+    public Cardinality getCardinality() {
+        return Cardinality.EXACTLY_ONE;
+    }
+
+    @Override
+    public void analyze(final AnalyzeContextInfo contextInfo) throws XPathException {
+        contextInfo.setParent(this);
+        expression.analyze(contextInfo);
+    }
+
+    @Override
+    public Sequence eval(final Sequence contextSequence, final Item contextItem) throws XPathException {
+        final Sequence seq = Atomize.atomize(expression.eval(contextSequence, contextItem));
+        if (seq.isEmpty()) {
+            return BooleanValue.valueOf(
+                    requiredCardinality.isSuperCardinalityOrEqualOf(Cardinality.EMPTY_SEQUENCE));
+        }
+        if (!requiredCardinality.isSuperCardinalityOrEqualOf(seq.getCardinality())) {
+            return BooleanValue.FALSE;
+        }
+
+        final Item item = seq.itemAt(0);
+        for (final int targetType : targetTypes) {
+            try {
+                item.convertTo(targetType);
+                return BooleanValue.TRUE;
+            } catch (final XPathException e) {
+                // try next type
+            }
+        }
+        return BooleanValue.FALSE;
+    }
+
+    @Override
+    public void dump(final ExpressionDumper dumper) {
+        expression.dump(dumper);
+        dumper.display(" castable as (");
+        for (int i = 0; i < targetTypes.length; i++) {
+            if (i > 0) {
+                dumper.display(" | ");
+            }
+            dumper.display(Type.getTypeName(targetTypes[i]));
+        }
+        dumper.display(")");
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        sb.append(expression.toString()).append(" castable as (");
+        for (int i = 0; i < targetTypes.length; i++) {
+            if (i > 0) {
+                sb.append(" | ");
+            }
+            sb.append(Type.getTypeName(targetTypes[i]));
+        }
+        sb.append(")");
+        return sb.toString();
+    }
+
+    @Override
+    public int getDependencies() {
+        return Dependency.CONTEXT_SET + Dependency.CONTEXT_ITEM;
+    }
+
+    @Override
+    public void setContextDocSet(final DocumentSet contextSet) {
+        super.setContextDocSet(contextSet);
+        expression.setContextDocSet(contextSet);
+    }
+
+    @Override
+    public void resetState(final boolean postOptimization) {
+        super.resetState(postOptimization);
+        expression.resetState(postOptimization);
+    }
+}

exist-core/src/main/java/org/exist/xquery/Constants.java

@@ -46,7 +46,11 @@ public interface Constants {
 					    "following-sibling",
 					    "namespace",
 					    "self",
-					    "attribute-descendant"
+					    "attribute-descendant",
+					    "following-or-self",
+					    "preceding-or-self",
+					    "following-sibling-or-self",
+					    "preceding-sibling-or-self"
 	};    
 
     /**
@@ -73,6 +77,12 @@ public interface Constants {
     //combines /descendant-or-self::node()/attribute:*
 	int DESCENDANT_ATTRIBUTE_AXIS = 13;
 
+    /** XQuery 4.0 axes */
+    int FOLLOWING_OR_SELF_AXIS = 14;
+    int PRECEDING_OR_SELF_AXIS = 15;
+    int FOLLOWING_SIBLING_OR_SELF_AXIS = 16;
+    int PRECEDING_SIBLING_OR_SELF_AXIS = 17;
+
     /**
      * Node types
      */

exist-core/src/main/java/org/exist/xquery/DynamicCardinalityCheck.java

@@ -82,7 +82,14 @@ else if (seq.hasMany())
             error.addArgs(ExpressionDumper.dump(expression),
                 requiredCardinality.getHumanDescription(),
                     seq.getItemCount());
-            throw new XPathException(this, error.toString());
+            final String errCode = error.getErrorCode();
+            final ErrorCodes.ErrorCode xpathErrCode;
+            if ("XPDY0050".equals(errCode)) {
+                xpathErrCode = ErrorCodes.XPDY0050;
+            } else {
+                xpathErrCode = ErrorCodes.XPTY0004;
+            }
+            throw new XPathException(this, xpathErrCode, error.toString());
         }
         if (context.getProfiler().isEnabled())
             {context.getProfiler().end(this, "", seq);}