1143371400

Build Type

github

Committed by GitHub

Commit Message

Merge e4a30b12e into c44a09941

Pull Request Pull Request #397: Compare jscodegen

Run Details

4742 of 5095 branches covered (93.07%)

Branch coverage included in aggregate %.

327 of 341 new or added lines in 14 files covered. (95.89%)

1 existing line in 1 file now uncovered.

9421 of 9652 relevant lines covered (97.61%)

5615398.58 hits per line

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

84.31

/src/jsCodegen/emitCompare.ts

import {
        SequenceMultiplicity,
        SequenceType,
        ValueType,
        valueTypeToString,
} from '../expressions/dataTypes/Value';
import astHelper, { IAST } from '../parsing/astHelper';
import { CodeGenContext } from './CodeGenContext';
import { emitOperand } from './emitOperand';
// import { emitBaseExpr } from './emitBaseExpression';
import {
        acceptAst,
        FunctionIdentifier,
        GeneratedCodeBaseType,
        getCompiledValueCode,
        PartialCompilationResult,
        rejectAst,
} from './JavaScriptCompiledXPath';

/**
 * Generates javascript code for a value compare expression.
 *
 * @param ast The ast of the value compare expression
 * @param compareType The type of comparison we're executing
 * @param firstExpr The generated code of the first expression
 * @param secondExpr The generated code of the second expression
 * @param identifier The identifier of the result
 * @param staticContext The code generation context
 * @returns Generated code of the value compare
 */
export function emitValueCompare(
        ast: IAST,
        compareType: string,
        firstExpr: PartialCompilationResult,
        secondExpr: PartialCompilationResult,
        identifier: string,
        _staticContext: CodeGenContext
): PartialCompilationResult {
        const leftType = astHelper.getAttribute(
                astHelper.getFirstChild(ast, 'firstOperand')[1] as IAST,
                'type'
        );
        const rightType = astHelper.getAttribute(
                astHelper.getFirstChild(ast, 'secondOperand')[1] as IAST,
                'type'
        );

        if (!leftType || !rightType) {
                return rejectAst('Left or right type of compare are not found, annotation failed.');
        }

        const supportedTypes = [ValueType.ATTRIBUTE, ValueType.XSSTRING, ValueType.NODE];
        if (!supportedTypes.includes(leftType.type) || !supportedTypes.includes(rightType.type)) {
                return rejectAst(
                        `Unsupported types in compare: [${valueTypeToString(
                                leftType.type
                        )}, ${valueTypeToString(rightType.type)}]`
                );
        }

        if (!firstExpr.isAstAccepted) {
                return firstExpr;
        }
        if (!secondExpr.isAstAccepted) {
                return secondExpr;
        }

        // Make sure both child expression got annotated
        if (!leftType || !rightType) {
                return rejectAst("Operands in compare weren't annotated");
        }

        const compareOperators: Record<string, string> = {
                eqOp: '===',
                neOp: '!==',
        };

        // Make sure we support the comparison type
        if (!compareOperators[compareType]) {
                return rejectAst(compareType + ' not yet implemented');
        }

        // Get the correct operator
        const operator = compareOperators[compareType];

        const leftGenerated = getCompiledValueCode(firstExpr.code, firstExpr.generatedCodeType);
        const rightGenerated = getCompiledValueCode(secondExpr.code, secondExpr.generatedCodeType);

        if (
                (leftGenerated[1].type === GeneratedCodeBaseType.Value ||
                        leftGenerated[1].type === GeneratedCodeBaseType.Variable) &&
                (rightGenerated[1].type === GeneratedCodeBaseType.Value ||
                        rightGenerated[1].type === GeneratedCodeBaseType.Variable)
        ) {
                return acceptAst(
                        `function ${identifier}(contextItem) {
                                ${firstExpr.variables.join('\n')}
                                 ${secondExpr.variables.join('\n')}
                              return ${leftGenerated[0]} ${operator} ${rightGenerated[0]};
                        }`,
                        {
                                type: GeneratedCodeBaseType.Function,
                                returnType: { type: GeneratedCodeBaseType.Value },
                        }
                );
        }

        const code = `
        function ${identifier}(contextItem) {
                ${firstExpr.variables.join('\n')}
                ${secondExpr.variables.join('\n')}

                let atomizedLeft;
                if (${leftGenerated[0]}.next) {
                        atomizedLeft = atomize({value: ${leftGenerated[0]}}, {domFacade}).getAllValues().map(x => x.value);
                } else {
                        atomizedLeft = [${leftGenerated[0]}];
                }
                let atomizedRight;
                if (${rightGenerated[0]}.next) {
                        atomizedRight = atomize({value: ${
                                rightGenerated[0]
                        }}, {domFacade}).getAllValues().map(x => x.value);
                } else {
                        atomizedRight = [${rightGenerated[0]}];
                }

                if (atomizedLeft.length === 0 || atomizedRight.length === 0) return [];
                
                return atomizedLeft[0] ${operator} atomizedRight[0];
        }
        `;

        return acceptAst(code, {
                type: GeneratedCodeBaseType.Function,
                returnType: { type: GeneratedCodeBaseType.Value },
        });
}

