3628388019

Build Type

github

Committed by GitHub

Commit Message

Merge 176742a86 into de815bf32

Pull Request Pull Request #561: Circ deps

Run Details

4886 of 5685 branches covered (85.95%)

Branch coverage included in aggregate %.

44 of 45 new or added lines in 9 files covered. (97.78%)

14 existing lines in 3 files now uncovered.

10512 of 11151 relevant lines covered (94.27%)

97489.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.12

/src/parsing/processProlog.ts

import type { EvaluableExpression } from '../evaluateXPath';
import ISequence from '../expressions/dataTypes/ISequence';
import sequenceFactory from '../expressions/dataTypes/sequenceFactory';
import type { SequenceType } from '../expressions/dataTypes/Value';
import DynamicContext from '../expressions/DynamicContext';
import ExecutionParameters from '../expressions/ExecutionParameters';
import Expression from '../expressions/Expression';
import FunctionDefinitionType from '../expressions/functions/FunctionDefinitionType';
import { getAlternativesAsStringFor } from '../expressions/functions/functionRegistry';
import { BUILT_IN_NAMESPACE_URIS } from '../expressions/staticallyKnownNamespaces';
import StaticContext, {
        FunctionDefinition,
        GenericFunctionDefinition,
        UpdatingFunctionDefinition,
} from '../expressions/StaticContext';
import createDoublyIterableSequence from '../expressions/util/createDoublyIterableSequence';
import UpdatingExpression from '../expressions/xquery-update/UpdatingExpression';
import UpdatingFunctionDefinitionType from '../expressions/xquery-update/UpdatingFunctionDefinitionType';
import { errXUST0001 } from '../expressions/xquery-update/XQueryUpdateFacilityErrors';
import {
        errXPST0081,
        errXQST0045,
        errXQST0047,
        errXQST0060,
        errXQST0066,
        errXQST0070,
} from '../expressions/xquery/XQueryErrors';
import astHelper, { IAST } from './astHelper';
import compileAstToExpression from './compileAstToExpression';
import { enhanceStaticContextWithModule } from './globalModuleCache';

export type ModuleDeclaration = {
        functionDeclarations: (FunctionDefinition | UpdatingFunctionDefinition)[];
        source: EvaluableExpression;
        variableDeclarations: VariableDeclaration[];
        /**
         * Perform static analysis on the module. the whole module is passed, with all additional
         * functions that are registered for this namespace
         */
        performStaticAnalysis(moduleContents: ModuleDeclaration): void;
};

const RESERVED_FUNCTION_NAMESPACE_URIS = [
        'http://www.w3.org/XML/1998/namespace',
        'http://www.w3.org/2001/XMLSchema',
        'http://www.w3.org/2001/XMLSchema-instance',
        'http://www.w3.org/2005/xpath-functions',
        'http://www.w3.org/2005/xpath-functions/math',
        'http://www.w3.org/2012/xquery',
        'http://www.w3.org/2005/xpath-functions/array',
        'http://www.w3.org/2005/xpath-functions/map',
];
export type FunctionDeclaration = {
        arity: number;
        expression: Expression;
        functionDefinition: GenericFunctionDefinition<
                boolean,
                FunctionDefinitionType | UpdatingFunctionDefinitionType
        >;
        localName: string;
        namespaceURI: string;
};
export type VariableDeclaration = {
        expression: Expression;
        localName: string;
        namespaceURI: string;
};

