[refactor] Reduce complexity of XQ4 coercion checks flagged by Codacy

Simplify DynamicTypeCheck.isXQ4ImplicitCast to a single boolean return, dropping
the xs:double/xs:float to xs:decimal cases already subsumed by the any-numeric to
any-numeric rule; collapse the boolean return in isXQ4Relabeling; and extract the
XQuery 4.0 coercion disjunct in Function.checkArgumentType into an
isXQ4CoercionAllowed helper so it no longer inflates that method's condition. No
behavior change; the full XQuery3Tests suite (including the XQ4 type-promotion
tests) still passes.

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

Author: joewiz

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

@@ -215,31 +215,16 @@ private Item xq4ImplicitCast(Item item, final int type, final int requiredType)
      * The "to" column must match R exactly (the required type must be the primitive type).
      */
     static boolean isXQ4ImplicitCast(final int sourceType, final int requiredType) {
-        // xs:string → xs:anyURI
-        if (Type.subTypeOf(sourceType, Type.STRING) && requiredType == Type.ANY_URI) {
-            return true;
-        }
-        // xs:hexBinary ↔ xs:base64Binary
-        if (Type.subTypeOf(sourceType, Type.HEX_BINARY) && requiredType == Type.BASE64_BINARY) {
-            return true;
-        }
-        if (Type.subTypeOf(sourceType, Type.BASE64_BINARY) && requiredType == Type.HEX_BINARY) {
-            return true;
-        }
-        // Bidirectional numeric: xs:double → xs:decimal, xs:float → xs:decimal
-        // (Note: decimal→float, decimal→double, float→double already handled by XQ 3.1 rules)
-        if (Type.subTypeOf(sourceType, Type.DOUBLE) && requiredType == Type.DECIMAL) {
-            return true;
-        }
-        if (Type.subTypeOf(sourceType, Type.FLOAT) && requiredType == Type.DECIMAL) {
-            return true;
-        }
-        // XQ4 also allows any numeric → any other numeric
-        // "any numeric type to be implicitly converted to any other"
-        if (Type.subTypeOfUnion(sourceType, Type.NUMERIC) && Type.subTypeOfUnion(requiredType, Type.NUMERIC)) {
-            return true;
-        }
-        return false;
+        return
+                // xs:string → xs:anyURI
+                (Type.subTypeOf(sourceType, Type.STRING) && requiredType == Type.ANY_URI)
+                // xs:hexBinary ↔ xs:base64Binary
+                || (Type.subTypeOf(sourceType, Type.HEX_BINARY) && requiredType == Type.BASE64_BINARY)
+                || (Type.subTypeOf(sourceType, Type.BASE64_BINARY) && requiredType == Type.HEX_BINARY)
+                // any numeric type → any other numeric type. This subsumes the specific cases such as
+                // xs:double → xs:decimal and xs:float → xs:decimal; decimal→float, decimal→double and
+                // float→double are already permitted by the XQuery 3.1 numeric type promotion rules.
+                || (Type.subTypeOfUnion(sourceType, Type.NUMERIC) && Type.subTypeOfUnion(requiredType, Type.NUMERIC));
     }
 
     /**
@@ -255,12 +240,9 @@ static boolean isXQ4Relabeling(final int sourceType, final int requiredType) {
         }
         try {
             final int requiredPrimitive = Type.primitiveTypeOf(requiredType);
-            // Relabeling only applies when R is a derived type (not a primitive itself)
-            if (requiredPrimitive == requiredType) {
-                return false;
-            }
-            // J must be an instance of the same primitive type P
-            return Type.subTypeOf(sourceType, requiredPrimitive);
+            // Relabeling only applies when R is a derived type (not a primitive itself),
+            // and J must be an instance of the same primitive type P.
+            return requiredPrimitive != requiredType && Type.subTypeOf(sourceType, requiredPrimitive);
         } catch (final IllegalArgumentException e) {
             return false;
         }

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

@@ -309,7 +309,7 @@ private Expression checkArgumentType(
                     //Because () is seen as a node
                     (argType.getCardinality().isSuperCardinalityOrEqualOf(Cardinality.EMPTY_SEQUENCE) && returnType == Type.NODE) ||
                     // XQuery 4.0: allow implicit casts and relabeling
-                    (context.getXQueryVersion() >= 40 && (DynamicTypeCheck.isXQ4ImplicitCast(returnType, argType.getPrimaryType()) || DynamicTypeCheck.isXQ4Relabeling(returnType, argType.getPrimaryType()))))) {
+                    isXQ4CoercionAllowed(returnType, argType.getPrimaryType()))) {
                 LOG.debug(ExpressionDumper.dump(argument));
                 throw new XPathException(this, ErrorCodes.XPTY0004, Messages.getMessage(Error.FUNC_PARAM_TYPE_STATIC,
                         String.valueOf(argPosition), mySignature, argType.toString(), Type.getTypeName(returnType)));
@@ -330,6 +330,17 @@ private Expression checkArgumentType(
         return new DynamicTypeCheck(context, argType.getPrimaryType(), argument);
     }
 
+    /**
+     * Whether a value of {@code sourceType} may be implicitly coerced to {@code requiredType}
+     * under the XQuery 4.0 function coercion rules (spec §3.4.1): implicit casting or relabeling.
+     * Always false below XQuery 4.0.
+     */
+    private boolean isXQ4CoercionAllowed(final int sourceType, final int requiredType) {
+        return context.getXQueryVersion() >= 40
+                && (DynamicTypeCheck.isXQ4ImplicitCast(sourceType, requiredType)
+                    || DynamicTypeCheck.isXQ4Relabeling(sourceType, requiredType));
+    }
+
     protected boolean checkArgumentTypeCardinality(
             final Expression argument,
             @Nullable final SequenceType argType,