1143360288

Build Type

github

Committed by GitHub

Commit Message

Merge 9af7a04b0 into c44a09941

Pull Request Pull Request #349: Improve fuzzer

Run Details

4717 of 5068 branches covered (93.07%)

Branch coverage included in aggregate %.

200 of 212 new or added lines in 12 files covered. (94.34%)

1 existing line in 1 file now uncovered.

9394 of 9624 relevant lines covered (97.61%)

5677820.51 hits per line

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

85.86

/src/jsCodegen/emitCompare.ts

import { SequenceMultiplicity, SequenceType, ValueType } from '../expressions/dataTypes/Value';
import astHelper, { IAST } from '../parsing/astHelper';
import { CodeGenContext } from './CodeGenContext';
import { emitOperand } from './emitOperand';
// import { emitBaseExpr } from './emitBaseExpression';
import {
        acceptAst,
        CompiledResultType,
        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.XSSTRING, ValueType.NODE];
        if (!supportedTypes.includes(leftType.type) || !supportedTypes.includes(rightType.type)) {
                return rejectAst('Unsupported types in compare');
        }

        if (!firstExpr.isAstAccepted || !secondExpr.isAstAccepted) {
                return rejectAst("One of the two operands in compare wasn't accepted");
        }

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

FontoXML / fontoxpath / 1143360288

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