3296779345

Build Type

push

github

Committed by Stef Busking

Commit Message

Fix handling filterExpr that results in a generator

Run Details

4867 of 5674 branches covered (85.78%)

Branch coverage included in aggregate %.

9 of 12 new or added lines in 1 file covered. (75.0%)

1 existing line in 1 file now uncovered.

10443 of 11089 relevant lines covered (94.17%)

32633.14 hits per line

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

90.08

/src/jsCodegen/emitPathExpr.ts

import { NODE_TYPES } from '../domFacade/ConcreteNode';
import { Bucket, intersectBuckets } from '../expressions/util/Bucket';
import astHelper, { IAST } from '../parsing/astHelper';
import { CodeGenContext } from './CodeGenContext';
import emitAxis, { axisAstNodes } from './emitAxis';
import {
        emitAnd,
        emitEffectiveBooleanValue,
        mapPartialCompilationResult,
        mapPartialCompilationResultAndBucket,
} from './emitHelpers';
import emitTest, { tests } from './emitTest';
import {
        acceptAst,
        GeneratedCodeBaseType,
        PartialCompilationResult,
        rejectAst,
} from './JavaScriptCompiledXPath';

function emitPredicate(
        predicateAst: IAST,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): [PartialCompilationResult, Bucket] {
        const [expr, bucket] = context.emitBaseExpr(predicateAst, contextItemExpr, context);
        const type = astHelper.getAttribute(predicateAst, 'type');
        const asBool = emitEffectiveBooleanValue(expr, type, contextItemExpr, context);
        return [asBool, bucket];
}

/**
 * Determines for every path step if it should emit a node or not.
 */
function emitPredicates(
        predicatesAst: IAST | null,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): [PartialCompilationResult | null, Bucket] {
        const predicateAsts = predicatesAst ? astHelper.getChildren(predicatesAst, '*') : [];
        const [combinedPredicatesExpr, bucket] = predicateAsts.reduce<
                [PartialCompilationResult | null, Bucket]
        >(
                ([previousExpr, previousBucket], predicateAst) => {
                        if (!previousExpr) {
                                return emitPredicate(predicateAst, contextItemExpr, context);
                        }
                        let combinedBucket = previousBucket;
                        return mapPartialCompilationResultAndBucket(previousExpr, (previousExpr) => {
                                const [predicateExpr, bucket] = emitPredicate(
                                        predicateAst,
                                        contextItemExpr,
                                        context
                                );
                                combinedBucket = intersectBuckets(previousBucket, bucket);
                                return [
                                        mapPartialCompilationResult(predicateExpr, (predicateExpr) =>
                                                acceptAst(
                                                        `${previousExpr.code} && ${predicateExpr.code}`,
                                                        { type: GeneratedCodeBaseType.Value },
                                                        [...previousExpr.variables, ...predicateExpr.variables]
                                                )
                                        ),
                                        combinedBucket,
                                ];
                        });
                },
                [null, null]
        );

        return [
                // Make predicate variables evaluate lazily so the test is always checked first
                combinedPredicatesExpr
                        ? mapPartialCompilationResult(combinedPredicatesExpr, (combinedPredicatesExpr) =>
                                        acceptAst(
                                                `(function () {
                                                        ${combinedPredicatesExpr.variables.join('\n')}
                                                        return ${combinedPredicatesExpr.code};
                                                })()`,
                                                { type: GeneratedCodeBaseType.Value },
                                                []
                                        )
                          )
                        : null,
                bucket,
        ];
}

/**
 * Takes the step AST's of a path expression and turns it into runnable JavaScript code.
 */
