Codegen improvements

src/expressions/XPathErrors.ts

@@ -4,7 +4,7 @@ export const errFORG0001 = (value: string, type: ValueType, reason?: string) =>
 	new Error(
 		`FORG0001: Cannot cast ${value} to ${valueTypeToString(type)}${reason ? `, ${reason}` : ''}`
 	);
-export const XPDY0002 = (message: string) => new Error(`XPDY0002: ${message}`);
+export const errXPDY0002 = (message: string) => new Error(`XPDY0002: ${message}`);
 export const errXPTY0004 = (message: string) => new Error(`XPTY0004: ${message}`);
 export const errFOTY0013 = (type: ValueType) =>
 	new Error(`FOTY0013: Atomization is not supported for ${valueTypeToString(type)}.`);

src/expressions/dataTypes/typeHelpers.ts

@@ -1,5 +1,5 @@
 import builtinDataTypesByType, { TypeModel } from './builtins/builtinDataTypesByType';
-import { ValueType } from './Value';
+import { SequenceMultiplicity, SequenceType, ValueType } from './Value';
 import { Variety } from './Variety';
 
 export function getPrimitiveTypeName(typeName: ValueType): ValueType | null {
@@ -89,3 +89,25 @@ export function validateRestrictions(value: string, valueType: ValueType): boole
 	}
 	return true;
 }
+
+export function doesTypeAllowEmpty(type: SequenceType | null): boolean {
+	if (!type) {
+		// Unknown types can be anything
+		return true;
+	}
+	return (
+		type.mult === SequenceMultiplicity.ZERO_OR_MORE ||
+		type.mult === SequenceMultiplicity.ZERO_OR_ONE
+	);
+}
+
+export function doesTypeAllowMultiple(type: SequenceType | null): boolean {
+	if (!type) {
+		// Unknown types can be anything
+		return true;
+	}
+	return (
+		type.mult === SequenceMultiplicity.ZERO_OR_MORE ||
+		type.mult === SequenceMultiplicity.ONE_OR_MORE
+	);
+}

src/expressions/functions/builtInFunctions_identifiers.ts

@@ -6,7 +6,7 @@ import isSubtypeOf from '../dataTypes/isSubtypeOf';
 import sequenceFactory from '../dataTypes/sequenceFactory';
 import { SequenceMultiplicity, ValueType } from '../dataTypes/Value';
 import { BUILT_IN_NAMESPACE_URIS } from '../staticallyKnownNamespaces';
-import { errXPTY0004, XPDY0002 } from '../XPathErrors';
+import { errXPDY0002, errXPTY0004 } from '../XPathErrors';
 import { BuiltinDeclarationType } from './builtInFunctions';
 import FunctionDefinitionType from './FunctionDefinitionType';
 
