3318962510

Build Type

push

github

Committed by Stef Busking

Commit Message

Directly emit true() and false()

Run Details

4870 of 5672 branches covered (85.86%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

8 existing lines in 1 file now uncovered.

10449 of 11091 relevant lines covered (94.21%)

32629.39 hits per line

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

87.02

/src/jsCodegen/emitFunctionCallExpr.ts

import isSubtypeOf from '../expressions/dataTypes/isSubtypeOf';
import { doesTypeAllowMultiple } from '../expressions/dataTypes/typeHelpers';
import {
        EllipsisType,
        ParameterType,
        SequenceType,
        ValueType,
        valueTypeToString,
} from '../expressions/dataTypes/Value';
import { getFunctionByArity } from '../expressions/functions/functionRegistry';
import { BUILT_IN_NAMESPACE_URIS } from '../expressions/staticallyKnownNamespaces';
import astHelper, { IAST } from '../parsing/astHelper';
import { CodeGenContext } from './CodeGenContext';
import {
        emitConversionToFirstNode,
        emitConversionToString,
        emitConversionToValue,
        emitEffectiveBooleanValue,
        mapPartialCompilationResult,
} from './emitHelpers';
import escapeJavaScriptString from './escapeJavaScriptString';
import {
        acceptAst,
        GeneratedCodeBaseType,
        PartialCompilationResult,
        rejectAst,
} from './JavaScriptCompiledXPath';

const supportedFunctions: Record<
        string,
        (
                ast: IAST,
                contextItemExpr: PartialCompilationResult,
                context: CodeGenContext
        ) => PartialCompilationResult
> = {
        'false#0': emitFalseFunction,
        'local-name#0': emitLocalNameFunction,
        'local-name#1': emitLocalNameFunction,
        'name#0': emitNameFunction,
        'name#1': emitNameFunction,
        'not#1': emitNotFunction,
        'true#0': emitTrueFunction,
};

// Built-in function allow list
// Namespaces not mentioned here are assumed to be custom functions, which are more limited in what
// they require (no static / dynamic context) and should be safe if their return and argument types
// are supported.
const supportedBuiltinFunctions: Record<string, string[]> = {
        [BUILT_IN_NAMESPACE_URIS.FONTOXPATH_NAMESPACE_URI]: ['version#0'],
        ['']: ['root#1', 'path#1'],
};

function emitFunctionArgumentConversion(
        argAst: IAST,
        requestedType: SequenceType,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): PartialCompilationResult {
        const [argExpr, _] = context.emitBaseExpr(argAst, contextItemExpr, context);
        const actualType = astHelper.getAttribute(argAst, 'type');
        if (doesTypeAllowMultiple(requestedType)) {
                return rejectAst('Not supported: sequence arguments with multiple items');
        }

        // TODO: emit runtime check that the actual sequence doesn't contain more than one item

        if (isSubtypeOf(requestedType.type, ValueType.NODE)) {
                return emitConversionToFirstNode(argExpr, actualType, contextItemExpr, context);
        }

        switch (requestedType.type) {
                case ValueType.ITEM:
                        return emitConversionToValue(argExpr, contextItemExpr, context);

                case ValueType.XSBOOLEAN:
                        return emitEffectiveBooleanValue(argExpr, actualType, contextItemExpr, context);

                case ValueType.XSSTRING:
                        return emitConversionToString(argExpr, actualType, contextItemExpr, context);
        }

        return rejectAst(
                `Argument types not supported: ${
                        actualType ? valueTypeToString(actualType.type) : 'unknown'
                } -> ${valueTypeToString(requestedType.type)}`
        );
}

function emitFunctionArgumentsConversion(
        argAsts: IAST[],
        argTypes: ParameterType[],
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): PartialCompilationResult {
        if (
                argAsts.length !== argTypes.length ||
                argTypes.some((type) => type === EllipsisType.ELLIPSIS)
        ) {
                return rejectAst('Not supported: variadic function or mismatch in argument count');
        }

        if (argAsts.length === 0) {
                return acceptAst('', { type: GeneratedCodeBaseType.Value }, []);
        }
        const [argAst, ...restArgAsts] = argAsts;
        const [type, ...restTypes] = argTypes;
        const argExpr = context.getIdentifierFor(
                emitFunctionArgumentConversion(
                        argAst,
                        // We checked for ELLIPSIS earlier, so all argument types are normal SequenceTypes
                        type as SequenceType,
                        contextItemExpr,
                        context
                ),
                'arg'
        );
        if (restArgAsts.length === 0) {
                return argExpr;
        }

        // Recurse and combine all arguments
        return mapPartialCompilationResult(argExpr, (argExpr) => {
                const argsExpr = emitFunctionArgumentsConversion(
                        restArgAsts,
                        restTypes,
                        contextItemExpr,
                        context
                );
                return mapPartialCompilationResult(argsExpr, (argsExpr) =>
                        acceptAst(`${argExpr.code}, ${argsExpr.code}`, { type: GeneratedCodeBaseType.Value }, [
                                ...argExpr.variables,
                                ...argsExpr.variables,
                        ])
                );
        });
}

function emitFunctionReturnTypeConversion(
        callFunctionExpr: PartialCompilationResult,
        returnType: SequenceType
) {
        return mapPartialCompilationResult(callFunctionExpr, (callFunctionExpr) => {
                // We support (zero or) one string, node or boolean
                if (
                        !doesTypeAllowMultiple(returnType) &&
                        ([ValueType.XSBOOLEAN, ValueType.XSSTRING].includes(returnType.type) ||
                                isSubtypeOf(returnType.type, ValueType.NODE))
                ) {
                        // Singleton string or empty sequence, handled by runtimeLib
                        return callFunctionExpr;
                }
                return rejectAst(
                        `Function return type ${valueTypeToString(returnType.type)} not supported`
                );
        });
}

export function emitFunctionCallExpr(
        ast: IAST,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): PartialCompilationResult {
        const { localName, namespaceURI } = astHelper.getQName(
                astHelper.getFirstChild(ast, 'functionName')
        );

        const argAsts = astHelper.getChildren(astHelper.getFirstChild(ast, 'arguments'), '*');
        const arity = argAsts.length;
        const functionNameAndArity = `${localName}#${arity}`;

        // First check if we have a codegen-specific implementation
        const isDefaultFunctionNamespace = namespaceURI === context.defaultFunctionNamespaceUri;
        if (isDefaultFunctionNamespace) {
                const emitFunctionCall = supportedFunctions[functionNameAndArity];
                if (emitFunctionCall !== undefined) {
                        return emitFunctionCall(ast, contextItemExpr, context);
                }
        }

        // Check allowlist
        const allowlist = supportedBuiltinFunctions[isDefaultFunctionNamespace ? '' : namespaceURI];
        if (allowlist) {
                // Function is built-in and must be allowed explicitly to be considered safe for codegen
                if (!allowlist.includes(functionNameAndArity)) {
                        return rejectAst(
                                `Not supported: built-in function not on allow list: ${functionNameAndArity}`
                        );
                }
        }

        // Then check registered functions
        const functionProperties = getFunctionByArity(namespaceURI, localName, arity);
        if (!functionProperties) {
                return rejectAst(`Unknown function / arity: ${functionNameAndArity}`);
        }

        // Should never happen, but let's check anyway
        if (functionProperties.isUpdating) {
                return rejectAst('Not supported: updating functions');
        }

        const argsExpr = emitFunctionArgumentsConversion(
                argAsts,
                functionProperties.argumentTypes,
                contextItemExpr,
                context
        );

        const callFunction = mapPartialCompilationResult(argsExpr, (argsExpr) =>
                acceptAst(
                        `runtimeLib.callFunction(domFacade, ${escapeJavaScriptString(
                                namespaceURI
                        )}, ${escapeJavaScriptString(localName)}, [${argsExpr.code}], options)`,
                        { type: GeneratedCodeBaseType.Value },
                        argsExpr.variables
                )
        );
        return emitFunctionReturnTypeConversion(callFunction, functionProperties.returnType);
}

function emitContextItemCheck(
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): PartialCompilationResult {
        return mapPartialCompilationResult(
                context.getIdentifierFor(contextItemExpr, 'contextItem'),
                (contextItemExpr) =>
                        acceptAst(contextItemExpr.code, { type: GeneratedCodeBaseType.Value }, [
                                ...contextItemExpr.variables,
                                `if (${contextItemExpr.code} === undefined || ${contextItemExpr.code} === null) {
                                        throw errXPDY0002('The function which was called depends on dynamic context, which is absent.');
                                }`,
                        ])
        );
}

function emitSpecificNameFunction(
        ast: IAST,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext,
        nameGetterFunction: (itemName: string) => string
): PartialCompilationResult {
        const argumentAst = astHelper.followPath(ast, ['arguments', '*']);
        let argExpr: PartialCompilationResult;
        // Handle explicit context item arg as the no-arguments version
        if (!argumentAst || argumentAst[0] === 'contextItemExpr') {
                // No args or '.' as arg - use the context item
                argExpr = emitContextItemCheck(contextItemExpr, context);
        } else {
                // One arg, should be a node
                const argType = astHelper.getAttribute(argumentAst, 'type');
                if (!argType || !isSubtypeOf(argType.type, ValueType.NODE)) {
                        return rejectAst('name function only implemented if arg is a node');
                }

                const [expr, _] = context.emitBaseExpr(argumentAst, contextItemExpr, context);
                argExpr = expr;
        }

        // TODO: this (and any other function call) should check multiplicity of the actual argument
        const argAsValue = emitConversionToValue(argExpr, contextItemExpr, context);
        return mapPartialCompilationResult(context.getIdentifierFor(argAsValue, 'arg'), (argAsValue) =>
                acceptAst(
                        `(${argAsValue.code} ? ${nameGetterFunction(argAsValue.code)} : '')`,
                        { type: GeneratedCodeBaseType.Value },
                        argAsValue.variables
                )
        );
}

function emitNameFunction(
        ast: IAST,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): PartialCompilationResult {
        return emitSpecificNameFunction(
                ast,
                contextItemExpr,
                context,
                (identifier) =>
                        `(((${identifier}.prefix || '').length !== 0 ? ${identifier}.prefix + ':' : '')
                + (${identifier}.localName || ${identifier}.target || ''))`
        );
}

function emitLocalNameFunction(
        ast: IAST,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): PartialCompilationResult {
        return emitSpecificNameFunction(
                ast,
                contextItemExpr,
                context,
                (identifier) => `(${identifier}.localName || ${identifier}.target || '')`
        );
}

function emitNotFunction(
        ast: IAST,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): PartialCompilationResult {
        const argumentAst = astHelper.followPath(ast, ['arguments', '*']);
        const argType = astHelper.getAttribute(argumentAst, 'type');
        const [argExpr, _] = context.emitBaseExpr(argumentAst, contextItemExpr, context);
        const argAsBool = emitEffectiveBooleanValue(argExpr, argType, contextItemExpr, context);
        return mapPartialCompilationResult(argAsBool, (argAsBool) =>
                acceptAst(`!${argAsBool.code}`, { type: GeneratedCodeBaseType.Value }, argAsBool.variables)
        );
}

function emitFalseFunction(
        _ast: IAST,
        _contextItemExpr: PartialCompilationResult,
        _context: CodeGenContext
): PartialCompilationResult {
        return acceptAst('false', { type: GeneratedCodeBaseType.Value }, []);
}

function emitTrueFunction(
        _ast: IAST,
        _contextItemExpr: PartialCompilationResult,
        _context: CodeGenContext
): PartialCompilationResult {
        return acceptAst('true', { type: GeneratedCodeBaseType.Value }, []);
}

1	import isSubtypeOf from '../expressions/dataTypes/isSubtypeOf';	3✔
2	import { doesTypeAllowMultiple } from '../expressions/dataTypes/typeHelpers';	3✔
3	import {	3✔
4	EllipsisType,
5	ParameterType,
6	SequenceType,
7	ValueType,
8	valueTypeToString,
9	} from '../expressions/dataTypes/Value';
10	import { getFunctionByArity } from '../expressions/functions/functionRegistry';	3✔
11	import { BUILT_IN_NAMESPACE_URIS } from '../expressions/staticallyKnownNamespaces';
12	import astHelper, { IAST } from '../parsing/astHelper';	3✔
13	import { CodeGenContext } from './CodeGenContext';
14	import {	3✔
15	emitConversionToFirstNode,
16	emitConversionToString,
17	emitConversionToValue,
18	emitEffectiveBooleanValue,
19	mapPartialCompilationResult,
20	} from './emitHelpers';
21	import escapeJavaScriptString from './escapeJavaScriptString';	3✔
22	import {	3✔
23	acceptAst,
24	GeneratedCodeBaseType,
25	PartialCompilationResult,
26	rejectAst,
27	} from './JavaScriptCompiledXPath';
28
29	const supportedFunctions: Record<
30	string,
31	(
32	ast: IAST,
33	contextItemExpr: PartialCompilationResult,
34	context: CodeGenContext
35	) => PartialCompilationResult
36	> = {	3✔
37	'false#0': emitFalseFunction,
38	'local-name#0': emitLocalNameFunction,
39	'local-name#1': emitLocalNameFunction,
40	'name#0': emitNameFunction,
41	'name#1': emitNameFunction,
42	'not#1': emitNotFunction,
43	'true#0': emitTrueFunction,
44	};
45
46	// Built-in function allow list
47	// Namespaces not mentioned here are assumed to be custom functions, which are more limited in what
48	// they require (no static / dynamic context) and should be safe if their return and argument types
49	// are supported.
50	const supportedBuiltinFunctions: Record<string, string[]> = {	3✔
51	[BUILT_IN_NAMESPACE_URIS.FONTOXPATH_NAMESPACE_URI]: ['version#0'],
52	['']: ['root#1', 'path#1'],
53	};
54
55	function emitFunctionArgumentConversion(
56	argAst: IAST,
57	requestedType: SequenceType,
58	contextItemExpr: PartialCompilationResult,
59	context: CodeGenContext
60	): PartialCompilationResult {
61	const [argExpr, _] = context.emitBaseExpr(argAst, contextItemExpr, context);	8✔
62	const actualType = astHelper.getAttribute(argAst, 'type');	8✔
63	if (doesTypeAllowMultiple(requestedType)) {	8!
UNCOV 64	return rejectAst('Not supported: sequence arguments with multiple items');	×
65	}
66
67	// TODO: emit runtime check that the actual sequence doesn't contain more than one item
68
69	if (isSubtypeOf(requestedType.type, ValueType.NODE)) {	8✔
70	return emitConversionToFirstNode(argExpr, actualType, contextItemExpr, context);	4✔
71	}
72
73	switch (requestedType.type) {	4!
74	case ValueType.ITEM:
UNCOV 75	return emitConversionToValue(argExpr, contextItemExpr, context);	×
76
77	case ValueType.XSBOOLEAN:
78	return emitEffectiveBooleanValue(argExpr, actualType, contextItemExpr, context);	2✔
79
80	case ValueType.XSSTRING:
81	return emitConversionToString(argExpr, actualType, contextItemExpr, context);	2✔
82	}
83
UNCOV 84	return rejectAst(	×
85	`Argument types not supported: ${
86	actualType ? valueTypeToString(actualType.type) : 'unknown'	×
87	} -> ${valueTypeToString(requestedType.type)}`
88	);
89	}
90
91	function emitFunctionArgumentsConversion(
92	argAsts: IAST[],
93	argTypes: ParameterType[],
94	contextItemExpr: PartialCompilationResult,
95	context: CodeGenContext
96	): PartialCompilationResult {
97	if (	9!
98	argAsts.length !== argTypes.length \|\|	18✔
99	argTypes.some((type) => type === EllipsisType.ELLIPSIS)	14✔
100	) {
UNCOV 101	return rejectAst('Not supported: variadic function or mismatch in argument count');	×
102	}
103
104	if (argAsts.length === 0) {	9✔
105	return acceptAst('', { type: GeneratedCodeBaseType.Value }, []);	1✔
106	}
107	const [argAst, ...restArgAsts] = argAsts;	8✔
108	const [type, ...restTypes] = argTypes;	8✔
109	const argExpr = context.getIdentifierFor(	8✔
110	emitFunctionArgumentConversion(
111	argAst,
112	// We checked for ELLIPSIS earlier, so all argument types are normal SequenceTypes
113	type as SequenceType,
114	contextItemExpr,
115	context
116	),
117	'arg'
118	);
119	if (restArgAsts.length === 0) {	8✔
120	return argExpr;	4✔
121	}
122
123	// Recurse and combine all arguments
124	return mapPartialCompilationResult(argExpr, (argExpr) => {	4✔
125	const argsExpr = emitFunctionArgumentsConversion(	4✔
126	restArgAsts,
127	restTypes,
128	contextItemExpr,
129	context
130	);
131	return mapPartialCompilationResult(argsExpr, (argsExpr) =>	4✔
132	acceptAst(`${argExpr.code}, ${argsExpr.code}`, { type: GeneratedCodeBaseType.Value }, [	4✔
133	...argExpr.variables,
134	...argsExpr.variables,
135	])
136	);
137	});
138	}
139
140	function emitFunctionReturnTypeConversion(
141	callFunctionExpr: PartialCompilationResult,
142	returnType: SequenceType
143	) {
144	return mapPartialCompilationResult(callFunctionExpr, (callFunctionExpr) => {	5✔
145	// We support (zero or) one string, node or boolean
146	if (	5!
147	!doesTypeAllowMultiple(returnType) &&	13✔
148	([ValueType.XSBOOLEAN, ValueType.XSSTRING].includes(returnType.type) \|\|
149	isSubtypeOf(returnType.type, ValueType.NODE))
150	) {
151	// Singleton string or empty sequence, handled by runtimeLib
152	return callFunctionExpr;	5✔
153	}
UNCOV 154	return rejectAst(	×
155	`Function return type ${valueTypeToString(returnType.type)} not supported`
156	);
157	});
158	}
159
160	export function emitFunctionCallExpr(	3✔
161	ast: IAST,
162	contextItemExpr: PartialCompilationResult,
163	context: CodeGenContext
164	): PartialCompilationResult {
165	const { localName, namespaceURI } = astHelper.getQName(	15✔
166	astHelper.getFirstChild(ast, 'functionName')
167	);
168
169	const argAsts = astHelper.getChildren(astHelper.getFirstChild(ast, 'arguments'), '*');	15✔
170	const arity = argAsts.length;	15✔
171	const functionNameAndArity = `${localName}#${arity}`;	15✔
172
173	// First check if we have a codegen-specific implementation
174	const isDefaultFunctionNamespace = namespaceURI === context.defaultFunctionNamespaceUri;	15✔
175	if (isDefaultFunctionNamespace) {	15✔
176	const emitFunctionCall = supportedFunctions[functionNameAndArity];	12✔
177	if (emitFunctionCall !== undefined) {	12✔
178	return emitFunctionCall(ast, contextItemExpr, context);	7✔
179	}
180	}
181
182	// Check allowlist
183	const allowlist = supportedBuiltinFunctions[isDefaultFunctionNamespace ? '' : namespaceURI];	8✔
184	if (allowlist) {	8✔
185	// Function is built-in and must be allowed explicitly to be considered safe for codegen
186	if (!allowlist.includes(functionNameAndArity)) {	6✔
187	return rejectAst(	3✔
188	`Not supported: built-in function not on allow list: ${functionNameAndArity}`
189	);
190	}
191	}
192
193	// Then check registered functions
194	const functionProperties = getFunctionByArity(namespaceURI, localName, arity);	5✔
195	if (!functionProperties) {	5!
UNCOV 196	return rejectAst(`Unknown function / arity: ${functionNameAndArity}`);	×
197	}
198
199	// Should never happen, but let's check anyway
200	if (functionProperties.isUpdating) {	5!
UNCOV 201	return rejectAst('Not supported: updating functions');	×
202	}
203
204	const argsExpr = emitFunctionArgumentsConversion(	5✔
205	argAsts,
206	functionProperties.argumentTypes,
207	contextItemExpr,
208	context
209	);
210
211	const callFunction = mapPartialCompilationResult(argsExpr, (argsExpr) =>	5✔
212	acceptAst(	5✔
213	`runtimeLib.callFunction(domFacade, ${escapeJavaScriptString(
214	namespaceURI
215	)}, ${escapeJavaScriptString(localName)}, [${argsExpr.code}], options)`,
216	{ type: GeneratedCodeBaseType.Value },
217	argsExpr.variables
218	)
219	);
220	return emitFunctionReturnTypeConversion(callFunction, functionProperties.returnType);	5✔
221	}
222
223	function emitContextItemCheck(
224	contextItemExpr: PartialCompilationResult,
225	context: CodeGenContext
226	): PartialCompilationResult {
227	return mapPartialCompilationResult(	1✔
228	context.getIdentifierFor(contextItemExpr, 'contextItem'),
229	(contextItemExpr) =>
230	acceptAst(contextItemExpr.code, { type: GeneratedCodeBaseType.Value }, [	1✔
231	...contextItemExpr.variables,
232	`if (${contextItemExpr.code} === undefined \|\| ${contextItemExpr.code} === null) {
233	throw errXPDY0002('The function which was called depends on dynamic context, which is absent.');
234	}`,
235	])
236	);
237	}
238
239	function emitSpecificNameFunction(
240	ast: IAST,
241	contextItemExpr: PartialCompilationResult,
242	context: CodeGenContext,
243	nameGetterFunction: (itemName: string) => string
244	): PartialCompilationResult {
245	const argumentAst = astHelper.followPath(ast, ['arguments', '*']);	2✔
246	let argExpr: PartialCompilationResult;
247	// Handle explicit context item arg as the no-arguments version
248	if (!argumentAst \|\| argumentAst[0] === 'contextItemExpr') {	2✔
249	// No args or '.' as arg - use the context item
250	argExpr = emitContextItemCheck(contextItemExpr, context);	1✔
251	} else {
252	// One arg, should be a node
253	const argType = astHelper.getAttribute(argumentAst, 'type');	1✔
254	if (!argType \|\| !isSubtypeOf(argType.type, ValueType.NODE)) {	1!
UNCOV 255	return rejectAst('name function only implemented if arg is a node');	×
256	}
257
258	const [expr, _] = context.emitBaseExpr(argumentAst, contextItemExpr, context);	1✔
259	argExpr = expr;	1✔
260	}
261
262	// TODO: this (and any other function call) should check multiplicity of the actual argument
263	const argAsValue = emitConversionToValue(argExpr, contextItemExpr, context);	2✔
264	return mapPartialCompilationResult(context.getIdentifierFor(argAsValue, 'arg'), (argAsValue) =>	2✔
265	acceptAst(	2✔
266	`(${argAsValue.code} ? ${nameGetterFunction(argAsValue.code)} : '')`,
267	{ type: GeneratedCodeBaseType.Value },
268	argAsValue.variables
269	)
270	);
271	}
272
273	function emitNameFunction(
274	ast: IAST,
275	contextItemExpr: PartialCompilationResult,
276	context: CodeGenContext
277	): PartialCompilationResult {
278	return emitSpecificNameFunction(	1✔
279	ast,
280	contextItemExpr,
281	context,
282	(identifier) =>
283	`(((${identifier}.prefix \|\| '').length !== 0 ? ${identifier}.prefix + ':' : '')	1✔
284	+ (${identifier}.localName \|\| ${identifier}.target \|\| ''))`
285	);
286	}
287
288	function emitLocalNameFunction(
289	ast: IAST,
290	contextItemExpr: PartialCompilationResult,
291	context: CodeGenContext
292	): PartialCompilationResult {
293	return emitSpecificNameFunction(	1✔
294	ast,
295	contextItemExpr,
296	context,
297	(identifier) => `(${identifier}.localName \|\| ${identifier}.target \|\| '')`	1✔
298	);
299	}
300
301	function emitNotFunction(
302	ast: IAST,
303	contextItemExpr: PartialCompilationResult,
304	context: CodeGenContext
305	): PartialCompilationResult {
306	const argumentAst = astHelper.followPath(ast, ['arguments', '*']);	1✔
307	const argType = astHelper.getAttribute(argumentAst, 'type');	1✔
308	const [argExpr, _] = context.emitBaseExpr(argumentAst, contextItemExpr, context);	1✔
309	const argAsBool = emitEffectiveBooleanValue(argExpr, argType, contextItemExpr, context);	1✔
310	return mapPartialCompilationResult(argAsBool, (argAsBool) =>	1✔
311	acceptAst(`!${argAsBool.code}`, { type: GeneratedCodeBaseType.Value }, argAsBool.variables)	1✔
312	);
313	}
314
315	function emitFalseFunction(
316	_ast: IAST,
317	_contextItemExpr: PartialCompilationResult,
318	_context: CodeGenContext
319	): PartialCompilationResult {
320	return acceptAst('false', { type: GeneratedCodeBaseType.Value }, []);	3✔
321	}
322
323	function emitTrueFunction(
324	_ast: IAST,
325	_contextItemExpr: PartialCompilationResult,
326	_context: CodeGenContext
327	): PartialCompilationResult {
328	return acceptAst('true', { type: GeneratedCodeBaseType.Value }, []);	1✔
329	}

FontoXML / fontoxpath / 3318962510

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