function emitSteps(
        stepAsts: IAST[],
        contextItemCanBeAttribute: boolean,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): [PartialCompilationResult, Bucket] {
        if (stepAsts.length === 0) {
                return [
                        mapPartialCompilationResult(contextItemExpr, (contextItemExpr) =>
                                acceptAst(
                                        `yield ${contextItemExpr.code};`,
                                        { type: GeneratedCodeBaseType.Statement },
                                        contextItemExpr.variables
                                )
                        ),
                        null,
                ];
        }

        // A step is constructed as follows:
        // for (stepContextItemExpr of axis) {
        //     test code for step, continue if no match
        //     predicates for step, continue if no match
        //     nested steps
        // }
        // This recurses over steps to build that nested structure. Once there are no more nested steps
        // this hits the case above which outputs the single yield statement.

        const [stepAst, ...restStepAsts] = stepAsts;

        const lookupAsts = astHelper.getChildren(stepAst, 'lookup');
        if (lookupAsts.length > 0) {
                return [rejectAst('Unsupported: lookups'), null];
        }

        // Every step introduces a context item for its test and predicates
        const stepContextItemExpr = context.getNewIdentifier('contextItem');

        const predicatesAst = astHelper.getFirstChild(stepAst, 'predicates');
        const [predicatesExpr, predicatesBucket] = emitPredicates(
                predicatesAst,
                stepContextItemExpr,
                context
        );

        const axisAst = astHelper.getFirstChild(stepAst, 'xpathAxis');
        if (axisAst) {
                const testAst = astHelper.getFirstChild(stepAst, tests);
                if (!testAst) {
                        return [rejectAst('Unsupported test in step'), null];
                }

                // TODO: may be better to annotate steps instead to narrow down types?
                const axisType = astHelper.getTextContent(axisAst);
                const stepContextItemCanBeAttribute =
                        axisType === 'attribute' || (axisType === 'self' && contextItemCanBeAttribute);
                const [testExpr, testBucket] = emitTest(
                        testAst,
                        stepContextItemCanBeAttribute,
                        stepContextItemExpr,
                        context
                );

                const combinedConditionExpr =
                        predicatesExpr === null ? testExpr : emitAnd(testExpr, predicatesExpr);

                const combinedConditionBucket = intersectBuckets(testBucket, predicatesBucket);

                const [nestedStepsCode, _] = emitSteps(
                        restStepAsts,
                        stepContextItemCanBeAttribute,
                        stepContextItemExpr,
                        context
                );

                return emitAxis(
                        axisAst,
                        combinedConditionExpr,
                        combinedConditionBucket,
                        nestedStepsCode,
                        stepContextItemExpr,
                        contextItemExpr
                );
        }

        // step may contain a filterExpr instead
        const filterExprAst = astHelper.followPath(stepAst, ['filterExpr', '*']);
        if (!filterExprAst) {
                return [rejectAst('Unsupported: unknown step type'), null];
        }

        // Compile the expression
        const [filterExpr, filterBucket] = context.emitBaseExpr(
                filterExprAst,
                contextItemExpr,
                context
        );
        // Assign it to the stepContextItem variable
        // If the filterExpr is a path, the result could be another generator we should loop over
        return [
                mapPartialCompilationResult(filterExpr, (filterExpr) => {
                        // If there are following steps, the result of the expression must be a node
                        const pathTypeCheck =
                                restStepAsts.length === 0
                                        ? acceptAst(``, { type: GeneratedCodeBaseType.Statement }, [])
                                        : acceptAst(
                                                        `if (${stepContextItemExpr.code} !== null && !${stepContextItemExpr.code}.nodeType) {
                                                                        throw new Error('XPTY0019: The result of E1 in a path expression E1/E2 should evaluate to a sequence of nodes.');
                                                                }`,
                                                        { type: GeneratedCodeBaseType.Statement },
                                                        []
                                          );

                        // Compile nested steps
                        const [nestedStepsCode, _] = emitSteps(
                                restStepAsts,
                                true,
                                stepContextItemExpr,
                                context
                        );

                        const nestedCode =
                                predicatesExpr === null
                                        ? nestedStepsCode
                                        : mapPartialCompilationResult(predicatesExpr, (predicatesExpr) =>
                                                        mapPartialCompilationResult(nestedStepsCode, (nestedStepsCode) =>
                                                                acceptAst(
                                                                        `if (${predicatesExpr.code}) {
                                                                        ${nestedStepsCode.variables.join('\n')}
                                                                        ${nestedStepsCode.code}
                                                                }`,
                                                                        { type: GeneratedCodeBaseType.Statement },
                                                                        predicatesExpr.variables
                                                                )
                                                        )
                                          );

                        // Combine
                        return mapPartialCompilationResult(nestedCode, (nestedCode) => {
                                switch (filterExpr.generatedCodeType.type) {
                                        case GeneratedCodeBaseType.Generator:
                                                return mapPartialCompilationResult(contextItemExpr, (contextItemExpr) =>
                                                        acceptAst(
                                                                `for (const ${stepContextItemExpr.code} of ${filterExpr.code}(${
                                                                        contextItemExpr.code
                                                                })) {
                                                                        ${nestedCode.variables.join('\n')}
                                                                        ${nestedCode.code}
                                                                }`,
                                                                { type: GeneratedCodeBaseType.Statement },
                                                                [
                                                                        ...stepContextItemExpr.variables,
                                                                        ...filterExpr.variables,
                                                                        ...pathTypeCheck.variables,
                                                                ]
                                                        )
                                                );

                                        case GeneratedCodeBaseType.Value:
                                                return acceptAst(
                                                        `const ${stepContextItemExpr.code} = ${filterExpr.code};
                                                        ${pathTypeCheck.code}
                                                        if (${stepContextItemExpr.code} !== null) {
                                                                ${nestedCode.variables.join('\n')}
                                                                ${nestedCode.code}
                                                        }`,
                                                        { type: GeneratedCodeBaseType.Statement },
                                                        [
                                                                ...stepContextItemExpr.variables,
                                                                ...filterExpr.variables,
                                                                ...pathTypeCheck.variables,
                                                        ]
                                                );
                                        default:
                                                return rejectAst('Unsupported generated code type for filterExpr');
                                }
                        });
                }),
                filterBucket,
        ];
}