@@ -44,7 +44,7 @@ const fnId: FunctionDefinitionType = (
 ) => {
 	const targetNodeValue = targetNodeSequence.first();
 	if (!targetNodeValue) {
-		throw XPDY0002('The context is absent, it needs to be present to use id function.');
+		throw errXPDY0002('The context is absent, it needs to be present to use id function.');
 	}
 	if (!isSubtypeOf(targetNodeValue.type, ValueType.NODE)) {
 		throw errXPTY0004(
@@ -102,7 +102,7 @@ const fnIdref: FunctionDefinitionType = (
 ) => {
 	const targetNodeValue = targetNodeSequence.first();
 	if (!targetNodeValue) {
-		throw XPDY0002('The context is absent, it needs to be present to use idref function.');
+		throw errXPDY0002('The context is absent, it needs to be present to use idref function.');
 	}
 	if (!isSubtypeOf(targetNodeValue.type, ValueType.NODE)) {
 		throw errXPTY0004(

src/expressions/functions/builtInFunctions_node.ts

@@ -108,7 +108,7 @@ const fnName: FunctionDefinitionType = (
 				staticContext,
 				fnNodeName(dynamicContext, executionParameters, staticContext, sequence)
 			),
-		empty: () => sequenceFactory.empty(),
+		empty: () => sequenceFactory.singleton(createAtomicValue('', ValueType.XSSTRING)),
 	});
 };
 
@@ -403,7 +403,7 @@ const declarations: BuiltinDeclarationType[] = [
 		callFunction: fnName,
 		localName: 'name',
 		namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
-		returnType: { type: ValueType.XSSTRING, mult: SequenceMultiplicity.ZERO_OR_ONE },
+		returnType: { type: ValueType.XSSTRING, mult: SequenceMultiplicity.EXACTLY_ONE },
 	},
 
 	{

src/jsCodegen/CodeGenContext.ts

@@ -1,13 +1,67 @@
-import { Bucket } from '../expressions/util/Bucket';
-import { IAST } from '../parsing/astHelper';
 import { NamespaceResolver } from '../types/Options';
-import { FunctionIdentifier, PartialCompilationResult } from './JavaScriptCompiledXPath';
-
-export type CodeGenContext = {
-	emitBaseExpr?: (
-		ast: IAST,
-		identifier: FunctionIdentifier,
-		staticContext: CodeGenContext
-	) => [PartialCompilationResult, Bucket];
-	resolveNamespace: NamespaceResolver;
-};
+import { emitBaseExpr } from './emitBaseExpr';
+import { mapPartialCompilationResult } from './emitHelpers';
+import {
+	acceptAst,
+	GeneratedCodeBaseType,
+	PartialCompilationResult,
+	PartiallyCompiledAstAccepted,
+} from './JavaScriptCompiledXPath';
+
+export class CodeGenContext {
+	public defaultFunctionNamespaceUri: string;
+
+	// We need to create indirection through context for emitBaseExpr to avoid a cyclic dependency
+	// that the Closure compiler can't handle
+	public emitBaseExpr: typeof emitBaseExpr;
+
+	public resolveNamespace: NamespaceResolver;
+
+	private _identifierExprByExpr = new Map<
+		PartiallyCompiledAstAccepted,
+		PartiallyCompiledAstAccepted
+	>();
+
+	private _nextByPrefix = new Map<string, number>();
+
+	public constructor(resolveNamespace: NamespaceResolver, defaultFunctionNamespaceUri: string) {
+		this.resolveNamespace = resolveNamespace;
+		this.defaultFunctionNamespaceUri = defaultFunctionNamespaceUri;
+		this.emitBaseExpr = emitBaseExpr;
+	}
+
+	public getIdentifierFor(
+		expr: PartialCompilationResult,
+		prefix = 'v'
+	): PartialCompilationResult {
+		return mapPartialCompilationResult(expr, (expr) => {
+			let identifierExpr = this._identifierExprByExpr.get(expr);
+			if (!identifierExpr) {
+				const identifier = this._getNewIdentifier(prefix);
+				identifierExpr = acceptAst(identifier, expr.generatedCodeType, [
+					...expr.variables,
+					`const ${identifier} = ${expr.code};`,
+				]);
+				this._identifierExprByExpr.set(expr, identifierExpr);
+				this._identifierExprByExpr.set(identifierExpr, identifierExpr);
+			}
+			return identifierExpr;
+		});
+	}
+
+	public getNewIdentifier(prefix = 'v'): PartiallyCompiledAstAccepted {
+		return this.getVarInScope(this._getNewIdentifier(prefix));
+	}
+
+	public getVarInScope(identifier: string): PartiallyCompiledAstAccepted {
+		const expr = acceptAst(identifier, { type: GeneratedCodeBaseType.Value }, []);
+		this._identifierExprByExpr.set(expr, expr);
+		return expr;
+	}
+
+	private _getNewIdentifier(prefix = 'v'): string {
+		const next = this._nextByPrefix.get(prefix) || 0;
+		this._nextByPrefix.set(prefix, next + 1);
+		return `${prefix}${next}`;
+	}
+}

src/jsCodegen/JavaScriptCompiledXPath.ts

@@ -9,80 +9,40 @@ export enum CompiledResultType {
 }
 
 export type PartiallyCompiledAstAccepted = {
+	// Expression that was generated
 	code: string;
 	// What kind of code was generated.
 	generatedCodeType: GeneratedCodeType;
 	isAstAccepted: true;
 	// Contains variable (and function) declarations for the upper compiled
 	// scope.
-	variables?: string[];
+	variables: string[];
 };
 
 export enum GeneratedCodeBaseType {
 	// A normal value: 5, "test", true, ...
 	Value,
-	// Defining a variable: const test = "test";
-	Variable,
-	// A statement: if (this) { do that; }
+	// A generator function representing a lazy sequence
+	Generator,
+	// Statements, used to build the generator body - doesn't have a value
 	Statement,
-	// A function has been generated: function foo() { return true; }
-	Function,
-	// An iterator is returned.
-	Iterator,
-	// Used in a single case where no code is generated.
-	None,
 }
 
 export type GeneratedCodeType =
 	| { type: GeneratedCodeBaseType.Value }
-	| { type: GeneratedCodeBaseType.Variable }
-	| { type: GeneratedCodeBaseType.Statement }
-	| { returnType: GeneratedCodeType; type: GeneratedCodeBaseType.Function }
-	| { type: GeneratedCodeBaseType.Iterator }
-	| { type: GeneratedCodeBaseType.None };
-
-export function getCompiledValueCode(
-	identifier: string,
-	generatedCodeType: GeneratedCodeType,
-	contextItemName?: string
-): [string, GeneratedCodeType] {
-	switch (generatedCodeType.type) {
-		case GeneratedCodeBaseType.Value:
-			return [identifier, { type: GeneratedCodeBaseType.Value }];
-		case GeneratedCodeBaseType.Variable:
-			return [identifier, { type: GeneratedCodeBaseType.Variable }];
-		case GeneratedCodeBaseType.Function: {
-			const code = `${
-				getCompiledValueCode(
-					`${identifier}(${contextItemName ? contextItemName : 'contextItem'})`,
-					generatedCodeType.returnType,
-					contextItemName
-				)[0]
-			}`;
-			return [code, generatedCodeType.returnType];
-		}
-		case GeneratedCodeBaseType.Iterator: {
-			return [identifier, { type: GeneratedCodeBaseType.Iterator }];
-		}
-		case GeneratedCodeBaseType.None:
-			throw new Error('Trying to get value of generated code with type None');
-		default:
-			throw new Error(
-				'Unreachable! Trying to get compiled value of unsupported GeneratedCodeType.'
-			);
-	}
-}
+	| { type: GeneratedCodeBaseType.Generator }
+	| { type: GeneratedCodeBaseType.Statement };
 
 export function acceptAst(
 	code: string,
 	generatedCodeType: GeneratedCodeType,
-	variables?: string[]
+	variables: string[]
 ): PartiallyCompiledAstAccepted {
 	return {
 		code,
 		generatedCodeType,
-		isAstAccepted: true,
 		variables,
+		isAstAccepted: true,
 	};
 }