Implement otherwise and combinating tests from XQ4

Author: DrRataplan

src/evaluateUpdatingExpression.ts

@@ -30,6 +30,7 @@ import { Language, Logger, XMLSerializer } from './types/Options';
  * nodesFactory				- Reference to a nodes factory object.
  * returnType				- The type that the evaluation function will return.
  * xmlSerializer			- An XML serializer that can serialize nodes. Used when the `fn:serialize` function is called with a node.
+ * language                 - Whether to allow experimental XQuery 4 features in the script
  */
 export type UpdatingOptions = {
 	debug?: boolean;
@@ -41,6 +42,7 @@ export type UpdatingOptions = {
 	nodesFactory?: INodesFactory;
 	returnType?: ReturnType;
 	xmlSerializer?: XMLSerializer;
+	language?: Language.XQUERY_UPDATE_3_1_LANGUAGE | Language.XQUERY_UPDATE_4_0_LANGUAGE;
 };
 
 /**
@@ -82,6 +84,7 @@ export default async function evaluateUpdatingExpression(
 				allowXQuery: true,
 				debug: !!options['debug'],
 				disableCache: !!options['disableCache'],
+				version: options.language === Language.XQUERY_UPDATE_4_0_LANGUAGE ? 4 : 3.1,
 			},
 		);
 		dynamicContext = context.dynamicContext;

src/evaluateUpdatingExpressionSync.ts

@@ -12,6 +12,7 @@ import UpdatingExpressionResult from './expressions/UpdatingExpressionResult';
 import { IterationHint, IterationResult } from './expressions/util/iterators';
 import { IReturnTypes, ReturnType } from './parsing/convertXDMReturnValue';
 import { performStaticCompilationOnModules } from './parsing/globalModuleCache';
+import { Language } from './types/Options';
 import { Node } from './types/Types';
 
 /**
@@ -57,6 +58,7 @@ export default function evaluateUpdatingExpressionSync<
 				allowXQuery: true,
 				debug: !!options['debug'],
 				disableCache: !!options['disableCache'],
+				version: options.language === Language.XQUERY_UPDATE_4_0_LANGUAGE ? 4 : 3.1,
 			},
 		);
 		dynamicContext = context.dynamicContext;

src/evaluateXPath.ts

@@ -180,6 +180,12 @@ const evaluateXPath = <TNode extends Node, TReturnType extends keyof IReturnType
 					options['language'] === Language.XQUERY_UPDATE_3_1_LANGUAGE,
 				debug: !!options['debug'],
 				disableCache: !!options['disableCache'],
+				version:
+					options['language'] === Language.XPATH_4_0_LANGUAGE ||
+					options['language'] === Language.XQUERY_4_0_LANGUAGE ||
+					options['language'] === Language.XQUERY_UPDATE_4_0_LANGUAGE
+						? 4
+						: 3.1,
 			},
 		);
 		dynamicContext = context.dynamicContext;

src/evaluationUtils/buildEvaluationContext.ts

@@ -71,6 +71,7 @@ export default function buildEvaluationContext(
 		allowXQuery: boolean;
 		debug: boolean;
 		disableCache: boolean;
+		version: 3.1 | 4;
 	},
 ): {
 	dynamicContext: DynamicContext;

src/expressions/functions/builtInFunctions_fontoxpath.ts

@@ -61,6 +61,7 @@ function buildResultIterator(
 				allowXQuery: true,
 				debug: executionParameters.debug,
 				disableCache: executionParameters.disableCache,
+				version: 3.1,
 			},
 			(prefix) => staticContext.resolveNamespace(prefix),
 			// Set up temporary bindings for the given variables

src/expressions/tests/CombinatingTest.ts

@@ -0,0 +1,65 @@
+import Value from '../dataTypes/Value';
+import DynamicContext from '../DynamicContext';
+import ExecutionParameters from '../ExecutionParameters';
+import {} from '../Expression';
+import Specificity from '../Specificity';
+import StaticContext from '../StaticContext';
+import { Bucket, unionBucket } from '../util/Bucket';
+import TestAbstractExpression from './TestAbstractExpression';
+
+/**
+ * Combinating test, used to process `descendant::(a|b|c)` selectors
+ */
+class CombinatingTest extends TestAbstractExpression {
+	private _subTests: TestAbstractExpression[];
+	private _bucket: Bucket;
+	constructor(subTests: TestAbstractExpression[]) {
+		const maxSpecificity = subTests.reduce<Specificity>((currentMaxSpecificity, selector) => {
+			if (currentMaxSpecificity.compareTo(selector.specificity) > 0) {
+				return currentMaxSpecificity;
+			}
+			return selector.specificity;
+		}, new Specificity({}));
+
+		super(maxSpecificity);
+
+		// If all subExpressions define the same bucket: use that one, else, use no bucket.
+		let bucket: Bucket | null;
+		for (let i = 0; i < subTests.length; ++i) {
+			const subTestBucket = subTests[i].getBucket();
+			if (bucket === undefined) {
+				bucket = subTestBucket;
+			}
+			if (bucket === null) {
+				// Not applicable buckets
+				break;
+			}
+
+			bucket = unionBucket(bucket, subTestBucket);
+		}
+
+		this._bucket = bucket;
+		this._subTests = subTests;
+	}
+
+	public evaluateToBoolean(
+		dynamicContext: DynamicContext,
+		value: Value,
+		executionParameters: ExecutionParameters,
+	) {
+		return this._subTests.some((test) => {
+			const result = test.evaluateToBoolean(dynamicContext, value, executionParameters);
+			return result;
+		});
+	}
+
+	public override getBucket(): Bucket {
+		return this._bucket;
+	}
+
+	public performStaticEvaluation(staticContext: StaticContext) {
+		this._subTests.forEach((test) => test.performStaticEvaluation(staticContext));
+	}
+}
+
+export default CombinatingTest;

src/expressions/util/Bucket.ts

@@ -35,6 +35,13 @@ const subBucketsByBucket: Map<Bucket, Bucket[]> = new Map([
 	['type-2', ['name']],
 ]);
 
+// Some buckets exclude others. For the purppose of determining their unions, this lists supertypes pet bucket.
+const superBucketsByBucket: Map<Bucket, Bucket> = new Map([
+	['name', 'type-1-or-type-2'],
+	['type-1', 'type-1-or-type-2'],
+	['type-2', 'type-1-or-type-2'],
+]);
+
 /**
  * Determine the intersection between the two passed buckets. The intersection is the 'strongest'
  * bucket of the two. This may return `empty` if there is no such intersection.
@@ -78,3 +85,54 @@ export function intersectBuckets(bucket1: Bucket | null, bucket2: Bucket | null)
 	// Expression will never match any nodes
 	return 'empty';
 }
+
+/**
+ * Determine the union between the two passed buckets. The union is the common denominator between buckets
+ *
+ * Example: `null` ∪ `name-div` = `null`
+ * Example: `name-p` ∪ `name-div` = `type-1-or-type-2`
+ * Example: `type-1` ∪ `name-p` = `type-1`
+ * Example: `type-1` ∪ `empty` = `type-1`
+ *
+ * @param  bucket1 - The first bucket to check
+ * @param  bucket2 - The second bucket to check
+ *
+ * @returns The union of the two buckets.
+ */
+export function unionBucket(bucket1: Bucket | null, bucket2: Bucket | null): Bucket | null {
+	// null bucket applies to everything
+	if (bucket1 === null || bucket2 === null) {
+		return null;
+	}
+	if (bucket1 === 'empty') {
+		return bucket2;
+	}
+	if (bucket2 === 'empty') {
+		return bucket1;
+	}
+	// Same bucket is same
+	if (bucket1 === bucket2) {
+		return bucket1;
+	}
+	// Find the more specific one, given that the buckets are not equal
+	const type1 = bucket1.startsWith('name-') ? 'name' : bucket1;
+	const type2 = bucket2.startsWith('name-') ? 'name' : bucket2;
+
+	const supertypes1 = superBucketsByBucket.get(type1);
+	if (supertypes1 !== undefined && supertypes1 === type2) {
+		// bucket 2 includes bucket 1
+		return supertypes1;
+	}
+	const supertypes2 = superBucketsByBucket.get(type2);
+	if (supertypes2 !== undefined && supertypes2 === type1) {
+		// bucket 1 includes bucket 2
+		return supertypes2;
+	}
+
+	if (supertypes1 === supertypes2) {
+		return supertypes1;
+	}
+
+	// Expression will never match any nodes
+	return 'empty';
+}

src/expressions/xpath-40/Otherwise.ts

@@ -0,0 +1,47 @@
+import ISequence from '../dataTypes/ISequence';
+import sequenceFactory from '../dataTypes/sequenceFactory';
+import { SequenceType, ValueType } from '../dataTypes/Value';
+import DynamicContext from '../DynamicContext';
+import ExecutionParameters from '../ExecutionParameters';
+import Expression, { RESULT_ORDERINGS } from '../Expression';
+import PossiblyUpdatingExpression, { SequenceCallbacks } from '../PossiblyUpdatingExpression';
+import Specificity from '../Specificity';
+
+/**
+ * The 'otherwise' expression: returns the first operand that's not empty
+ */
+class Otherwise extends PossiblyUpdatingExpression {
+	constructor(expressions: Expression[], type: SequenceType) {
+		const maxSpecificity = expressions.reduce((maxSpecificitySoFar, expression) => {
+			if (maxSpecificitySoFar.compareTo(expression.specificity) > 0) {
+				return maxSpecificitySoFar;
+			}
+			return expression.specificity;
+		}, new Specificity({}));
+		super(
+			maxSpecificity,
+			expressions,
+			{
+				canBeStaticallyEvaluated: expressions.every(
+					(expression) => expression.canBeStaticallyEvaluated,
+				),
+			},
+			type,
+		);
+	}
+
+	public override performFunctionalEvaluation(
+		dynamicContext: DynamicContext,
+		_executionParameters: ExecutionParameters,
+		sequenceCallbacks: SequenceCallbacks,
+	): ISequence {
+		for (const cb of sequenceCallbacks) {
+			const sequence = cb(dynamicContext);
+			if (!sequence.isEmpty()) {
+				return sequence;
+			}
+		}
+		return sequenceFactory.empty();
+	}
+}
+export default Otherwise;

src/index.ts

@@ -84,7 +84,7 @@ function parseXPath(xpathExpression: EvaluableExpression): Expression {
 
 	const ast =
 		typeof xpathExpression === 'string'
-			? parseExpression(xpathExpression, { allowXQuery: false })
+			? parseExpression(xpathExpression, { allowXQuery: false, version: 4 })
 			: // AST is an element: convert to jsonml
 			  convertXmlToAst(xpathExpression);
 

src/jsCodegen/compileXPathToJavaScript.ts

@@ -1,3 +1,4 @@
+import { version } from 'chai';
 import { EvaluableExpression } from '../evaluateXPath';
 import {
 	createDefaultFunctionNameResolver,
@@ -11,7 +12,7 @@ import astHelper from '../parsing/astHelper';
 import { ReturnType } from '../parsing/convertXDMReturnValue';
 import convertXmlToAst from '../parsing/convertXmlToAst';
 import normalizeEndOfLines from '../parsing/normalizeEndOfLines';
-import parseExpression from '../parsing/parseExpression';
+import parseExpression, { CompilationOptions } from '../parsing/parseExpression';
 import annotateAst from '../typeInference/annotateAST';
 import { AnnotationContext } from '../typeInference/AnnotationContext';
 import { Language, Options } from '../types/Options';
@@ -42,13 +43,14 @@ function compileXPathToJavaScript(
 	let ast;
 	if (typeof selector === 'string') {
 		const expressionString = normalizeEndOfLines(selector);
-		const parserOptions = {
+		const parserOptions: CompilationOptions = {
 			allowXQuery:
 				options['language'] === Language.XQUERY_3_1_LANGUAGE ||
 				options['language'] === Language.XQUERY_UPDATE_3_1_LANGUAGE,
 			// Debugging inserts xs:stackTrace in the AST, but this is not supported
 			// yet by the js-codegen backend.
 			debug: false,
+			version: 3.1,
 		};
 		try {
 			ast = parseExpression(expressionString, parserOptions);