function processFunctionDefinition(
        declaration: IAST,
        staticContext: StaticContext,
        staticallyCompilableExpressions: { expression: Expression; staticContextLeaf: StaticContext }[],
        compiledFunctionDeclarations: FunctionDeclaration[],
        createExpressions: boolean
) {
        const functionName = astHelper.getFirstChild(declaration, 'functionName');
        const declarationPrefix = (astHelper.getAttribute(functionName, 'prefix') || '') as string;
        let declarationNamespaceURI = astHelper.getAttribute(functionName, 'URI') as string;
        const declarationLocalName = astHelper.getTextContent(functionName);

        if (declarationNamespaceURI === null) {
                // Note: Never use the function namespace resolver to resolve the name of a function
                // declaration.
                if (declarationPrefix === '') {
                        declarationNamespaceURI =
                                staticContext.registeredDefaultFunctionNamespaceURI === null
                                        ? BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI
                                        : staticContext.registeredDefaultFunctionNamespaceURI;
                } else {
                        declarationNamespaceURI = staticContext.resolveNamespace(declarationPrefix);
                }

                if (!declarationNamespaceURI && declarationPrefix) {
                        throw errXPST0081(declarationPrefix);
                }
        }

        if (RESERVED_FUNCTION_NAMESPACE_URIS.includes(declarationNamespaceURI)) {
                throw errXQST0045();
        }

        // Functions are public unless they're private
        const annotations = astHelper
                .getChildren(declaration, 'annotation')
                .map((annotation) => astHelper.getFirstChild(annotation, 'annotationName'));
        const isPublicDeclaration = annotations.every(
                (annotationName) =>
                        !astHelper.getAttribute(annotationName, 'URI') &&
                        astHelper.getTextContent(annotationName) !== 'private'
        );
        const isUpdatingFunction = annotations.some(
                (annotationName) =>
                        !astHelper.getAttribute(annotationName, 'URI') &&
                        astHelper.getTextContent(annotationName) === 'updating'
        );

        if (!declarationNamespaceURI) {
                throw errXQST0060();
        }

        const returnType: SequenceType = astHelper.getTypeDeclaration(declaration);
        const params = astHelper.getChildren(
                astHelper.getFirstChild(declaration, 'paramList'),
                'param'
        );
        const paramNames = params.map((param) => astHelper.getFirstChild(param, 'varName'));
        const paramTypes: SequenceType[] = params.map((param) => astHelper.getTypeDeclaration(param));

        let functionDefinition: GenericFunctionDefinition<any, any>;
        const functionBody = astHelper.getFirstChild(declaration, 'functionBody');
        if (functionBody) {
                if (
                        staticContext.lookupFunction(
                                declarationNamespaceURI,
                                declarationLocalName,
                                paramTypes.length
                        )
                ) {
                        throw new Error(
                                `XQST0049: The function Q{${declarationNamespaceURI}}${declarationLocalName}#${paramTypes.length} has already been declared.`
                        );
                }

                if (!createExpressions) {
                        return;
                }

                // functionBody usually has a single expression
                const body = functionBody[1];
                const compiledFunctionBody = compileAstToExpression(body as IAST, {
                        allowUpdating: false,
                        allowXQuery: true,
                });

                const staticContextLeaf = new StaticContext(staticContext);
                const parameterBindingNames = paramNames.map((param) => {
                        let namespaceURI = astHelper.getAttribute(param, 'URI') as string;
                        const prefix = astHelper.getAttribute(param, 'prefix') as string;
                        const localName = astHelper.getTextContent(param);

                        if (prefix && namespaceURI === null) {
                                namespaceURI = staticContext.resolveNamespace(prefix || '');
                        }
                        return staticContextLeaf.registerVariable(namespaceURI, localName);
                });

                if (isUpdatingFunction) {
                        const executeFunction: UpdatingFunctionDefinitionType = (
                                dynamicContext: DynamicContext,
                                executionParameters: ExecutionParameters,
                                _staticContext: StaticContext,
                                ...parameters: ISequence[]
                        ) => {
                                const scopedDynamicContext = dynamicContext
                                        .scopeWithFocus(-1, null, sequenceFactory.empty())
                                        .scopeWithVariableBindings(
                                                parameterBindingNames.reduce((paramByName, bindingName, i) => {
                                                        paramByName[bindingName] = createDoublyIterableSequence(parameters[i]);
                                                        return paramByName;
                                                }, Object.create(null))
                                        );
                                return (compiledFunctionBody as UpdatingExpression).evaluateWithUpdateList(
                                        scopedDynamicContext,
                                        executionParameters
                                );
                        };

                        functionDefinition = {
                                argumentTypes: paramTypes,
                                arity: paramNames.length,
                                callFunction: executeFunction,
                                isExternal: false,
                                isUpdating: true,
                                localName: declarationLocalName,
                                namespaceURI: declarationNamespaceURI,
                                returnType,
                        };
                } else {
                        const executeFunction: FunctionDefinitionType = (
                                dynamicContext: DynamicContext,
                                executionParameters: ExecutionParameters,
                                _staticContext: StaticContext,
                                ...parameters: ISequence[]
                        ): ISequence => {
                                const scopedDynamicContext = dynamicContext
                                        .scopeWithFocus(-1, null, sequenceFactory.empty())
                                        .scopeWithVariableBindings(
                                                parameterBindingNames.reduce((paramByName, bindingName, i) => {
                                                        paramByName[bindingName] = createDoublyIterableSequence(parameters[i]);
                                                        return paramByName;
                                                }, Object.create(null))
                                        );
                                return compiledFunctionBody.evaluateMaybeStatically(
                                        scopedDynamicContext,
                                        executionParameters
                                );
                        };

                        functionDefinition = {
                                argumentTypes: paramTypes,
                                arity: paramNames.length,
                                callFunction: executeFunction,
                                isExternal: false,
                                isUpdating: false,
                                localName: declarationLocalName,
                                namespaceURI: declarationNamespaceURI,
                                returnType,
                        };
                }

                staticallyCompilableExpressions.push({
                        expression: compiledFunctionBody,
                        staticContextLeaf,
                });

                // Only mark the registration as the public API for the module if it's public
                compiledFunctionDeclarations.push({
                        arity: paramNames.length,
                        expression: compiledFunctionBody,
                        functionDefinition,
                        localName: declarationLocalName,
                        namespaceURI: declarationNamespaceURI,
                });
        } else {
                if (isUpdatingFunction) {
                        throw new Error('Updating external function declarations are not supported');
                }

                // This must be an exteral declaration. This function will be declared using
                // registerCustomXPathFunction, making it globally available later on. We do register
                // a "proxy" function definition here so it doesn't matter whether that implementation
                // is defined before or after this module has been registered.
                const executeFunction: FunctionDefinitionType = (
                        dynamicContext: DynamicContext,
                        executionParameters: ExecutionParameters,
                        innerStaticContext: StaticContext,
                        ...parameters: ISequence[]
                ): ISequence => {
                        const actualFunctionProperties = innerStaticContext.lookupFunction(
                                declarationNamespaceURI,
                                declarationLocalName,
                                paramNames.length,
                                true
                        );
                        if (!actualFunctionProperties) {
                                throw new Error(
                                        `XPST0017: Function Q{${declarationNamespaceURI}}${declarationLocalName} with arity of ${
                                                paramNames.length
                                        } not registered. ${getAlternativesAsStringFor(declarationLocalName)}`
                                );
                        }

                        if (
                                actualFunctionProperties.returnType.type !== returnType.type ||
                                actualFunctionProperties.argumentTypes.some(
                                        // TODO: what do we do with any RestArguments here?
                                        // It seems that callFunction in FunctionCall.ts performs a similar cast...
                                        (type, i) => (type as SequenceType).type !== paramTypes[i].type
                                )
                        ) {
                                throw new Error('External function declaration types do not match actual function');
                        }

                        return actualFunctionProperties.callFunction(
                                dynamicContext,
                                executionParameters,
                                innerStaticContext,
                                ...parameters
                        );
                };

                functionDefinition = {
                        argumentTypes: paramTypes,
                        arity: paramNames.length,
                        callFunction: executeFunction,
                        isExternal: true,
                        isUpdating: false,
                        localName: declarationLocalName,
                        namespaceURI: declarationNamespaceURI,
                        returnType,
                };
        }

        staticContext.registerFunctionDefinition(
                declarationNamespaceURI,
                declarationLocalName,
                paramNames.length,
                functionDefinition
        );
}