/**
 * Generates javascript code for a general compare expression.
 *
 * @param ast The ast of the general compare expression
 * @param compareType The type of comparison we're executing
 * @param firstExpr The generated code of the first expression
 * @param secondExpr The generated code of the second expression
 * @param identifier The identifier of the result
 * @param staticContext The code generation context
 * @returns Generated code of the general compare
 */
export function emitGeneralCompare(
        ast: IAST,
        compareType: string,
        firstExpr: PartialCompilationResult,
        secondExpr: PartialCompilationResult,
        identifier: string,
        staticContext: CodeGenContext
): PartialCompilationResult {
        const firstAstOp = astHelper.getFirstChild(ast, 'firstOperand')[1] as IAST;
        const firstType: SequenceType = astHelper.getAttribute(ast, 'type');
        const secondAstOp = astHelper.getFirstChild(ast, 'secondOperand')[1] as IAST;
        const secondType: SequenceType = astHelper.getAttribute(ast, 'type');
        if (!firstType || !secondType) {
                return rejectAst('types of compare are not known');
        }
        if (
                firstType.mult === SequenceMultiplicity.EXACTLY_ONE &&
                secondType.mult === SequenceMultiplicity.EXACTLY_ONE
        ) {
                return emitValueCompare(
                        ast,
                        OPERATOR_TRANSLATION[compareType],
                        firstExpr,
                        secondExpr,
                        identifier,
                        staticContext
                );
        } else {
                return rejectAst('generalCompare with sequences is still in development');
        }
}

/**
 * Compiles compare expressions to a JavaScript function.
 *
 *
 * @param ast Logical expression AST node.
 * @param identifier Function identifier for the emitted function
 * @param staticContext Static context parameter to retrieve context-dependent information.
 * @param compareType The exact operator that will be compiled
 * @returns Wrapped compare expression.
 */
export function emitCompareExpr(
        ast: IAST,
        identifier: FunctionIdentifier,
        staticContext: CodeGenContext,
        compareType: string
): PartialCompilationResult {
        const firstExpr = emitOperand(ast, identifier, 'firstOperand', staticContext);
        if (!firstExpr.isAstAccepted) {
                return firstExpr;
        }

        const secondExpr = emitOperand(ast, identifier, 'secondOperand', staticContext);
        if (!secondExpr.isAstAccepted) {
                return secondExpr;
        }

        switch (compareType) {
                // valueCompare
                case 'eqOp':
                case 'neOp':
                case 'ltOp':
                case 'leOp':
                case 'gtOp':
                case 'geOp':
                case 'isOp':
                        return emitValueCompare(
                                ast,
                                compareType,
                                firstExpr,
                                secondExpr,
                                identifier,
                                staticContext
                        );
                // generalCompare
                case 'equalOp':
                case 'notEqualOp':
                case 'lessThanOrEqualOp':
                case 'lessThanOp':
                case 'greaterThanOrEqualOp':
                case 'greaterThanOp':
                        return emitGeneralCompare(
                                ast,
                                compareType,
                                firstExpr,
                                secondExpr,
                                identifier,
                                staticContext
                        );
                // nodeCompare
                case 'nodeBeforeOp':
                case 'nodeAfterOp':
                default:
                        return rejectAst('Unsupported compare type');
        }
}

/**
 *  A map to translate from general compare to value compare
 */
const OPERATOR_TRANSLATION: { [s: string]: string } = {
        ['equalOp']: 'eqOp',
        ['notEqualOp']: 'neOp',
        ['lessThanOrEqualOp']: 'leOp',
        ['lessThanOp']: 'ltOp',
        ['greaterThanOrEqualOp']: 'geOp',
        ['greaterThanOp']: 'gtOp',
};