function emitRootExpr(
        contextItemExpr: PartialCompilationResult,
        _context: CodeGenContext
): PartialCompilationResult {
        return mapPartialCompilationResult(contextItemExpr, (contextItemExpr) =>
                acceptAst(
                        `(function () {
                                let n = ${contextItemExpr.code};
                                while (n.nodeType !== /*DOCUMENT_NODE*/${NODE_TYPES.DOCUMENT_NODE}) {
                                        n = domFacade.getParentNode(n);
                                        if (n === null) {
                                                throw new Error('XPDY0050: the root node of the context node is not a document node.');
                                        }
                                }
                                return n;
                        })()`,
                        { type: GeneratedCodeBaseType.Value },
                        contextItemExpr.variables
                )
        );
}

function emitSingleSelfPathExpr(
        stepAst: IAST,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): [PartialCompilationResult, Bucket] {
        return mapPartialCompilationResultAndBucket(contextItemExpr, (contextItemExpr) => {
                const lookupAsts = astHelper.getChildren(stepAst, 'lookup');
                if (lookupAsts.length > 0) {
                        return [rejectAst('Unsupported: lookups'), null];
                }
                const predicatesAst = astHelper.getFirstChild(stepAst, 'predicates');
                const [predicatesExpr, predicatesBucket] = emitPredicates(
                        predicatesAst,
                        contextItemExpr,
                        context
                );
                const testAst = astHelper.getFirstChild(stepAst, tests);
                if (!testAst) {
                        return [rejectAst('Unsupported test in step'), null];
                }
                const [testExpr, testBucket] = emitTest(testAst, true, contextItemExpr, context);
                const combinedConditionExpr =
                        predicatesExpr === null ? testExpr : emitAnd(testExpr, predicatesExpr);
                const combinedConditionBucket = intersectBuckets(testBucket, predicatesBucket);

                return [
                        mapPartialCompilationResult(combinedConditionExpr, (combinedConditionExpr) =>
                                acceptAst(
                                        `((${combinedConditionExpr.code}) ? ${contextItemExpr.code} : null)`,
                                        { type: GeneratedCodeBaseType.Value },
                                        [...contextItemExpr.variables, ...combinedConditionExpr.variables]
                                )
                        ),
                        combinedConditionBucket,
                ];
        });
}

/**
 * Takes a path expression AST node and turns it into a javascript function.
 * Path expression can be used to locate nodes within trees and they
 * consist of a series of one or more steps.
 *
 * https://www.w3.org/TR/xpath-31/#doc-xpath31-PathExpr
 */