/**
 * Process an XQuery prolog, preparing a static context from it
 *
 * @param  prolog            - The AST to process
 * @param  staticContext     - The static context to extend
 * @param  createExpressions - Whether to compile the prolog as well. If we are just parsing there is no need to create expressions already
 * @param   moduleString      - The string of the module. Used for error reporting if a compilation failed
 */
export default function processProlog(
        prolog: IAST,
        staticContext: StaticContext,
        createExpressions: boolean,
        moduleString: EvaluableExpression
): ModuleDeclaration {
        const staticallyCompilableExpressions: {
                expression: Expression;
                staticContextLeaf: StaticContext;
        }[] = [];

        const compiledFunctionDeclarations: FunctionDeclaration[] = [];
        astHelper.getChildren(prolog, '*').forEach((feature) => {
                switch (feature[0]) {
                        case 'moduleImport':
                        case 'namespaceDecl':
                        case 'defaultNamespaceDecl':
                        case 'functionDecl':
                        case 'varDecl':
                                break;
                        default:
                                throw new Error(
                                        'Not implemented: only module imports, namespace declarations, and function declarations are implemented in XQuery modules'
                                );
                }
        });

        // First, let's import modules
        const importedModuleNamespaces = new Set<string>();
        astHelper.getChildren(prolog, 'moduleImport').forEach((moduleImport) => {
                const moduleImportPrefix = astHelper.getTextContent(
                        astHelper.getFirstChild(moduleImport, 'namespacePrefix')
                );
                const moduleImportNamespaceURI = astHelper.getTextContent(
                        astHelper.getFirstChild(moduleImport, 'targetNamespace')
                );

                if (importedModuleNamespaces.has(moduleImportNamespaceURI)) {
                        throw errXQST0047(moduleImportNamespaceURI);
                }
                importedModuleNamespaces.add(moduleImportNamespaceURI);

                staticContext.registerNamespace(moduleImportPrefix, moduleImportNamespaceURI);
                enhanceStaticContextWithModule(staticContext, moduleImportNamespaceURI);
        });

        astHelper.getChildren(prolog, 'namespaceDecl').forEach((namespaceDecl) => {
                const prefix = astHelper.getTextContent(astHelper.getFirstChild(namespaceDecl, 'prefix'));
                const namespaceURI = astHelper.getTextContent(
                        astHelper.getFirstChild(namespaceDecl, 'uri')
                );

                if (prefix === 'xml' || prefix === 'xmlns') {
                        throw errXQST0070();
                }

                if (
                        namespaceURI === BUILT_IN_NAMESPACE_URIS.XML_NAMESPACE_URI ||
                        namespaceURI === BUILT_IN_NAMESPACE_URIS.XMLNS_NAMESPACE_URI
                ) {
                        throw errXQST0070();
                }

                staticContext.registerNamespace(prefix, namespaceURI);
        });

        // Default function namespace declaration
        let defaultNamespaceFunctionDecl: string = null;
        let defaultNamespaceElementDecl: string = null;

        for (const astNode of astHelper.getChildren(prolog, 'defaultNamespaceDecl')) {
                const category = astHelper.getTextContent(
                        astHelper.getFirstChild(astNode, 'defaultNamespaceCategory')
                );

                const namespaceURI = astHelper.getTextContent(astHelper.getFirstChild(astNode, 'uri'));

                if (!namespaceURI) {
                        throw errXQST0060();
                }

                if (
                        namespaceURI === BUILT_IN_NAMESPACE_URIS.XML_NAMESPACE_URI ||
                        namespaceURI === BUILT_IN_NAMESPACE_URIS.XMLNS_NAMESPACE_URI
                ) {
                        throw errXQST0070();
                }

                if (category === 'function') {
                        if (defaultNamespaceFunctionDecl) {
                                throw errXQST0066();
                        }
                        defaultNamespaceFunctionDecl = namespaceURI;
                } else if (category === 'element') {
                        if (defaultNamespaceElementDecl) {
                                throw errXQST0066();
                        }
                        defaultNamespaceElementDecl = namespaceURI;
                }
        }

        if (defaultNamespaceFunctionDecl) {
                staticContext.registeredDefaultFunctionNamespaceURI = defaultNamespaceFunctionDecl;
        }
        if (defaultNamespaceElementDecl) {
                staticContext.registerNamespace('', defaultNamespaceElementDecl);
        }

        astHelper.getChildren(prolog, 'functionDecl').forEach((declaration) => {
                processFunctionDefinition(
                        declaration,
                        staticContext,
                        staticallyCompilableExpressions,
                        compiledFunctionDeclarations,
                        createExpressions
                );
        });

        const registeredVariables: VariableDeclaration[] = [];
        astHelper.getChildren(prolog, 'varDecl').forEach((varDecl) => {
                const varName = astHelper.getQName(astHelper.getFirstChild(varDecl, 'varName'));
                let declarationNamespaceURI = varName.namespaceURI;
                if (declarationNamespaceURI === null) {
                        declarationNamespaceURI = staticContext.resolveNamespace(varName.prefix);

                        if (!declarationNamespaceURI && varName.prefix) {
                                throw errXPST0081(varName.prefix);
                        }
                }

                if (RESERVED_FUNCTION_NAMESPACE_URIS.includes(declarationNamespaceURI)) {
                        throw errXQST0045();
                }
                const external = astHelper.getFirstChild(varDecl, 'external');
                const getVarValue = astHelper.getFirstChild(varDecl, 'varValue');

                let varValue: IAST;
                let compiledVariableAsExpression: Expression;

                if (external !== null) {
                        const varDefaultValue = astHelper.getFirstChild(external, 'varValue');
                        if (varDefaultValue !== null) {
                                varValue = astHelper.getFirstChild(varDefaultValue, '*');
                        }
                } else if (getVarValue !== null) {
                        varValue = astHelper.getFirstChild(getVarValue, '*');
                }

                if (
                        registeredVariables.some(
                                (registered) =>
                                        registered.namespaceURI === declarationNamespaceURI &&
                                        registered.localName === varName.localName
                        )
                ) {
                        throw new Error(
                                `XQST0049: The variable ${
                                        declarationNamespaceURI ? `Q{${declarationNamespaceURI}}` : ''
                                }${varName.localName} has already been declared.`
                        );
                }

                staticContext.registerVariable(declarationNamespaceURI || '', varName.localName);
                if (!createExpressions) {
                        return;
                }

                if (varValue) {
                        compiledVariableAsExpression = compileAstToExpression(varValue as IAST, {
                                allowUpdating: false,
                                allowXQuery: true,
                        });
                }

                if (
                        varValue &&
                        !staticContext.lookupVariableValue(declarationNamespaceURI || '', varName.localName)
                ) {
                        let cachedVariableValue: () => ISequence | null = null;
                        staticContext.registerVariableDeclaration(
                                declarationNamespaceURI,
                                varName.localName,
                                (dynamicContext, executionParameters) => {
                                        if (cachedVariableValue) {
                                                return cachedVariableValue();
                                        }
                                        cachedVariableValue = createDoublyIterableSequence(
                                                compiledVariableAsExpression.evaluateMaybeStatically(
                                                        dynamicContext,
                                                        executionParameters
                                                )
                                        );
                                        return cachedVariableValue();
                                }
                        );
                        staticallyCompilableExpressions.push({
                                expression: compiledVariableAsExpression,
                                staticContextLeaf: staticContext,
                        });

                        registeredVariables.push({
                                expression: compiledVariableAsExpression,
                                localName: varName.localName,
                                namespaceURI: declarationNamespaceURI,
                        });
                }
        });

        compiledFunctionDeclarations.forEach((compiledFunctionDeclaration) => {
                if (
                        !compiledFunctionDeclaration.functionDefinition.isUpdating &&
                        compiledFunctionDeclaration.expression.isUpdating
                ) {
                        throw errXUST0001(
                                `The function Q{${compiledFunctionDeclaration.namespaceURI}}${compiledFunctionDeclaration.localName} is updating but the %updating annotation is missing.`
                        );
                }
        });

        return {
                functionDeclarations: compiledFunctionDeclarations.map(
                        (declaration) =>
                                declaration.functionDefinition as UpdatingFunctionDefinition | FunctionDefinition
                ),
                variableDeclarations: registeredVariables,
                source: moduleString,
                performStaticAnalysis: (moduleContents: ModuleDeclaration) => {
                        staticallyCompilableExpressions.forEach(({ expression, staticContextLeaf }) => {
                                importedModuleNamespaces.forEach((namespaceURI) => {
                                        enhanceStaticContextWithModule(staticContextLeaf, namespaceURI);
                                });
                                moduleContents.functionDeclarations.forEach((funDecl) => {
                                        if (
                                                staticContextLeaf.lookupFunction(
                                                        funDecl.namespaceURI,
                                                        funDecl.localName,
                                                        funDecl.arity,
                                                        true
                                                )
                                        ) {
                                                return;
                                        }
                                        staticContextLeaf.registerFunctionDefinition(
                                                funDecl.namespaceURI,
                                                funDecl.localName,
                                                funDecl.arity,
                                                funDecl
                                        );
                                });
                                moduleContents.variableDeclarations.forEach((varDecl) => {
                                        if (staticContextLeaf.lookupVariable(varDecl.namespaceURI, varDecl.localName)) {
                                                return;
                                        }
                                        staticContextLeaf.registerVariable(varDecl.namespaceURI, varDecl.localName);
                                });

                                expression.performStaticEvaluation(staticContextLeaf);
                        });
                },
        };
}