1	import {	18✔
2	SequenceMultiplicity,
3	SequenceType,
4	ValueType,
5	valueTypeToString,
6	} from '../expressions/dataTypes/Value';
7	import astHelper, { IAST } from '../parsing/astHelper';	18✔
8	import { CodeGenContext } from './CodeGenContext';
9	import { emitOperand } from './emitOperand';	18✔
10	// import { emitBaseExpr } from './emitBaseExpression';
11	import {	18✔
12	acceptAst,
13	FunctionIdentifier,
14	GeneratedCodeBaseType,
15	getCompiledValueCode,
16	PartialCompilationResult,
17	rejectAst,
18	} from './JavaScriptCompiledXPath';
19
20	/**
21	* Generates javascript code for a value compare expression.
22	*
23	* @param ast The ast of the value compare expression
24	* @param compareType The type of comparison we're executing
25	* @param firstExpr The generated code of the first expression
26	* @param secondExpr The generated code of the second expression
27	* @param identifier The identifier of the result
28	* @param staticContext The code generation context
29	* @returns Generated code of the value compare
30	*/
31	export function emitValueCompare(	18✔
32	ast: IAST,
33	compareType: string,
34	firstExpr: PartialCompilationResult,
35	secondExpr: PartialCompilationResult,
36	identifier: string,
37	_staticContext: CodeGenContext
38	): PartialCompilationResult {
39	const leftType = astHelper.getAttribute(	312✔
40	astHelper.getFirstChild(ast, 'firstOperand')[1] as IAST,
41	'type'
42	);
43	const rightType = astHelper.getAttribute(	312✔
44	astHelper.getFirstChild(ast, 'secondOperand')[1] as IAST,
45	'type'
46	);
47
48	if (!leftType \|\| !rightType) {	312✔
49	return rejectAst('Left or right type of compare are not found, annotation failed.');	12✔
50	}
51
52	const supportedTypes = [ValueType.ATTRIBUTE, ValueType.XSSTRING, ValueType.NODE];	300✔
53	if (!supportedTypes.includes(leftType.type) \|\| !supportedTypes.includes(rightType.type)) {	300!
NEW 54	return rejectAst(	×
55	`Unsupported types in compare: [${valueTypeToString(
56	leftType.type
57	)}, ${valueTypeToString(rightType.type)}]`
58	);
59	}
60
61	if (!firstExpr.isAstAccepted) {	300!
NEW 62	return firstExpr;	×
63	}
64	if (!secondExpr.isAstAccepted) {	300!
NEW 65	return secondExpr;	×
66	}
67
68	// Make sure both child expression got annotated
69	if (!leftType \|\| !rightType) {	300!
NEW 70	return rejectAst("Operands in compare weren't annotated");	×
71	}
72
73	const compareOperators: Record<string, string> = {	300✔
74	eqOp: '===',
75	neOp: '!==',
76	};
77
78	// Make sure we support the comparison type
79	if (!compareOperators[compareType]) {	300✔
80	return rejectAst(compareType + ' not yet implemented');	72✔
81	}
82
83	// Get the correct operator
84	const operator = compareOperators[compareType];	228✔
85
86	const leftGenerated = getCompiledValueCode(firstExpr.code, firstExpr.generatedCodeType);	228✔
87	const rightGenerated = getCompiledValueCode(secondExpr.code, secondExpr.generatedCodeType);	228✔
88
89	if (	228✔
90	(leftGenerated[1].type === GeneratedCodeBaseType.Value \|\|	720✔
91	leftGenerated[1].type === GeneratedCodeBaseType.Variable) &&
92	(rightGenerated[1].type === GeneratedCodeBaseType.Value \|\|
93	rightGenerated[1].type === GeneratedCodeBaseType.Variable)
94	) {
95	return acceptAst(	120✔
96	`function ${identifier}(contextItem) {
97	${firstExpr.variables.join('\n')}
98	${secondExpr.variables.join('\n')}
99	return ${leftGenerated[0]} ${operator} ${rightGenerated[0]};
100	}`,
101	{
102	type: GeneratedCodeBaseType.Function,
103	returnType: { type: GeneratedCodeBaseType.Value },
104	}
105	);
106	}
107
108	const code = `	108✔
109	function ${identifier}(contextItem) {
110	${firstExpr.variables.join('\n')}
111	${secondExpr.variables.join('\n')}
112
113	let atomizedLeft;
114	if (${leftGenerated[0]}.next) {
115	atomizedLeft = atomize({value: ${leftGenerated[0]}}, {domFacade}).getAllValues().map(x => x.value);
116	} else {
117	atomizedLeft = [${leftGenerated[0]}];
118	}
119	let atomizedRight;
120	if (${rightGenerated[0]}.next) {
121	atomizedRight = atomize({value: ${
122	rightGenerated[0]
123	}}, {domFacade}).getAllValues().map(x => x.value);
124	} else {
125	atomizedRight = [${rightGenerated[0]}];
126	}
127
128	if (atomizedLeft.length === 0 \|\| atomizedRight.length === 0) return [];
129
130	return atomizedLeft[0] ${operator} atomizedRight[0];
131	}
132	`;
133
134	return acceptAst(code, {	108✔
135	type: GeneratedCodeBaseType.Function,
136	returnType: { type: GeneratedCodeBaseType.Value },
137	});
138	}
139
140	/**
141	* Generates javascript code for a general compare expression.
142	*
143	* @param ast The ast of the general compare expression
144	* @param compareType The type of comparison we're executing
145	* @param firstExpr The generated code of the first expression
146	* @param secondExpr The generated code of the second expression
147	* @param identifier The identifier of the result
148	* @param staticContext The code generation context
149	* @returns Generated code of the general compare
150	*/
151	export function emitGeneralCompare(	18✔
152	ast: IAST,
153	compareType: string,
154	firstExpr: PartialCompilationResult,
155	secondExpr: PartialCompilationResult,
156	identifier: string,
157	staticContext: CodeGenContext
158	): PartialCompilationResult {
159	const firstAstOp = astHelper.getFirstChild(ast, 'firstOperand')[1] as IAST;	48✔
160	const firstType: SequenceType = astHelper.getAttribute(ast, 'type');	48✔
161	const secondAstOp = astHelper.getFirstChild(ast, 'secondOperand')[1] as IAST;	48✔
162	const secondType: SequenceType = astHelper.getAttribute(ast, 'type');	48✔
163	if (!firstType \|\| !secondType) {	48!
NEW 164	return rejectAst('types of compare are not known');	×
165	}
166	if (	48!
167	firstType.mult === SequenceMultiplicity.EXACTLY_ONE &&	96✔
168	secondType.mult === SequenceMultiplicity.EXACTLY_ONE
169	) {
170	return emitValueCompare(	48✔
171	ast,
172	OPERATOR_TRANSLATION[compareType],
173	firstExpr,
174	secondExpr,
175	identifier,
176	staticContext
177	);
178	} else {
NEW 179	return rejectAst('generalCompare with sequences is still in development');	×
180	}
181	}
182
183	/**
184	* Compiles compare expressions to a JavaScript function.
185	*
186	*
187	* @param ast Logical expression AST node.
188	* @param identifier Function identifier for the emitted function
189	* @param staticContext Static context parameter to retrieve context-dependent information.
190	* @param compareType The exact operator that will be compiled
191	* @returns Wrapped compare expression.
192	*/
193	export function emitCompareExpr(	18✔
194	ast: IAST,
195	identifier: FunctionIdentifier,
196	staticContext: CodeGenContext,
197	compareType: string
198	): PartialCompilationResult {
199	const firstExpr = emitOperand(ast, identifier, 'firstOperand', staticContext);	18,972✔
200	if (!firstExpr.isAstAccepted) {	18,972✔
201	return firstExpr;	18,510✔
202	}
203
204	const secondExpr = emitOperand(ast, identifier, 'secondOperand', staticContext);	462✔
205	if (!secondExpr.isAstAccepted) {	462✔
206	return secondExpr;	150✔
207	}
208
209	switch (compareType) {	312✔
210	// valueCompare
211	case 'eqOp':	1,797!
212	case 'neOp':
213	case 'ltOp':
214	case 'leOp':
215	case 'gtOp':
216	case 'geOp':
217	case 'isOp':
218	return emitValueCompare(	264✔
219	ast,
220	compareType,
221	firstExpr,
222	secondExpr,
223	identifier,
224	staticContext
225	);
226	// generalCompare
227	case 'equalOp':
228	case 'notEqualOp':
229	case 'lessThanOrEqualOp':
230	case 'lessThanOp':
231	case 'greaterThanOrEqualOp':
232	case 'greaterThanOp':
233	return emitGeneralCompare(	48✔
234	ast,
235	compareType,
236	firstExpr,
237	secondExpr,
238	identifier,
239	staticContext
240	);
241	// nodeCompare
242	case 'nodeBeforeOp':
243	case 'nodeAfterOp':
244	default:
NEW 245	return rejectAst('Unsupported compare type');	×
246	}
247	}
248
249	/**
250	* A map to translate from general compare to value compare
251	*/
252	const OPERATOR_TRANSLATION: { [s: string]: string } = {	18✔
253	['equalOp']: 'eqOp',
254	['notEqualOp']: 'neOp',
255	['lessThanOrEqualOp']: 'leOp',
256	['lessThanOp']: 'ltOp',
257	['greaterThanOrEqualOp']: 'geOp',
258	['greaterThanOp']: 'gtOp',
259	};

FontoXML / fontoxpath / 1143371400

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