export function emitPathExpr(
        ast: IAST,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): [PartialCompilationResult, Bucket] {
        // Optimized code for single-self-axis paths, which are used a lot in selectors and don't need
        // a generator as they only test the context node
        const stepAsts = astHelper.getChildren(ast, 'stepExpr');
        if (stepAsts.length === 1) {
                const axisAst = astHelper.getFirstChild(stepAsts[0], 'xpathAxis');
                if (axisAst && astHelper.getTextContent(axisAst) === axisAstNodes.SELF) {
                        return emitSingleSelfPathExpr(stepAsts[0], contextItemExpr, context);
                }
        }

        // Other paths compile into a generator which is parameterized over contextItemExpr
        const contextItemArgExpr = context.getNewIdentifier('contextItem');
        // Find the root node from the context.
        const isAbsolute = astHelper.getFirstChild(ast, 'rootExpr');
        const rootExpr = isAbsolute
                ? context.getIdentifierFor(emitRootExpr(contextItemArgExpr, context), 'root')
                : contextItemArgExpr;
        const [stepsCode, bucket] = emitSteps(stepAsts, !isAbsolute, rootExpr, context);
        const generatorExpr = mapPartialCompilationResult(stepsCode, (stepsCode) =>
                acceptAst(
                        `(function* (${contextItemArgExpr.code}) {
                        ${stepsCode.variables.join('\n')}
                        ${stepsCode.code}
                })`,
                        { type: GeneratedCodeBaseType.Generator },
                        []
                )
        );
        return [generatorExpr, bucket];
}

