[feature] Complete XQ4 record type support: record(*) rejection, key ordering, fn:dateTime-record

- Reject record(*) and record(..., *) extensible types at parse time (XPST0003)
- Add RecordMapType with ordered keys() to preserve field declaration order
- Implement fn:dateTime-record with 0-7 arity overloads returning typed DATETIME_RECORD
- Register fn:dateTime-record as named record type resolvable in instance-of expressions
- Non-extensible record coercion drops extra keys instead of rejecting

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: joewiz

exist-core/src/main/antlr/org/exist/xquery/parser/XQuery.g

@@ -192,6 +192,8 @@ imaginaryTokenDefinitions
 	PREVIOUS_ITEM
 	NEXT_ITEM
 	WINDOW_VARS
+	RECORD_TEST
+	RECORD_FIELD
 	;
 
 // === XPointer ===
@@ -592,6 +594,8 @@ itemType throws XPathException
 	|
 	( "array" LPAREN ) => arrayType
 	|
+	( { LA(1) == NCNAME && LT(1).getText().equals("record") && LA(2) == LPAREN }? NCNAME LPAREN ) => recordType
+	|
 	( LPAREN ) => parenthesizedItemType
 	|
 	( . LPAREN ) => kindTest
@@ -686,6 +690,65 @@ arrayTypeTest throws XPathException
 	}
 	;
 
+// === XQuery 4.0 Record Type ===
+
+recordType throws XPathException
+:
+	{ LA(1) == NCNAME && LT(1).getText().equals("record") && LA(2) == LPAREN && LA(3) == RPAREN }?
+	emptyRecordTest
+	|
+	{ LA(1) == NCNAME && LT(1).getText().equals("record") && LA(2) == LPAREN && LA(3) == STAR }?
+	extensibleRecordReject
+	|
+	typedRecordTest
+	;
+
+emptyRecordTest throws XPathException
+:
+	r:NCNAME! LPAREN! RPAREN!
+	{
+		#emptyRecordTest = #(#[RECORD_TEST, "record"], #emptyRecordTest);
+	}
+	;
+
+extensibleRecordReject throws XPathException
+:
+	r:NCNAME! LPAREN! STAR RPAREN!
+	{
+		throw new XPathException(r.getLine(), r.getColumn(), ErrorCodes.XPST0003,
+			"Extensible record types record(*) are not supported in XQuery 4.0");
+	}
+	;
+
+typedRecordTest throws XPathException
+{ boolean extensible = false; }
+:
+	r:NCNAME! LPAREN! recordFieldDecl (COMMA!
+		( ( STAR ) => STAR { extensible = true; }
+		| recordFieldDecl
+		)
+	)* RPAREN!
+	{
+		if (extensible) {
+			throw new XPathException(r.getLine(), r.getColumn(), ErrorCodes.XPST0003,
+				"Extensible record types record(..., *) are not supported in XQuery 4.0");
+		}
+		#typedRecordTest = #(#[RECORD_TEST, "record"], #typedRecordTest);
+	}
+	;
+
+recordFieldDecl throws XPathException
+{ String fieldName = null; String fieldLabel = null; boolean isOptional = false; }
+:
+	fieldName=fn:ncnameOrKeyword
+	( QUESTION { isOptional = true; } )?
+	( "as" sequenceType )?
+	{
+		fieldLabel = isOptional ? fieldName.concat("?") : fieldName;
+		#recordFieldDecl = #(#[RECORD_FIELD, fieldLabel], #recordFieldDecl);
+	}
+	;
+
 // === Expressions ===
 
 queryBody throws XPathException: expr ;

exist-core/src/main/antlr/org/exist/xquery/parser/XQueryTree.g

@@ -1049,7 +1049,7 @@ throws XPathException
                 try {
                     QName qn= QName.parse(staticContext, t.getText());
                     int code= Type.getType(qn);
-                    if (!Type.subTypeOf(code, Type.ANY_ATOMIC_TYPE))
+                    if (!Type.subTypeOf(code, Type.ANY_ATOMIC_TYPE) && !Type.subTypeOf(code, Type.RECORD))
                         throw new XPathException(t.getLine(), t.getColumn(), ErrorCodes.XPST0051, qn.toString() + " is not atomic");
                     type.setPrimaryType(code);
                 } catch (final XPathException e) {
@@ -1132,6 +1132,37 @@ throws XPathException
             )
         )
         |