1	import type { EvaluableExpression } from '../evaluateXPath';
2	import ISequence from '../expressions/dataTypes/ISequence';
3	import sequenceFactory from '../expressions/dataTypes/sequenceFactory';	9✔
4	import type { SequenceType } from '../expressions/dataTypes/Value';
5	import DynamicContext from '../expressions/DynamicContext';
6	import ExecutionParameters from '../expressions/ExecutionParameters';
7	import Expression from '../expressions/Expression';
8	import FunctionDefinitionType from '../expressions/functions/FunctionDefinitionType';
9	import { getAlternativesAsStringFor } from '../expressions/functions/functionRegistry';	9✔
10	import { BUILT_IN_NAMESPACE_URIS } from '../expressions/staticallyKnownNamespaces';
11	import StaticContext, {	9✔
12	FunctionDefinition,
13	GenericFunctionDefinition,
14	UpdatingFunctionDefinition,
15	} from '../expressions/StaticContext';
16	import createDoublyIterableSequence from '../expressions/util/createDoublyIterableSequence';	9✔
17	import UpdatingExpression from '../expressions/xquery-update/UpdatingExpression';
18	import UpdatingFunctionDefinitionType from '../expressions/xquery-update/UpdatingFunctionDefinitionType';
19	import { errXUST0001 } from '../expressions/xquery-update/XQueryUpdateFacilityErrors';	9✔
20	import {	9✔
21	errXPST0081,
22	errXQST0045,
23	errXQST0047,
24	errXQST0060,
25	errXQST0066,
26	errXQST0070,
27	} from '../expressions/xquery/XQueryErrors';
28	import astHelper, { IAST } from './astHelper';	9✔
29	import compileAstToExpression from './compileAstToExpression';	9✔
30	import { enhanceStaticContextWithModule } from './globalModuleCache';	9✔
31
32	export type ModuleDeclaration = {
33	functionDeclarations: (FunctionDefinition \| UpdatingFunctionDefinition)[];
34	source: EvaluableExpression;
35	variableDeclarations: VariableDeclaration[];
36	/**
37	* Perform static analysis on the module. the whole module is passed, with all additional
38	* functions that are registered for this namespace
39	*/
40	performStaticAnalysis(moduleContents: ModuleDeclaration): void;
41	};
42
43	const RESERVED_FUNCTION_NAMESPACE_URIS = [	9✔
44	'http://www.w3.org/XML/1998/namespace',
45	'http://www.w3.org/2001/XMLSchema',
46	'http://www.w3.org/2001/XMLSchema-instance',
47	'http://www.w3.org/2005/xpath-functions',
48	'http://www.w3.org/2005/xpath-functions/math',
49	'http://www.w3.org/2012/xquery',
50	'http://www.w3.org/2005/xpath-functions/array',
51	'http://www.w3.org/2005/xpath-functions/map',
52	];
53	export type FunctionDeclaration = {
54	arity: number;
55	expression: Expression;
56	functionDefinition: GenericFunctionDefinition<
57	boolean,
58	FunctionDefinitionType \| UpdatingFunctionDefinitionType
59	>;
60	localName: string;
61	namespaceURI: string;
62	};
63	export type VariableDeclaration = {
64	expression: Expression;
65	localName: string;
66	namespaceURI: string;
67	};
68
69	function processFunctionDefinition(
70	declaration: IAST,
71	staticContext: StaticContext,
72	staticallyCompilableExpressions: { expression: Expression; staticContextLeaf: StaticContext }[],
73	compiledFunctionDeclarations: FunctionDeclaration[],
74	createExpressions: boolean
75	) {
76	const functionName = astHelper.getFirstChild(declaration, 'functionName');	309✔
77	const declarationPrefix = (astHelper.getAttribute(functionName, 'prefix') \|\| '') as string;	309✔
78	let declarationNamespaceURI = astHelper.getAttribute(functionName, 'URI') as string;	309✔
79	const declarationLocalName = astHelper.getTextContent(functionName);	309✔
80
81	if (declarationNamespaceURI === null) {	309✔
82	// Note: Never use the function namespace resolver to resolve the name of a function
83	// declaration.
84	if (declarationPrefix === '') {	306✔
85	declarationNamespaceURI =	27✔
86	staticContext.registeredDefaultFunctionNamespaceURI === null	27✔
87	? BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI
88	: staticContext.registeredDefaultFunctionNamespaceURI;
89	} else {
90	declarationNamespaceURI = staticContext.resolveNamespace(declarationPrefix);	279✔
91	}
92
93	if (!declarationNamespaceURI && declarationPrefix) {	306!
UNCOV 94	throw errXPST0081(declarationPrefix);	×
95	}
96	}
97
98	if (RESERVED_FUNCTION_NAMESPACE_URIS.includes(declarationNamespaceURI)) {	309✔
99	throw errXQST0045();	3✔
100	}
101
102	// Functions are public unless they're private
103	const annotations = astHelper	306✔
104	.getChildren(declaration, 'annotation')
105	.map((annotation) => astHelper.getFirstChild(annotation, 'annotationName'));	165✔
106	const isPublicDeclaration = annotations.every(	306✔
107	(annotationName) =>
108	!astHelper.getAttribute(annotationName, 'URI') &&	165✔
109	astHelper.getTextContent(annotationName) !== 'private'
110	);
111	const isUpdatingFunction = annotations.some(	306✔
112	(annotationName) =>
113	!astHelper.getAttribute(annotationName, 'URI') &&	165✔
114	astHelper.getTextContent(annotationName) === 'updating'
115	);
116
117	if (!declarationNamespaceURI) {	306!
UNCOV 118	throw errXQST0060();	×
119	}
120
121	const returnType: SequenceType = astHelper.getTypeDeclaration(declaration);	306✔
122	const params = astHelper.getChildren(	306✔
123	astHelper.getFirstChild(declaration, 'paramList'),
124	'param'
125	);
126	const paramNames = params.map((param) => astHelper.getFirstChild(param, 'varName'));	306✔
127	const paramTypes: SequenceType[] = params.map((param) => astHelper.getTypeDeclaration(param));	306✔
128
129	let functionDefinition: GenericFunctionDefinition<any, any>;
130	const functionBody = astHelper.getFirstChild(declaration, 'functionBody');	306✔
131	if (functionBody) {	306✔
132	if (	288✔
133	staticContext.lookupFunction(
134	declarationNamespaceURI,
135	declarationLocalName,
136	paramTypes.length
137	)
138	) {
139	throw new Error(	3✔
140	`XQST0049: The function Q{${declarationNamespaceURI}}${declarationLocalName}#${paramTypes.length} has already been declared.`
141	);
142	}
143
144	if (!createExpressions) {	285✔
145	return;	93✔
146	}
147
148	// functionBody usually has a single expression
149	const body = functionBody[1];	192✔
150	const compiledFunctionBody = compileAstToExpression(body as IAST, {	192✔
151	allowUpdating: false,
152	allowXQuery: true,
153	});
154
155	const staticContextLeaf = new StaticContext(staticContext);	192✔
156	const parameterBindingNames = paramNames.map((param) => {	192✔
157	let namespaceURI = astHelper.getAttribute(param, 'URI') as string;	168✔
158	const prefix = astHelper.getAttribute(param, 'prefix') as string;	168✔
159	const localName = astHelper.getTextContent(param);	168✔
160
161	if (prefix && namespaceURI === null) {	168!
UNCOV 162	namespaceURI = staticContext.resolveNamespace(prefix \|\| '');	×
163	}
164	return staticContextLeaf.registerVariable(namespaceURI, localName);	168✔
165	});
166
167	if (isUpdatingFunction) {	192✔
168	const executeFunction: UpdatingFunctionDefinitionType = (	75✔
169	dynamicContext: DynamicContext,
170	executionParameters: ExecutionParameters,
171	_staticContext: StaticContext,
172	...parameters: ISequence[]
173	) => {
174	const scopedDynamicContext = dynamicContext	93✔
175	.scopeWithFocus(-1, null, sequenceFactory.empty())
176	.scopeWithVariableBindings(
177	parameterBindingNames.reduce((paramByName, bindingName, i) => {
178	paramByName[bindingName] = createDoublyIterableSequence(parameters[i]);	93✔
179	return paramByName;	93✔
180	}, Object.create(null))
181	);
182	return (compiledFunctionBody as UpdatingExpression).evaluateWithUpdateList(	93✔
183	scopedDynamicContext,
184	executionParameters
185	);
186	};
187
188	functionDefinition = {	75✔
189	argumentTypes: paramTypes,
190	arity: paramNames.length,
191	callFunction: executeFunction,
192	isExternal: false,
193	isUpdating: true,
194	localName: declarationLocalName,
195	namespaceURI: declarationNamespaceURI,
196	returnType,
197	};
198	} else {
199	const executeFunction: FunctionDefinitionType = (	117✔
200	dynamicContext: DynamicContext,
201	executionParameters: ExecutionParameters,
202	_staticContext: StaticContext,
203	...parameters: ISequence[]
204	): ISequence => {
205	const scopedDynamicContext = dynamicContext	10,017✔
206	.scopeWithFocus(-1, null, sequenceFactory.empty())
207	.scopeWithVariableBindings(
208	parameterBindingNames.reduce((paramByName, bindingName, i) => {
209	paramByName[bindingName] = createDoublyIterableSequence(parameters[i]);	14,940✔
210	return paramByName;	14,940✔
211	}, Object.create(null))
212	);
213	return compiledFunctionBody.evaluateMaybeStatically(	10,017✔
214	scopedDynamicContext,
215	executionParameters
216	);
217	};
218
219	functionDefinition = {	117✔
220	argumentTypes: paramTypes,
221	arity: paramNames.length,
222	callFunction: executeFunction,
223	isExternal: false,
224	isUpdating: false,
225	localName: declarationLocalName,
226	namespaceURI: declarationNamespaceURI,
227	returnType,
228	};
229	}
230
231	staticallyCompilableExpressions.push({	192✔
232	expression: compiledFunctionBody,
233	staticContextLeaf,
234	});
235
236	// Only mark the registration as the public API for the module if it's public
237	compiledFunctionDeclarations.push({	192✔
238	arity: paramNames.length,
239	expression: compiledFunctionBody,
240	functionDefinition,
241	localName: declarationLocalName,
242	namespaceURI: declarationNamespaceURI,
243	});
244	} else {
245	if (isUpdatingFunction) {	18✔
246	throw new Error('Updating external function declarations are not supported');	3✔
247	}
248
249	// This must be an exteral declaration. This function will be declared using
250	// registerCustomXPathFunction, making it globally available later on. We do register
251	// a "proxy" function definition here so it doesn't matter whether that implementation
252	// is defined before or after this module has been registered.
253	const executeFunction: FunctionDefinitionType = (	15✔
254	dynamicContext: DynamicContext,
255	executionParameters: ExecutionParameters,
256	innerStaticContext: StaticContext,
257	...parameters: ISequence[]
258	): ISequence => {
259	const actualFunctionProperties = innerStaticContext.lookupFunction(	12✔
260	declarationNamespaceURI,
261	declarationLocalName,
262	paramNames.length,
263	true
264	);
265	if (!actualFunctionProperties) {	12✔
266	throw new Error(	3✔
267	`XPST0017: Function Q{${declarationNamespaceURI}}${declarationLocalName} with arity of ${
268	paramNames.length
269	} not registered. ${getAlternativesAsStringFor(declarationLocalName)}`
270	);
271	}
272
273	if (	9✔
274	actualFunctionProperties.returnType.type !== returnType.type \|\|	15✔
275	actualFunctionProperties.argumentTypes.some(
276	// TODO: what do we do with any RestArguments here?
277	// It seems that callFunction in FunctionCall.ts performs a similar cast...
278	(type, i) => (type as SequenceType).type !== paramTypes[i].type	3✔
279	)
280	) {
281	throw new Error('External function declaration types do not match actual function');	6✔
282	}
283
284	return actualFunctionProperties.callFunction(	3✔
285	dynamicContext,
286	executionParameters,
287	innerStaticContext,
288	...parameters
289	);
290	};
291
292	functionDefinition = {	15✔
293	argumentTypes: paramTypes,
294	arity: paramNames.length,
295	callFunction: executeFunction,
296	isExternal: true,
297	isUpdating: false,
298	localName: declarationLocalName,
299	namespaceURI: declarationNamespaceURI,
300	returnType,
301	};
302	}
303
304	staticContext.registerFunctionDefinition(	207✔
305	declarationNamespaceURI,
306	declarationLocalName,
307	paramNames.length,
308	functionDefinition
309	);
310	}
311
312	/**
313	* Process an XQuery prolog, preparing a static context from it
314	*
315	* @param prolog - The AST to process
316	* @param staticContext - The static context to extend
317	* @param createExpressions - Whether to compile the prolog as well. If we are just parsing there is no need to create expressions already
318	* @param moduleString - The string of the module. Used for error reporting if a compilation failed
319	*/
320	export default function processProlog(	9✔
321	prolog: IAST,
322	staticContext: StaticContext,
323	createExpressions: boolean,
324	moduleString: EvaluableExpression
325	): ModuleDeclaration {
326	const staticallyCompilableExpressions: {
327	expression: Expression;
328	staticContextLeaf: StaticContext;
329	}[] = [];	10,017✔
330
331	const compiledFunctionDeclarations: FunctionDeclaration[] = [];	10,017✔
332	astHelper.getChildren(prolog, '*').forEach((feature) => {	10,017✔
333	switch (feature[0]) {	11,619!
334	case 'moduleImport':
335	case 'namespaceDecl':
336	case 'defaultNamespaceDecl':
337	case 'functionDecl':
338	case 'varDecl':
339	break;	11,619✔
340	default:
UNCOV 341	throw new Error(	×
342	'Not implemented: only module imports, namespace declarations, and function declarations are implemented in XQuery modules'
343	);
344	}
345	});
346
347	// First, let's import modules
348	const importedModuleNamespaces = new Set<string>();	10,017✔
349	astHelper.getChildren(prolog, 'moduleImport').forEach((moduleImport) => {	10,017✔
350	const moduleImportPrefix = astHelper.getTextContent(	39✔
351	astHelper.getFirstChild(moduleImport, 'namespacePrefix')
352	);
353	const moduleImportNamespaceURI = astHelper.getTextContent(	39✔
354	astHelper.getFirstChild(moduleImport, 'targetNamespace')
355	);
356
357	if (importedModuleNamespaces.has(moduleImportNamespaceURI)) {	39✔
358	throw errXQST0047(moduleImportNamespaceURI);	3✔
359	}
360	importedModuleNamespaces.add(moduleImportNamespaceURI);	36✔
361
362	staticContext.registerNamespace(moduleImportPrefix, moduleImportNamespaceURI);	36✔
363	enhanceStaticContextWithModule(staticContext, moduleImportNamespaceURI);	36✔
364	});
365
366	astHelper.getChildren(prolog, 'namespaceDecl').forEach((namespaceDecl) => {	10,011✔
367	const prefix = astHelper.getTextContent(astHelper.getFirstChild(namespaceDecl, 'prefix'));	918✔
368	const namespaceURI = astHelper.getTextContent(	918✔
369	astHelper.getFirstChild(namespaceDecl, 'uri')
370	);
371
372	if (prefix === 'xml' \|\| prefix === 'xmlns') {	918!
UNCOV 373	throw errXQST0070();	×
374	}
375
376	if (	918!
377	namespaceURI === BUILT_IN_NAMESPACE_URIS.XML_NAMESPACE_URI \|\|	1,836✔
378	namespaceURI === BUILT_IN_NAMESPACE_URIS.XMLNS_NAMESPACE_URI
379	) {
UNCOV 380	throw errXQST0070();	×
381	}
382
383	staticContext.registerNamespace(prefix, namespaceURI);	918✔
384	});
385
386	// Default function namespace declaration
387	let defaultNamespaceFunctionDecl: string = null;	10,011✔
388	let defaultNamespaceElementDecl: string = null;	10,011✔
389
390	for (const astNode of astHelper.getChildren(prolog, 'defaultNamespaceDecl')) {	10,011✔
391	const category = astHelper.getTextContent(	159✔
392	astHelper.getFirstChild(astNode, 'defaultNamespaceCategory')
393	);
394
395	const namespaceURI = astHelper.getTextContent(astHelper.getFirstChild(astNode, 'uri'));	159✔
396
397	if (!namespaceURI) {	159!
UNCOV 398	throw errXQST0060();	×
399	}
400
401	if (	159✔
402	namespaceURI === BUILT_IN_NAMESPACE_URIS.XML_NAMESPACE_URI \|\|	315✔
403	namespaceURI === BUILT_IN_NAMESPACE_URIS.XMLNS_NAMESPACE_URI
404	) {
405	throw errXQST0070();	3✔
406	}
407
408	if (category === 'function') {	156✔
409	if (defaultNamespaceFunctionDecl) {	42✔
410	throw errXQST0066();	3✔
411	}
412	defaultNamespaceFunctionDecl = namespaceURI;	39✔
413	} else if (category === 'element') {	114!
414	if (defaultNamespaceElementDecl) {	114!
UNCOV 415	throw errXQST0066();	×
416	}
417	defaultNamespaceElementDecl = namespaceURI;	114✔
418	}
419	}
420
421	if (defaultNamespaceFunctionDecl) {	10,005✔
422	staticContext.registeredDefaultFunctionNamespaceURI = defaultNamespaceFunctionDecl;	36✔
423	}
424	if (defaultNamespaceElementDecl) {	10,005✔
425	staticContext.registerNamespace('', defaultNamespaceElementDecl);	114✔
426	}
427
428	astHelper.getChildren(prolog, 'functionDecl').forEach((declaration) => {	10,005✔
429	processFunctionDefinition(	309✔
430	declaration,
431	staticContext,
432	staticallyCompilableExpressions,
433	compiledFunctionDeclarations,
434	createExpressions
435	);
436	});
437
438	const registeredVariables: VariableDeclaration[] = [];	9,996✔
439	astHelper.getChildren(prolog, 'varDecl').forEach((varDecl) => {	9,996✔
440	const varName = astHelper.getQName(astHelper.getFirstChild(varDecl, 'varName'));	10,188✔
441	let declarationNamespaceURI = varName.namespaceURI;	10,188✔
442	if (declarationNamespaceURI === null) {	10,188✔
443	declarationNamespaceURI = staticContext.resolveNamespace(varName.prefix);	10,185✔
444
445	if (!declarationNamespaceURI && varName.prefix) {	10,185!
UNCOV 446	throw errXPST0081(varName.prefix);	×
447	}
448	}
449
450	if (RESERVED_FUNCTION_NAMESPACE_URIS.includes(declarationNamespaceURI)) {	10,188!
451	throw errXQST0045();	×
452	}
453	const external = astHelper.getFirstChild(varDecl, 'external');	10,188✔
454	const getVarValue = astHelper.getFirstChild(varDecl, 'varValue');	10,188✔
455
456	let varValue: IAST;
457	let compiledVariableAsExpression: Expression;
458
459	if (external !== null) {	10,188✔
460	const varDefaultValue = astHelper.getFirstChild(external, 'varValue');	10,056✔
461	if (varDefaultValue !== null) {	10,056✔
462	varValue = astHelper.getFirstChild(varDefaultValue, '*');	6✔
463	}
464	} else if (getVarValue !== null) {	132!
465	varValue = astHelper.getFirstChild(getVarValue, '*');	132✔
466	}
467
468	if (	10,188!
469	registeredVariables.some(
470	(registered) =>
471	registered.namespaceURI === declarationNamespaceURI &&	12✔
472	registered.localName === varName.localName
473	)
474	) {
UNCOV 475	throw new Error(	×
476	`XQST0049: The variable ${
477	declarationNamespaceURI ? `Q{${declarationNamespaceURI}}` : ''	×
478	}${varName.localName} has already been declared.`
479	);
480	}
481
482	staticContext.registerVariable(declarationNamespaceURI \|\| '', varName.localName);	10,188✔
483	if (!createExpressions) {	10,188✔
484	return;	5,301✔
485	}
486
487	if (varValue) {	4,887✔
488	compiledVariableAsExpression = compileAstToExpression(varValue as IAST, {	87✔
489	allowUpdating: false,
490	allowXQuery: true,
491	});
492	}
493
494	if (	4,887✔
495	varValue &&	4,974✔
496	!staticContext.lookupVariableValue(declarationNamespaceURI \|\| '', varName.localName)	162✔
497	) {
498	let cachedVariableValue: () => ISequence \| null = null;	87✔
499	staticContext.registerVariableDeclaration(	87✔
500	declarationNamespaceURI,
501	varName.localName,
502	(dynamicContext, executionParameters) => {
503	if (cachedVariableValue) {	84✔
504	return cachedVariableValue();	3✔
505	}
506	cachedVariableValue = createDoublyIterableSequence(	81✔
507	compiledVariableAsExpression.evaluateMaybeStatically(
508	dynamicContext,
509	executionParameters
510	)
511	);
512	return cachedVariableValue();	45✔
513	}
514	);
515	staticallyCompilableExpressions.push({	87✔
516	expression: compiledVariableAsExpression,
517	staticContextLeaf: staticContext,
518	});
519
520	registeredVariables.push({	87✔
521	expression: compiledVariableAsExpression,
522	localName: varName.localName,
523	namespaceURI: declarationNamespaceURI,
524	});
525	}
526	});
527
528	compiledFunctionDeclarations.forEach((compiledFunctionDeclaration) => {	9,996✔
529	if (	192✔
530	!compiledFunctionDeclaration.functionDefinition.isUpdating &&	309✔
531	compiledFunctionDeclaration.expression.isUpdating
532	) {
533	throw errXUST0001(	33✔
534	`The function Q{${compiledFunctionDeclaration.namespaceURI}}${compiledFunctionDeclaration.localName} is updating but the %updating annotation is missing.`
535	);
536	}
537	});
538
539	return {	9,963✔
540	functionDeclarations: compiledFunctionDeclarations.map(
541	(declaration) =>
542	declaration.functionDefinition as UpdatingFunctionDefinition \| FunctionDefinition	159✔
543	),
544	variableDeclarations: registeredVariables,
545	source: moduleString,
546	performStaticAnalysis: (moduleContents: ModuleDeclaration) => {
547	staticallyCompilableExpressions.forEach(({ expression, staticContextLeaf }) => {	4,836✔
548	importedModuleNamespaces.forEach((namespaceURI) => {	246✔
549	enhanceStaticContextWithModule(staticContextLeaf, namespaceURI);	6✔
550	});
551	moduleContents.functionDeclarations.forEach((funDecl) => {	246✔
552	if (	198✔
553	staticContextLeaf.lookupFunction(
554	funDecl.namespaceURI,
555	funDecl.localName,
556	funDecl.arity,
557	true
558	)
559	) {
560	return;	183✔
561	}
562	staticContextLeaf.registerFunctionDefinition(	15✔
563	funDecl.namespaceURI,
564	funDecl.localName,
565	funDecl.arity,
566	funDecl
567	);
568	});
569	moduleContents.variableDeclarations.forEach((varDecl) => {	246✔
570	if (staticContextLeaf.lookupVariable(varDecl.namespaceURI, varDecl.localName)) {	111!
571	return;	111✔
572	}
NEW 573	staticContextLeaf.registerVariable(varDecl.namespaceURI, varDecl.localName);	×
574	});
575
576	expression.performStaticEvaluation(staticContextLeaf);	246✔
577	});
578	},
579	};
580	}

FontoXML / fontoxpath / 3628388019

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous