3248629957

Build Type

push

github

Committed by Stef Busking

Commit Message

Fix conversion of null node value to nodes array

Run Details

4847 of 5651 branches covered (85.77%)

Branch coverage included in aggregate %.

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

6 existing lines in 2 files now uncovered.

10393 of 11037 relevant lines covered (94.17%)

32786.89 hits per line

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

79.81

/src/jsCodegen/emitHelpers.ts

import isSubtypeOf from '../expressions/dataTypes/isSubtypeOf';
import { doesTypeAllowEmpty } from '../expressions/dataTypes/typeHelpers';
import { SequenceMultiplicity, SequenceType, ValueType } from '../expressions/dataTypes/Value';
import { Bucket } from '../expressions/util/Bucket';
import { CodeGenContext } from './CodeGenContext';
import {
        acceptAst,
        GeneratedCodeBaseType,
        PartialCompilationResult,
        PartiallyCompiledAstAccepted,
        rejectAst,
} from './JavaScriptCompiledXPath';

export function mapPartialCompilationResult(
        expr: PartialCompilationResult,
        cb: (expr: PartiallyCompiledAstAccepted) => PartialCompilationResult
): PartialCompilationResult {
        if (!expr.isAstAccepted) {
                return expr;
        }

        return cb(expr);
}

export function mapPartialCompilationResultAndBucket(
        expr: PartialCompilationResult,
        cb: (expr: PartiallyCompiledAstAccepted) => [PartialCompilationResult, Bucket]
): [PartialCompilationResult, Bucket] {
        if (!expr.isAstAccepted) {
                return [expr, null];
        }

        return cb(expr);
}

export function emitConversionToValue(
        expr: PartialCompilationResult,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): PartialCompilationResult {
        return mapPartialCompilationResult(expr, (expr) => {
                switch (expr.generatedCodeType.type) {
                        case GeneratedCodeBaseType.Value:
                                return expr;

                        case GeneratedCodeBaseType.Generator: {
                                // Ensure we have an identifier for the generator in case this is used multiple times
                                return mapPartialCompilationResult(
                                        context.getIdentifierFor(expr, 'nodes'),
                                        (expr) =>
                                                mapPartialCompilationResult(
                                                        context.getIdentifierFor(contextItemExpr, 'contextItem'),
                                                        (contextItemExpr) =>
                                                                acceptAst(
                                                                        `(function () {
                                                        const { done, value } = ${expr.code}(${contextItemExpr.code}).next();
                                                        return done ? null : value;
                                                })()`,
                                                                        { type: GeneratedCodeBaseType.Value },
                                                                        [...expr.variables, ...contextItemExpr.variables]
                                                                )
                                                )
                                );
                        }

                        default:
                                throw new Error(
                                        `invalid generated code type to convert to value: ${expr.generatedCodeType.type}`
                                );
                }
        });
}

export function emitEffectiveBooleanValue(
        expr: PartialCompilationResult,
        astType: SequenceType | null,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): PartialCompilationResult {
        // TODO: a sequence of more than one non-node should return an error, but we don't generate such
        // sequences yet
        const value = emitConversionToValue(expr, contextItemExpr, context);
        if (
                astType &&
                astType.type === ValueType.XSBOOLEAN &&
                astType.mult === SequenceMultiplicity.EXACTLY_ONE
        ) {
                // No need to coerce if this is already a boolean
                return value;
        }
        return mapPartialCompilationResult(value, (expr) => {
                return acceptAst(`!!${expr.code}`, { type: GeneratedCodeBaseType.Value }, expr.variables);
        });
}

export function emitAtomizedValue(
        expr: PartialCompilationResult,
        astType: SequenceType | null,
        context: CodeGenContext
): PartialCompilationResult {
        if (!astType) {
                return rejectAst('Can not atomize value if type was not annotated');
        }
        if (expr.isAstAccepted && expr.generatedCodeType.type !== GeneratedCodeBaseType.Value) {
                return rejectAst('Atomization only implemented for single value');
        }

        if (isSubtypeOf(astType.type, ValueType.XSSTRING)) {
                return expr;
        }

        if (isSubtypeOf(astType.type, ValueType.ATTRIBUTE)) {
                return mapPartialCompilationResult(context.getIdentifierFor(expr, 'attr'), (expr) =>
                        acceptAst(
                                `(${expr.code} ? domFacade.getData(${expr.code}) : null)`,
                                { type: GeneratedCodeBaseType.Value },
                                expr.variables
                        )
                );
        }
        return rejectAst('Atomization only implemented for string and attribute');
}

export function emitConversionToString(
        expr: PartialCompilationResult,
        astType: SequenceType,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): PartialCompilationResult {
        const value = emitConversionToValue(expr, contextItemExpr, context);
        const atomized = emitAtomizedValue(value, astType, context);
        if (!doesTypeAllowEmpty(astType)) {
                return atomized;
        }
        return mapPartialCompilationResult(atomized, (atomized) =>
                acceptAst(
                        `${atomized.code} ?? ''`,
                        { type: GeneratedCodeBaseType.Value },
                        atomized.variables
                )
        );
}

function emitNodeCheck(
        expr: PartialCompilationResult,
        astType: SequenceType | null,
        context: CodeGenContext
): PartialCompilationResult {
        return mapPartialCompilationResult(context.getIdentifierFor(expr, 'node'), (expr) => {
                // Accept generators as-is (these currently always yield nodes)
                if (expr.generatedCodeType.type === GeneratedCodeBaseType.Generator) {
                        return expr;
                }

                if (astType && !isSubtypeOf(astType.type, ValueType.NODE)) {
                        return rejectAst('Can not evaluate to node if expression does not result in nodes');
                }

                // Emit a type check
                return acceptAst(
                        `(function () {
                                if (${expr.code} !== null && !${expr.code}.nodeType) {
                                        throw new Error('XPDY0050: The result of the expression was not a node');
                                }
                                return ${expr.code};
                        })()`,
                        { type: GeneratedCodeBaseType.Value },
                        expr.variables
                );
        });
}

export function emitConversionToFirstNode(
        expr: PartialCompilationResult,
        astType: SequenceType | null,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): PartialCompilationResult {
        const exprAsValue = emitConversionToValue(expr, contextItemExpr, context);
        return emitNodeCheck(exprAsValue, astType, context);
}

export function emitConversionToNodes(
        expr: PartialCompilationResult,
        astType: SequenceType,
        contextItemExpr: PartialCompilationResult,
        context: CodeGenContext
): PartialCompilationResult {
        return mapPartialCompilationResult(expr, (expr) => {
                switch (expr.generatedCodeType.type) {
                        case GeneratedCodeBaseType.Generator:
                                return mapPartialCompilationResult(
                                        context.getIdentifierFor(expr, 'nodes'),
                                        (expr) =>
                                                mapPartialCompilationResult(
                                                        context.getIdentifierFor(contextItemExpr, 'contextItem'),
                                                        (contextItemExpr) =>
                                                                acceptAst(
                                                                        `Array.from(${expr.code}(${contextItemExpr.code}))`,
                                                                        { type: GeneratedCodeBaseType.Value },
                                                                        [...expr.variables, ...contextItemExpr.variables]
                                                                )
                                                )
                                );
                        case GeneratedCodeBaseType.Value:
                                return mapPartialCompilationResult(
                                        context.getIdentifierFor(emitNodeCheck(expr, astType, context), 'node'),
                                        (expr) =>
                                                acceptAst(
                                                        `(${expr.code} === null ? [] : [${expr.code}])`,
                                                        { type: GeneratedCodeBaseType.Value },
                                                        expr.variables
                                                )
                                );
                        default:
                                return rejectAst('Unsupported code type to evaluate to nodes');
                }
        });
}

export function emitAnd(
        condition1: PartialCompilationResult,
        condition2: PartialCompilationResult
): PartialCompilationResult {
        return mapPartialCompilationResult(condition1, (condition1) =>
                mapPartialCompilationResult(condition2, (condition2) => {
                        if (
                                condition1.generatedCodeType.type !== GeneratedCodeBaseType.Value ||
                                condition2.generatedCodeType.type !== GeneratedCodeBaseType.Value
                        ) {
                                throw new Error('can only use emitAnd with value expressions');
                        }
                        return acceptAst(
                                `${condition1.code} && ${condition2.code}`,
                                { type: GeneratedCodeBaseType.Value },
                                [...condition1.variables, ...condition2.variables]
                        );
                })
        );
}

1	import isSubtypeOf from '../expressions/dataTypes/isSubtypeOf';	3✔
2	import { doesTypeAllowEmpty } from '../expressions/dataTypes/typeHelpers';	3✔
3	import { SequenceMultiplicity, SequenceType, ValueType } from '../expressions/dataTypes/Value';
4	import { Bucket } from '../expressions/util/Bucket';
5	import { CodeGenContext } from './CodeGenContext';
6	import {	3✔
7	acceptAst,
8	GeneratedCodeBaseType,
9	PartialCompilationResult,
10	PartiallyCompiledAstAccepted,
11	rejectAst,
12	} from './JavaScriptCompiledXPath';
13
14	export function mapPartialCompilationResult(	3✔
15	expr: PartialCompilationResult,
16	cb: (expr: PartiallyCompiledAstAccepted) => PartialCompilationResult
17	): PartialCompilationResult {
18	if (!expr.isAstAccepted) {	2,592✔
19	return expr;	110✔
20	}
21
22	return cb(expr);	2,482✔
23	}
24
25	export function mapPartialCompilationResultAndBucket(	3✔
26	expr: PartialCompilationResult,
27	cb: (expr: PartiallyCompiledAstAccepted) => [PartialCompilationResult, Bucket]
28	): [PartialCompilationResult, Bucket] {
29	if (!expr.isAstAccepted) {	153!
30	return [expr, null];	×
31	}
32
33	return cb(expr);	153✔
34	}
35
36	export function emitConversionToValue(	3✔
37	expr: PartialCompilationResult,
38	contextItemExpr: PartialCompilationResult,
39	context: CodeGenContext
40	): PartialCompilationResult {
41	return mapPartialCompilationResult(expr, (expr) => {	437✔
42	switch (expr.generatedCodeType.type) {	405!
43	case GeneratedCodeBaseType.Value:
44	return expr;	359✔
45
46	case GeneratedCodeBaseType.Generator: {
47	// Ensure we have an identifier for the generator in case this is used multiple times
48	return mapPartialCompilationResult(	46✔
49	context.getIdentifierFor(expr, 'nodes'),
50	(expr) =>
51	mapPartialCompilationResult(	46✔
52	context.getIdentifierFor(contextItemExpr, 'contextItem'),
53	(contextItemExpr) =>
54	acceptAst(	46✔
55	`(function () {
56	const { done, value } = ${expr.code}(${contextItemExpr.code}).next();
57	return done ? null : value;
58	})()`,
59	{ type: GeneratedCodeBaseType.Value },
60	[...expr.variables, ...contextItemExpr.variables]
61	)
62	)
63	);
64	}
65
66	default:
67	throw new Error(	×
68	`invalid generated code type to convert to value: ${expr.generatedCodeType.type}`
69	);
70	}
71	});
72	}
73
74	export function emitEffectiveBooleanValue(	3✔
75	expr: PartialCompilationResult,
76	astType: SequenceType \| null,
77	contextItemExpr: PartialCompilationResult,
78	context: CodeGenContext
79	): PartialCompilationResult {
80	// TODO: a sequence of more than one non-node should return an error, but we don't generate such
81	// sequences yet
82	const value = emitConversionToValue(expr, contextItemExpr, context);	102✔
83	if (	102✔
84	astType &&	238✔
85	astType.type === ValueType.XSBOOLEAN &&
86	astType.mult === SequenceMultiplicity.EXACTLY_ONE
87	) {
88	// No need to coerce if this is already a boolean
89	return value;	28✔
90	}
91	return mapPartialCompilationResult(value, (expr) => {	74✔
92	return acceptAst(`!!${expr.code}`, { type: GeneratedCodeBaseType.Value }, expr.variables);	50✔
93	});
94	}
95
96	export function emitAtomizedValue(	3✔
97	expr: PartialCompilationResult,
98	astType: SequenceType \| null,
99	context: CodeGenContext
100	): PartialCompilationResult {
101	if (!astType) {	325!
102	return rejectAst('Can not atomize value if type was not annotated');	×
103	}
104	if (expr.isAstAccepted && expr.generatedCodeType.type !== GeneratedCodeBaseType.Value) {	325!
105	return rejectAst('Atomization only implemented for single value');	×
106	}
107
108	if (isSubtypeOf(astType.type, ValueType.XSSTRING)) {	325✔
109	return expr;	310✔
110	}
111
112	if (isSubtypeOf(astType.type, ValueType.ATTRIBUTE)) {	15!
113	return mapPartialCompilationResult(context.getIdentifierFor(expr, 'attr'), (expr) =>	15✔
114	acceptAst(	15✔
115	`(${expr.code} ? domFacade.getData(${expr.code}) : null)`,
116	{ type: GeneratedCodeBaseType.Value },
117	expr.variables
118	)
119	);
120	}
121	return rejectAst('Atomization only implemented for string and attribute');	×
122	}
123
124	export function emitConversionToString(	3✔
125	expr: PartialCompilationResult,
126	astType: SequenceType,
127	contextItemExpr: PartialCompilationResult,
128	context: CodeGenContext
129	): PartialCompilationResult {
130	const value = emitConversionToValue(expr, contextItemExpr, context);	289✔
131	const atomized = emitAtomizedValue(value, astType, context);	289✔
132	if (!doesTypeAllowEmpty(astType)) {	289✔
133	return atomized;	285✔
134	}
135	return mapPartialCompilationResult(atomized, (atomized) =>	4✔
136	acceptAst(	4✔
137	`${atomized.code} ?? ''`,
138	{ type: GeneratedCodeBaseType.Value },
139	atomized.variables
140	)
141	);
142	}
143
144	function emitNodeCheck(
145	expr: PartialCompilationResult,
146	astType: SequenceType \| null,
147	context: CodeGenContext
148	): PartialCompilationResult {
149	return mapPartialCompilationResult(context.getIdentifierFor(expr, 'node'), (expr) => {	14✔
150	// Accept generators as-is (these currently always yield nodes)
151	if (expr.generatedCodeType.type === GeneratedCodeBaseType.Generator) {	14!
152	return expr;	×
153	}
154
155	if (astType && !isSubtypeOf(astType.type, ValueType.NODE)) {	14!
156	return rejectAst('Can not evaluate to node if expression does not result in nodes');	×
157	}
158
159	// Emit a type check
160	return acceptAst(	14✔
161	`(function () {
162	if (${expr.code} !== null && !${expr.code}.nodeType) {
163	throw new Error('XPDY0050: The result of the expression was not a node');
164	}
165	return ${expr.code};
166	})()`,
167	{ type: GeneratedCodeBaseType.Value },
168	expr.variables
169	);
170	});
171	}
172
173	export function emitConversionToFirstNode(	3✔
174	expr: PartialCompilationResult,
175	astType: SequenceType \| null,
176	contextItemExpr: PartialCompilationResult,
177	context: CodeGenContext
178	): PartialCompilationResult {
179	const exprAsValue = emitConversionToValue(expr, contextItemExpr, context);	14✔
180	return emitNodeCheck(exprAsValue, astType, context);	14✔
181	}
182
183	export function emitConversionToNodes(	3✔
184	expr: PartialCompilationResult,
185	astType: SequenceType,
186	contextItemExpr: PartialCompilationResult,
187	context: CodeGenContext
188	): PartialCompilationResult {
189	return mapPartialCompilationResult(expr, (expr) => {	11✔
190	switch (expr.generatedCodeType.type) {	11!
191	case GeneratedCodeBaseType.Generator:
192	return mapPartialCompilationResult(	11✔
193	context.getIdentifierFor(expr, 'nodes'),
194	(expr) =>
195	mapPartialCompilationResult(	11✔
196	context.getIdentifierFor(contextItemExpr, 'contextItem'),
197	(contextItemExpr) =>
198	acceptAst(	11✔
199	`Array.from(${expr.code}(${contextItemExpr.code}))`,
200	{ type: GeneratedCodeBaseType.Value },
201	[...expr.variables, ...contextItemExpr.variables]
202	)
203	)
204	);
205	case GeneratedCodeBaseType.Value:
NEW 206	return mapPartialCompilationResult(	×
207	context.getIdentifierFor(emitNodeCheck(expr, astType, context), 'node'),
208	(expr) =>
NEW 209	acceptAst(	×
210	`(${expr.code} === null ? [] : [${expr.code}])`,
211	{ type: GeneratedCodeBaseType.Value },
212	expr.variables
213	)
214	);
215	default:
216	return rejectAst('Unsupported code type to evaluate to nodes');	×
217	}
218	});
219	}
220
221	export function emitAnd(	3✔
222	condition1: PartialCompilationResult,
223	condition2: PartialCompilationResult
224	): PartialCompilationResult {
225	return mapPartialCompilationResult(condition1, (condition1) =>	275✔
226	mapPartialCompilationResult(condition2, (condition2) => {	275✔
227	if (	265!
228	condition1.generatedCodeType.type !== GeneratedCodeBaseType.Value \|\|	530✔
229	condition2.generatedCodeType.type !== GeneratedCodeBaseType.Value
230	) {
231	throw new Error('can only use emitAnd with value expressions');	×
232	}
233	return acceptAst(	265✔
234	`${condition1.code} && ${condition2.code}`,
235	{ type: GeneratedCodeBaseType.Value },
236	[...condition1.variables, ...condition2.variables]
237	);
238	})
239	);
240	}

FontoXML / fontoxpath / 3248629957

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