+        #(
+            RECORD_TEST
+            {
+                type.setPrimaryType(Type.RECORD);
+                List<RecordType.FieldDeclaration> recordFields = new ArrayList<RecordType.FieldDeclaration>();
+            }
+            (
+                #(
+                    rf:RECORD_FIELD
+                    {
+                        String rfName = rf.getText();
+                        boolean rfOptional = rfName.endsWith("?");
+                        if (rfOptional) {
+                            rfName = rfName.substring(0, rfName.length() - 1);
+                        }
+                        SequenceType rfType = null;
+                    }
+                    (
+                        { rfType = new SequenceType(); }
+                        sequenceType [rfType]
+                    )?
+                    {
+                        recordFields.add(new RecordType.FieldDeclaration(rfName, rfType, rfOptional));
+                    }
+                )
+            )*
+            {
+                type.setRecordType(new RecordType(recordFields, false));
+            }
+        )
+        |
         #(
             "item" { type.setPrimaryType(Type.ITEM); }
         )

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

@@ -24,6 +24,7 @@
 import org.exist.dom.persistent.DocumentSet;
 import org.exist.xquery.functions.map.AbstractMapType;
 import org.exist.xquery.functions.map.MapType;
+import org.exist.xquery.functions.map.RecordMapType;
 import org.exist.xquery.util.ExpressionDumper;
 import org.exist.xquery.value.*;
 