1	import { NODE_TYPES } from '../domFacade/ConcreteNode';
2	import { Bucket, intersectBuckets } from '../expressions/util/Bucket';	3✔
3	import astHelper, { IAST } from '../parsing/astHelper';	3✔
4	import { CodeGenContext } from './CodeGenContext';
5	import emitAxis, { axisAstNodes } from './emitAxis';	3✔
6	import {	3✔
7	emitAnd,
8	emitEffectiveBooleanValue,
9	mapPartialCompilationResult,
10	mapPartialCompilationResultAndBucket,
11	} from './emitHelpers';
12	import emitTest, { tests } from './emitTest';	3✔
13	import {	3✔
14	acceptAst,
15	GeneratedCodeBaseType,
16	PartialCompilationResult,
17	rejectAst,
18	} from './JavaScriptCompiledXPath';
19
20	function emitPredicate(
21	predicateAst: IAST,
22	contextItemExpr: PartialCompilationResult,
23	context: CodeGenContext
24	): [PartialCompilationResult, Bucket] {
25	const [expr, bucket] = context.emitBaseExpr(predicateAst, contextItemExpr, context);	31✔
26	const type = astHelper.getAttribute(predicateAst, 'type');	31✔
27	const asBool = emitEffectiveBooleanValue(expr, type, contextItemExpr, context);	31✔
28	return [asBool, bucket];	31✔
29	}
30
31	/**
32	* Determines for every path step if it should emit a node or not.
33	*/
34	function emitPredicates(
35	predicatesAst: IAST \| null,
36	contextItemExpr: PartialCompilationResult,
37	context: CodeGenContext
38	): [PartialCompilationResult \| null, Bucket] {
39	const predicateAsts = predicatesAst ? astHelper.getChildren(predicatesAst, '*') : [];	154✔
40	const [combinedPredicatesExpr, bucket] = predicateAsts.reduce<	154✔
41	[PartialCompilationResult \| null, Bucket]
42	>(
43	([previousExpr, previousBucket], predicateAst) => {
44	if (!previousExpr) {	31✔
45	return emitPredicate(predicateAst, contextItemExpr, context);	28✔
46	}
47	let combinedBucket = previousBucket;	3✔
48	return mapPartialCompilationResultAndBucket(previousExpr, (previousExpr) => {	3✔
49	const [predicateExpr, bucket] = emitPredicate(	3✔
50	predicateAst,
51	contextItemExpr,
52	context
53	);
54	combinedBucket = intersectBuckets(previousBucket, bucket);	3✔
55	return [	3✔
56	mapPartialCompilationResult(predicateExpr, (predicateExpr) =>
57	acceptAst(	3✔
58	`${previousExpr.code} && ${predicateExpr.code}`,
59	{ type: GeneratedCodeBaseType.Value },
60	[...previousExpr.variables, ...predicateExpr.variables]
61	)
62	),
63	combinedBucket,
64	];
65	});
66	},
67	[null, null]
68	);
69
70	return [	154✔
71	// Make predicate variables evaluate lazily so the test is always checked first
72	combinedPredicatesExpr	154✔
73	? mapPartialCompilationResult(combinedPredicatesExpr, (combinedPredicatesExpr) =>
74	acceptAst(	18✔
75	`(function () {
76	${combinedPredicatesExpr.variables.join('\n')}
77	return ${combinedPredicatesExpr.code};
78	})()`,
79	{ type: GeneratedCodeBaseType.Value },
80	[]
81	)
82	)
83	: null,
84	bucket,
85	];
86	}
87
88	/**
89	* Takes the step AST's of a path expression and turns it into runnable JavaScript code.
90	*/
91	function emitSteps(
92	stepAsts: IAST[],
93	contextItemCanBeAttribute: boolean,
94	contextItemExpr: PartialCompilationResult,
95	context: CodeGenContext
96	): [PartialCompilationResult, Bucket] {
97	if (stepAsts.length === 0) {	214✔
98	return [	82✔
99	mapPartialCompilationResult(contextItemExpr, (contextItemExpr) =>
100	acceptAst(	82✔
101	`yield ${contextItemExpr.code};`,
102	{ type: GeneratedCodeBaseType.Statement },
103	contextItemExpr.variables
104	)
105	),
106	null,
107	];
108	}
109
110	// A step is constructed as follows:
111	// for (stepContextItemExpr of axis) {
112	// test code for step, continue if no match
113	// predicates for step, continue if no match
114	// nested steps
115	// }
116	// This recurses over steps to build that nested structure. Once there are no more nested steps
117	// this hits the case above which outputs the single yield statement.
118
119	const [stepAst, ...restStepAsts] = stepAsts;	132✔
120
121	const lookupAsts = astHelper.getChildren(stepAst, 'lookup');	132✔
122	if (lookupAsts.length > 0) {	132!
123	return [rejectAst('Unsupported: lookups'), null];	×
124	}
125
126	// Every step introduces a context item for its test and predicates
127	const stepContextItemExpr = context.getNewIdentifier('contextItem');	132✔
128
129	const predicatesAst = astHelper.getFirstChild(stepAst, 'predicates');	132✔
130	const [predicatesExpr, predicatesBucket] = emitPredicates(	132✔
131	predicatesAst,
132	stepContextItemExpr,
133	context
134	);
135
136	const axisAst = astHelper.getFirstChild(stepAst, 'xpathAxis');	132✔
137	if (axisAst) {	132✔
138	const testAst = astHelper.getFirstChild(stepAst, tests);	128✔
139	if (!testAst) {	128✔
140	return [rejectAst('Unsupported test in step'), null];	1✔
141	}
142
143	// TODO: may be better to annotate steps instead to narrow down types?
144	const axisType = astHelper.getTextContent(axisAst);	127✔
145	const stepContextItemCanBeAttribute =
146	axisType === 'attribute' \|\| (axisType === 'self' && contextItemCanBeAttribute);	127!
147	const [testExpr, testBucket] = emitTest(	127✔
148	testAst,
149	stepContextItemCanBeAttribute,
150	stepContextItemExpr,
151	context
152	);
153
154	const combinedConditionExpr =
155	predicatesExpr === null ? testExpr : emitAnd(testExpr, predicatesExpr);	127✔
156
157	const combinedConditionBucket = intersectBuckets(testBucket, predicatesBucket);	127✔
158
159	const [nestedStepsCode, _] = emitSteps(	127✔
160	restStepAsts,
161	stepContextItemCanBeAttribute,
162	stepContextItemExpr,
163	context
164	);
165
166	return emitAxis(	127✔
167	axisAst,
168	combinedConditionExpr,
169	combinedConditionBucket,
170	nestedStepsCode,
171	stepContextItemExpr,
172	contextItemExpr
173	);
174	}
175
176	// step may contain a filterExpr instead
177	const filterExprAst = astHelper.followPath(stepAst, ['filterExpr', '*']);	4✔
178	if (!filterExprAst) {	4!
179	return [rejectAst('Unsupported: unknown step type'), null];	×
180	}
181
182	// Compile the expression
183	const [filterExpr, filterBucket] = context.emitBaseExpr(	4✔
184	filterExprAst,
185	contextItemExpr,
186	context
187	);
188	// Assign it to the stepContextItem variable
189	// If the filterExpr is a path, the result could be another generator we should loop over
190	return [	4✔
191	mapPartialCompilationResult(filterExpr, (filterExpr) => {
192	// If there are following steps, the result of the expression must be a node
193	const pathTypeCheck =
194	restStepAsts.length === 0	4!
195	? acceptAst(``, { type: GeneratedCodeBaseType.Statement }, [])
196	: acceptAst(
197	`if (${stepContextItemExpr.code} !== null && !${stepContextItemExpr.code}.nodeType) {
198	throw new Error('XPTY0019: The result of E1 in a path expression E1/E2 should evaluate to a sequence of nodes.');
199	}`,
200	{ type: GeneratedCodeBaseType.Statement },
201	[]
202	);
203
204	// Compile nested steps
205	const [nestedStepsCode, _] = emitSteps(	4✔
206	restStepAsts,
207	true,
208	stepContextItemExpr,
209	context
210	);
211
212	const nestedCode =
213	predicatesExpr === null	4✔
214	? nestedStepsCode
215	: mapPartialCompilationResult(predicatesExpr, (predicatesExpr) =>
216	mapPartialCompilationResult(nestedStepsCode, (nestedStepsCode) =>	2✔
217	acceptAst(	2✔
218	`if (${predicatesExpr.code}) {
219	${nestedStepsCode.variables.join('\n')}
220	${nestedStepsCode.code}
221	}`,
222	{ type: GeneratedCodeBaseType.Statement },
223	predicatesExpr.variables
224	)
225	)
226	);
227
228	// Combine
229	return mapPartialCompilationResult(nestedCode, (nestedCode) => {	4✔
230	switch (filterExpr.generatedCodeType.type) {	4!
231	case GeneratedCodeBaseType.Generator:
NEW 232	return mapPartialCompilationResult(contextItemExpr, (contextItemExpr) =>	×
NEW 233	acceptAst(	×
234	`for (const ${stepContextItemExpr.code} of ${filterExpr.code}(${
235	contextItemExpr.code
236	})) {
237	${nestedCode.variables.join('\n')}
238	${nestedCode.code}
239	}`,
240	{ type: GeneratedCodeBaseType.Statement },
241	[
242	...stepContextItemExpr.variables,
243	...filterExpr.variables,
244	...pathTypeCheck.variables,
245	]
246	)
247	);
248
249	case GeneratedCodeBaseType.Value:
250	return acceptAst(	4✔
251	`const ${stepContextItemExpr.code} = ${filterExpr.code};
252	${pathTypeCheck.code}
253	if (${stepContextItemExpr.code} !== null) {
254	${nestedCode.variables.join('\n')}
255	${nestedCode.code}
256	}`,
257	{ type: GeneratedCodeBaseType.Statement },
258	[
259	...stepContextItemExpr.variables,
260	...filterExpr.variables,
261	...pathTypeCheck.variables,
262	]
263	);
264	default:
NEW 265	return rejectAst('Unsupported generated code type for filterExpr');	×
266	}
267	});
268	}),
269	filterBucket,
270	];
271	}
272
273	function emitRootExpr(
274	contextItemExpr: PartialCompilationResult,
275	_context: CodeGenContext
276	): PartialCompilationResult {
277	return mapPartialCompilationResult(contextItemExpr, (contextItemExpr) =>	42✔
278	acceptAst(	42✔
279	`(function () {
280	let n = ${contextItemExpr.code};
281	while (n.nodeType !== /DOCUMENT_NODE/${NODE_TYPES.DOCUMENT_NODE}) {
282	n = domFacade.getParentNode(n);
283	if (n === null) {
284	throw new Error('XPDY0050: the root node of the context node is not a document node.');
285	}
286	}
287	return n;
288	})()`,
289	{ type: GeneratedCodeBaseType.Value },
290	contextItemExpr.variables
291	)
292	);
293	}
294
295	function emitSingleSelfPathExpr(
296	stepAst: IAST,
297	contextItemExpr: PartialCompilationResult,
298	context: CodeGenContext
299	): [PartialCompilationResult, Bucket] {
300	return mapPartialCompilationResultAndBucket(contextItemExpr, (contextItemExpr) => {	22✔
301	const lookupAsts = astHelper.getChildren(stepAst, 'lookup');	22✔
302	if (lookupAsts.length > 0) {	22!
UNCOV 303	return [rejectAst('Unsupported: lookups'), null];	×
304	}
305	const predicatesAst = astHelper.getFirstChild(stepAst, 'predicates');	22✔
306	const [predicatesExpr, predicatesBucket] = emitPredicates(	22✔
307	predicatesAst,
308	contextItemExpr,
309	context
310	);
311	const testAst = astHelper.getFirstChild(stepAst, tests);	22✔
312	if (!testAst) {	22✔
313	return [rejectAst('Unsupported test in step'), null];	2✔
314	}
315	const [testExpr, testBucket] = emitTest(testAst, true, contextItemExpr, context);	20✔
316	const combinedConditionExpr =
317	predicatesExpr === null ? testExpr : emitAnd(testExpr, predicatesExpr);	20✔
318	const combinedConditionBucket = intersectBuckets(testBucket, predicatesBucket);	20✔
319
320	return [	20✔
321	mapPartialCompilationResult(combinedConditionExpr, (combinedConditionExpr) =>
322	acceptAst(	20✔
323	`((${combinedConditionExpr.code}) ? ${contextItemExpr.code} : null)`,
324	{ type: GeneratedCodeBaseType.Value },
325	[...contextItemExpr.variables, ...combinedConditionExpr.variables]
326	)
327	),
328	combinedConditionBucket,
329	];
330	});
331	}
332
333	/**
334	* Takes a path expression AST node and turns it into a javascript function.
335	* Path expression can be used to locate nodes within trees and they
336	* consist of a series of one or more steps.
337	*
338	* https://www.w3.org/TR/xpath-31/#doc-xpath31-PathExpr
339	*/
340	export function emitPathExpr(	3✔
341	ast: IAST,
342	contextItemExpr: PartialCompilationResult,
343	context: CodeGenContext
344	): [PartialCompilationResult, Bucket] {
345	// Optimized code for single-self-axis paths, which are used a lot in selectors and don't need
346	// a generator as they only test the context node
347	const stepAsts = astHelper.getChildren(ast, 'stepExpr');	105✔
348	if (stepAsts.length === 1) {	105✔
349	const axisAst = astHelper.getFirstChild(stepAsts[0], 'xpathAxis');	77✔
350	if (axisAst && astHelper.getTextContent(axisAst) === axisAstNodes.SELF) {	77✔
351	return emitSingleSelfPathExpr(stepAsts[0], contextItemExpr, context);	22✔
352	}
353	}
354
355	// Other paths compile into a generator which is parameterized over contextItemExpr
356	const contextItemArgExpr = context.getNewIdentifier('contextItem');	83✔
357	// Find the root node from the context.
358	const isAbsolute = astHelper.getFirstChild(ast, 'rootExpr');	83✔
359	const rootExpr = isAbsolute	83✔
360	? context.getIdentifierFor(emitRootExpr(contextItemArgExpr, context), 'root')
361	: contextItemArgExpr;
362	const [stepsCode, bucket] = emitSteps(stepAsts, !isAbsolute, rootExpr, context);	83✔
363	const generatorExpr = mapPartialCompilationResult(stepsCode, (stepsCode) =>	83✔
364	acceptAst(	64✔
365	`(function* (${contextItemArgExpr.code}) {
366	${stepsCode.variables.join('\n')}
367	${stepsCode.code}
368	})`,
369	{ type: GeneratedCodeBaseType.Generator },
370	[]
371	)
372	);
373	return [generatorExpr, bucket];	83✔
374	}

FontoXML / fontoxpath / 3296779345

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