@@ -96,8 +97,14 @@ private Sequence coerce(final Item item) throws XPathException {
         final AbstractMapType sourceMap = (AbstractMapType) item;
         final java.util.List<RecordType.FieldDeclaration> fields = recordType.getFieldDeclarations();
 
-        // Build a new map with only declared fields, in declaration order
-        final MapType coercedMap = new MapType(expression, context);
+        // Build field order list for RecordMapType
+        final java.util.List<String> fieldOrder = new java.util.ArrayList<>(fields.size());
+        for (final RecordType.FieldDeclaration f : fields) {
+            fieldOrder.add(f.getName());
+        }
+
+        // Build a new record map with only declared fields, in declaration order
+        final RecordMapType coercedMap = new RecordMapType(expression, context, fieldOrder);
 
         for (final RecordType.FieldDeclaration field : fields) {
             final StringValue key = new StringValue(expression, field.getName());

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

@@ -0,0 +1,150 @@
+/*
+ * eXist-db Open Source Native XML Database
+ * Copyright (C) 2001 The eXist-db Authors
+ *
+ * [email protected]
+ * 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.xquery.*;
+import org.exist.xquery.functions.map.RecordMapType;
+import org.exist.xquery.value.*;
+
+import java.util.List;
+
+import static org.exist.xquery.FunctionDSL.*;
+import static org.exist.xquery.functions.fn.FnModule.functionSignature;
+import static org.exist.xquery.functions.fn.FnModule.functionSignatures;
+
+/**
+ * Implementation of the XQuery 4.0 fn:dateTime-record named record constructor.
+ *
+ * <p>The function accepts 0 to 7 optional parameters (year, month, day,
+ * hours, minutes, seconds, timezone) and returns a map of type
+ * {@code fn:dateTime-record}. Only fields with non-empty values are
+ * included in the result map.</p>
+ *
+ * @see <a href="https://qt4cg.org/specifications/xpath-functions-40/Overview.html#dateTime-record">
+ *     XPath and XQuery Functions and Operators 4.0: fn:dateTime-record</a>
+ */
+public class FnDateTimeRecord extends BasicFunction {
+
+    private static final String FS_NAME = "dateTime-record";
+
+    /** The field names in declaration order. */
+    private static final List<String> FIELD_ORDER = List.of(
+            "year", "month", "day", "hours", "minutes", "seconds", "timezone"
+    );
+
+    private static final FunctionReturnSequenceType FS_RETURN_TYPE = returns(
+            Type.DATETIME_RECORD,
+            "A record of type fn:dateTime-record containing the specified date/time components.");
+
+    static final FunctionSignature[] FS_DATETIME_RECORD = functionSignatures(
+            FS_NAME,
+            "Constructs a dateTime-record from optional date/time component values.",
+            FS_RETURN_TYPE,
+            arities(
+                    arity(),
+                    arity(
+                            optParam("year", Type.INTEGER, "The year component")
+                    ),
+                    arity(
+                            optParam("year", Type.INTEGER, "The year component"),
+                            optParam("month", Type.INTEGER, "The month component")
+                    ),
+                    arity(
+                            optParam("year", Type.INTEGER, "The year component"),
+                            optParam("month", Type.INTEGER, "The month component"),
+                            optParam("day", Type.INTEGER, "The day component")
+                    ),
+                    arity(
+                            optParam("year", Type.INTEGER, "The year component"),
+                            optParam("month", Type.INTEGER, "The month component"),
+                            optParam("day", Type.INTEGER, "The day component"),
+                            optParam("hours", Type.INTEGER, "The hours component")
+                    ),
+                    arity(
+                            optParam("year", Type.INTEGER, "The year component"),
+                            optParam("month", Type.INTEGER, "The month component"),
+                            optParam("day", Type.INTEGER, "The day component"),
+                            optParam("hours", Type.INTEGER, "The hours component"),
+                            optParam("minutes", Type.INTEGER, "The minutes component")
+                    ),
+                    arity(
+                            optParam("year", Type.INTEGER, "The year component"),
+                            optParam("month", Type.INTEGER, "The month component"),
+                            optParam("day", Type.INTEGER, "The day component"),
+                            optParam("hours", Type.INTEGER, "The hours component"),
+                            optParam("minutes", Type.INTEGER, "The minutes component"),
+                            optParam("seconds", Type.DECIMAL, "The seconds component")
+                    ),
+                    arity(
+                            optParam("year", Type.INTEGER, "The year component"),
+                            optParam("month", Type.INTEGER, "The month component"),
+                            optParam("day", Type.INTEGER, "The day component"),
+                            optParam("hours", Type.INTEGER, "The hours component"),
+                            optParam("minutes", Type.INTEGER, "The minutes component"),
+                            optParam("seconds", Type.DECIMAL, "The seconds component"),
+                            optParam("timezone", Type.DAY_TIME_DURATION, "The timezone as xs:dayTimeDuration")
+                    )
+            )
+    );
+
+    public FnDateTimeRecord(final XQueryContext context, final FunctionSignature signature) {
+        super(context, signature);
+    }
+
+    @Override
+    public Sequence eval(final Sequence[] args, final Sequence contextSequence) throws XPathException {
+        final RecordMapType result = new RecordMapType(this, context, FIELD_ORDER, Type.DATETIME_RECORD);
+
+        for (int i = 0; i < args.length && i < FIELD_ORDER.size(); i++) {
+            final Sequence arg = args[i];
+            if (arg != null && !arg.isEmpty()) {
+                final String fieldName = FIELD_ORDER.get(i);
+                if ("timezone".equals(fieldName)) {
+                    result.add(new StringValue(this, fieldName), coerceTimezone(arg));
+                } else {
+                    result.add(new StringValue(this, fieldName), arg);
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Coerce the timezone argument to xs:dayTimeDuration.
+     * Accepts xs:dayTimeDuration directly, or xs:duration (coerced).
+     * Rejects xs:string with XPTY0004.
+     */
+    private Sequence coerceTimezone(final Sequence value) throws XPathException {
+        final Item item = value.itemAt(0);
+        if (item instanceof DurationValue dv) {
+            if (dv.getType() == Type.DAY_TIME_DURATION) {
+                return value;
+            }
+            // Coerce xs:duration or xs:yearMonthDuration to xs:dayTimeDuration
+            return dv.convertTo(Type.DAY_TIME_DURATION);
+        }
+        throw new XPathException(this, ErrorCodes.XPTY0004,
+                "Expected xs:dayTimeDuration for timezone parameter, got " +
+                        Type.getTypeName(item.getType()));
+    }
+}

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

@@ -66,6 +66,16 @@ public class FnModule extends AbstractInternalModule {
         new FunctionDef(FunData.signatures[0], FunData.class),
         new FunctionDef(FunData.signatures[1], FunData.class),
         new FunctionDef(FunDateTime.signature, FunDateTime.class),
+        // --- XQuery 4.0: fn:dateTime-record ---
+        new FunctionDef(FnDateTimeRecord.FS_DATETIME_RECORD[0], FnDateTimeRecord.class),
+        new FunctionDef(FnDateTimeRecord.FS_DATETIME_RECORD[1], FnDateTimeRecord.class),
+        new FunctionDef(FnDateTimeRecord.FS_DATETIME_RECORD[2], FnDateTimeRecord.class),
+        new FunctionDef(FnDateTimeRecord.FS_DATETIME_RECORD[3], FnDateTimeRecord.class),
+        new FunctionDef(FnDateTimeRecord.FS_DATETIME_RECORD[4], FnDateTimeRecord.class),
+        new FunctionDef(FnDateTimeRecord.FS_DATETIME_RECORD[5], FnDateTimeRecord.class),
+        new FunctionDef(FnDateTimeRecord.FS_DATETIME_RECORD[6], FnDateTimeRecord.class),
+        new FunctionDef(FnDateTimeRecord.FS_DATETIME_RECORD[7], FnDateTimeRecord.class),
+        // --- End XQuery 4.0: fn:dateTime-record ---
         new FunctionDef(FunDeepEqual.signatures[0], FunDeepEqual.class),
         new FunctionDef(FunDeepEqual.signatures[1], FunDeepEqual.class),
         new FunctionDef(FunDefaultCollation.signature, FunDefaultCollation.class),