970660600

Build Type

push

github

Committed by GitHub

Commit Message

Optimise ValueCompare more by checking for multiplicities

Run Details

4625 of 4970 branches covered (93.06%)

Branch coverage included in aggregate %.

22 of 23 new or added lines in 2 files covered. (95.65%)

3 existing lines in 1 file now uncovered.

9253 of 9485 relevant lines covered (97.55%)

1915050.92 hits per line

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

82.65

/src/typeInference/annotateFlworExpression.ts

import { SequenceMultiplicity, SequenceType, ValueType } from '../expressions/dataTypes/Value';
import astHelper, { IAST } from '../parsing/astHelper';
import { AnnotationContext } from './AnnotationContext';

/**
 * A method to annotate the FLWORExpression.
 * @param ast The ast containing the FLWORExpression
 * @param annotationContext THe context in which it gets annotated
 * @param annotate the annotationFunction as a callback
 * @returns The type of the entire ast, it always returns a item()*
 * if the expression contains a for loop otherwise it returns what the returnClause returns.
 */
export function annotateFlworExpression(
        ast: IAST,
        annotationContext: AnnotationContext,
        annotate: (ast: IAST, annotationContext: AnnotationContext) => SequenceType
): SequenceType | undefined {
        let hasFor = false;
        for (let i = 1; i < ast.length; i++) {
                switch ((ast[i] as IAST)[0]) {
                        case 'letClause': {
                                annotationContext.pushScope();
                                annotateLetClause(ast[i] as IAST, annotationContext, annotate);
                                break;
                        }
                        case 'forClause': {
                                // `For` expression returns sequence type (XS:ITEM)
                                // However, the variable registration of the elements in the sequence is not properly handled
                                // We only register the variable types if they are all of the same type
                                hasFor = true;
                                annotationContext.pushScope();
                                annotateForClause(ast[i] as IAST, annotationContext, annotate);
                                break;
                        }
                        case 'whereClause': {
                                annotationContext.pushScope();
                                annotateWhereClause(ast[i] as IAST, annotationContext, annotate);
                                break;
                        }
                        case 'orderByClause': {
                                annotationContext.pushScope();
                                annotateOrderByClause(ast[i] as IAST, annotationContext);
                                break;
                        }
                        case 'returnClause': {
                                let retType: SequenceType = annotateReturnType(
                                        ast[i] as IAST,
                                        annotationContext,
                                        annotate
                                );

                                if (!retType) {
                                        return { type: ValueType.ITEM, mult: SequenceMultiplicity.ZERO_OR_MORE };
                                }

                                if (hasFor) {
                                        retType = { type: retType.type, mult: SequenceMultiplicity.ZERO_OR_MORE };
                                }

                                if (retType.type !== ValueType.ITEM) {
                                        astHelper.insertAttribute(ast, 'type', retType);
                                }
                                return retType;
                        }
                        default: {
                                let retType: SequenceType = annotate(ast[i] as IAST, annotationContext);

                                if (!retType) {
                                        return { type: ValueType.ITEM, mult: SequenceMultiplicity.ZERO_OR_MORE };
                                }

                                if (hasFor) {
                                        retType = { type: retType.type, mult: SequenceMultiplicity.ZERO_OR_MORE };
                                }

                                if (retType.type !== ValueType.ITEM) {
                                        astHelper.insertAttribute(ast, 'type', retType);
                                }
                                return retType;
                        }
                }
        }
        annotationContext.popScope();
        return undefined;
}

/**
 * This method annotates the LetClause of the FLWORExpression,
 * the letClause does not return anything but only introduces new variables.
 * @param ast The ast containing the letClause
 * @param annotationContext The context in which it gets annotated and in which new variables will be introduced
 * @param annotate the annotate function as a callback to annotate the children
 */
function annotateLetClause(
        ast: IAST,
        annotationContext: AnnotationContext,
        annotate: (ast: IAST, annotationContext: AnnotationContext) => SequenceType
): void {
        const pathToVarName: string[] = ['letClauseItem', 'typedVariableBinding', 'varName'];
        const varNameNode: IAST = astHelper.followPath(ast, pathToVarName);
        const varName = varNameNode[1] as string;

        const pathToVarType: string[] = ['letClauseItem', 'letExpr'];
        const varTypeNode: IAST = astHelper.followPath(ast, pathToVarType);

        const varType: SequenceType = annotate(varTypeNode[1] as IAST, annotationContext);

        annotationContext.insertVariable(varName, varType);
}

/**
 * A method to annotate the ForClause.
 * @param ast the ast containing the forClause
 * @param annotationContext the context in which its being annotated
 * @param annotate the annotate function as a callback to annotate the children
 */
function annotateForClause(
        ast: IAST,
        annotationContext: AnnotationContext,
        annotate: (ast: IAST, annotationContext: AnnotationContext) => SequenceType
): void {
        const pathToTypedVariableBinding = ['forClauseItem', 'typedVariableBinding', 'varName'];
        const pathToForExpr = ['forClauseItem', 'forExpr', 'sequenceExpr'];

        const varName = astHelper.followPath(ast, pathToTypedVariableBinding)[1] as string;

        const varTypeNode: IAST = astHelper.followPath(ast, pathToForExpr);
        if (!varTypeNode) {
                return;
        }

        // A set of all the SequenceType in the sequenceExpr
        const allTypes: SequenceType[] = astHelper
                .getChildren(varTypeNode, '*')
                .map((element) => annotate(element, annotationContext));

        if (allTypes.includes(undefined) || allTypes.includes(null)) {
                // Includes undefined so we can't annotate this
                return;
        }

        // filter on unique types
        const types = filterOnUniqueObjects(allTypes);

        // if there is only 1 unique type we can add the variable to have this type.
        if (types.length === 1) {
                annotationContext.insertVariable(varName, types[0]);
        }
}

/**
 * Annotate the where clause.
 * @param ast the ast containing the whereClause
 * @param annotationContext the context in which its being annotated
 * @param annotate the annotate function as a callback to annotate the children
 * @returns always returns exactly 1 boolean
 */
function annotateWhereClause(
        ast: IAST,
        annotationContext: AnnotationContext,
        annotate: (ast: IAST, annotationContext: AnnotationContext) => SequenceType
): SequenceType {
        const seqType = {
                type: ValueType.XSBOOLEAN,
                mult: SequenceMultiplicity.EXACTLY_ONE,
        };

        // Annotate the child nodes
        annotate(ast, annotationContext);

        astHelper.insertAttribute(ast, 'type', seqType);
        return seqType;
}

function annotateOrderByClause(ast: IAST, annotationContext: AnnotationContext): undefined {
        return undefined;
}

/**
 * A method to filter a SequenceTypeArray to only have unique items,
 *  by filtering the items whose first index is not equal to its own.
 * @param array the array to be filtered
 * @returns the filtered array
 */
export function filterOnUniqueObjects(array: SequenceType[]): SequenceType[] {
        return array.filter(
                (current, index, arrayCopy) =>
                        arrayCopy.findIndex(
                                (element) => element.type === current.type && element.mult === current.mult
                        ) === index
        );
}
function annotateReturnType(
        ast: IAST,
        context: AnnotationContext,
        annotate: (ast: IAST, context: AnnotationContext) => SequenceType
): SequenceType {
        const pathFollowed: IAST = astHelper.followPath(ast, ['*']);
        const returnType = annotate(pathFollowed, context);
        astHelper.insertAttribute(pathFollowed, 'type', returnType);
        astHelper.insertAttribute(ast as IAST, 'type', returnType);
        return returnType;
}

1	import { SequenceMultiplicity, SequenceType, ValueType } from '../expressions/dataTypes/Value';
2	import astHelper, { IAST } from '../parsing/astHelper';	6✔
3	import { AnnotationContext } from './AnnotationContext';
4
5	/**
6	* A method to annotate the FLWORExpression.
7	* @param ast The ast containing the FLWORExpression
8	* @param annotationContext THe context in which it gets annotated
9	* @param annotate the annotationFunction as a callback
10	* @returns The type of the entire ast, it always returns a item()*
11	* if the expression contains a for loop otherwise it returns what the returnClause returns.
12	*/
13	export function annotateFlworExpression(	6✔
14	ast: IAST,
15	annotationContext: AnnotationContext,
16	annotate: (ast: IAST, annotationContext: AnnotationContext) => SequenceType
17	): SequenceType \| undefined {
18	let hasFor = false;	2,321✔
19	for (let i = 1; i < ast.length; i++) {	2,321✔
20	switch ((ast[i] as IAST)[0]) {	5,247✔
21	case 'letClause': {	5,247!
22	annotationContext.pushScope();	1,419✔
23	annotateLetClause(ast[i] as IAST, annotationContext, annotate);	1,419✔
24	break;	1,419✔
25	}
26	case 'forClause': {
27	// `For` expression returns sequence type (XS:ITEM)
28	// However, the variable registration of the elements in the sequence is not properly handled
29	// We only register the variable types if they are all of the same type
30	hasFor = true;	1,248✔
31	annotationContext.pushScope();	1,248✔
32	annotateForClause(ast[i] as IAST, annotationContext, annotate);	1,248✔
33	break;	1,248✔
34	}
35	case 'whereClause': {
36	annotationContext.pushScope();	121✔
37	annotateWhereClause(ast[i] as IAST, annotationContext, annotate);	121✔
38	break;	121✔
39	}
40	case 'orderByClause': {
41	annotationContext.pushScope();	138✔
42	annotateOrderByClause(ast[i] as IAST, annotationContext);	138✔
43	break;	138✔
44	}
45	case 'returnClause': {
46	let retType: SequenceType = annotateReturnType(	2,321✔
47	ast[i] as IAST,
48	annotationContext,
49	annotate
50	);
51
52	if (!retType) {	2,320✔
53	return { type: ValueType.ITEM, mult: SequenceMultiplicity.ZERO_OR_MORE };	479✔
54	}
55
56	if (hasFor) {	1,841✔
57	retType = { type: retType.type, mult: SequenceMultiplicity.ZERO_OR_MORE };	872✔
58	}
59
60	if (retType.type !== ValueType.ITEM) {	1,841✔
61	astHelper.insertAttribute(ast, 'type', retType);	1,109✔
62	}
63	return retType;	1,841✔
64	}
65	default: {
UNCOV 66	let retType: SequenceType = annotate(ast[i] as IAST, annotationContext);	×
67
UNCOV 68	if (!retType) {	×
UNCOV 69	return { type: ValueType.ITEM, mult: SequenceMultiplicity.ZERO_OR_MORE };	×
70	}
71
72	if (hasFor) {	×
73	retType = { type: retType.type, mult: SequenceMultiplicity.ZERO_OR_MORE };	×
74	}
75
76	if (retType.type !== ValueType.ITEM) {	×
77	astHelper.insertAttribute(ast, 'type', retType);	×
78	}
79	return retType;	×
80	}
81	}
82	}
83	annotationContext.popScope();	×
84	return undefined;	×
85	}
86
87	/**
88	* This method annotates the LetClause of the FLWORExpression,
89	* the letClause does not return anything but only introduces new variables.
90	* @param ast The ast containing the letClause
91	* @param annotationContext The context in which it gets annotated and in which new variables will be introduced
92	* @param annotate the annotate function as a callback to annotate the children
93	*/
94	function annotateLetClause(
95	ast: IAST,
96	annotationContext: AnnotationContext,
97	annotate: (ast: IAST, annotationContext: AnnotationContext) => SequenceType
98	): void {
99	const pathToVarName: string[] = ['letClauseItem', 'typedVariableBinding', 'varName'];	1,419✔
100	const varNameNode: IAST = astHelper.followPath(ast, pathToVarName);	1,419✔
101	const varName = varNameNode[1] as string;	1,419✔
102
103	const pathToVarType: string[] = ['letClauseItem', 'letExpr'];	1,419✔
104	const varTypeNode: IAST = astHelper.followPath(ast, pathToVarType);	1,419✔
105
106	const varType: SequenceType = annotate(varTypeNode[1] as IAST, annotationContext);	1,419✔
107
108	annotationContext.insertVariable(varName, varType);	1,419✔
109	}
110
111	/**
112	* A method to annotate the ForClause.
113	* @param ast the ast containing the forClause
114	* @param annotationContext the context in which its being annotated
115	* @param annotate the annotate function as a callback to annotate the children
116	*/
117	function annotateForClause(
118	ast: IAST,
119	annotationContext: AnnotationContext,
120	annotate: (ast: IAST, annotationContext: AnnotationContext) => SequenceType
121	): void {
122	const pathToTypedVariableBinding = ['forClauseItem', 'typedVariableBinding', 'varName'];	1,248✔
123	const pathToForExpr = ['forClauseItem', 'forExpr', 'sequenceExpr'];	1,248✔
124
125	const varName = astHelper.followPath(ast, pathToTypedVariableBinding)[1] as string;	1,248✔
126
127	const varTypeNode: IAST = astHelper.followPath(ast, pathToForExpr);	1,248✔
128	if (!varTypeNode) {	1,248✔
129	return;	1,051✔
130	}
131
132	// A set of all the SequenceType in the sequenceExpr
133	const allTypes: SequenceType[] = astHelper	197✔
134	.getChildren(varTypeNode, '*')
135	.map((element) => annotate(element, annotationContext));	1,563✔
136
137	if (allTypes.includes(undefined) \|\| allTypes.includes(null)) {	197✔
138	// Includes undefined so we can't annotate this
139	return;	20✔
140	}
141
142	// filter on unique types
143	const types = filterOnUniqueObjects(allTypes);	177✔
144
145	// if there is only 1 unique type we can add the variable to have this type.
146	if (types.length === 1) {	177✔
147	annotationContext.insertVariable(varName, types[0]);	147✔
148	}
149	}
150
151	/**
152	* Annotate the where clause.
153	* @param ast the ast containing the whereClause
154	* @param annotationContext the context in which its being annotated
155	* @param annotate the annotate function as a callback to annotate the children
156	* @returns always returns exactly 1 boolean
157	*/
158	function annotateWhereClause(
159	ast: IAST,
160	annotationContext: AnnotationContext,
161	annotate: (ast: IAST, annotationContext: AnnotationContext) => SequenceType
162	): SequenceType {
163	const seqType = {	121✔
164	type: ValueType.XSBOOLEAN,
165	mult: SequenceMultiplicity.EXACTLY_ONE,
166	};
167
168	// Annotate the child nodes
169	annotate(ast, annotationContext);	121✔
170
171	astHelper.insertAttribute(ast, 'type', seqType);	121✔
172	return seqType;	121✔
173	}
174
175	function annotateOrderByClause(ast: IAST, annotationContext: AnnotationContext): undefined {
176	return undefined;	138✔
177	}
178
179	/**
180	* A method to filter a SequenceTypeArray to only have unique items,
181	* by filtering the items whose first index is not equal to its own.
182	* @param array the array to be filtered
183	* @returns the filtered array
184	*/
185	export function filterOnUniqueObjects(array: SequenceType[]): SequenceType[] {	6✔
186	return array.filter(	3,906✔
187	(current, index, arrayCopy) =>
188	arrayCopy.findIndex(	11,753✔
189	(element) => element.type === current.type && element.mult === current.mult	14,046✔
190	) === index
191	);
192	}
193	function annotateReturnType(
194	ast: IAST,
195	context: AnnotationContext,
196	annotate: (ast: IAST, context: AnnotationContext) => SequenceType
197	): SequenceType {
198	const pathFollowed: IAST = astHelper.followPath(ast, ['*']);	2,321✔
199	const returnType = annotate(pathFollowed, context);	2,321✔
200	astHelper.insertAttribute(pathFollowed, 'type', returnType);	2,320✔
201	astHelper.insertAttribute(ast as IAST, 'type', returnType);	2,320✔
202	return returnType;	2,320✔
203	}

FontoXML / fontoxpath / 970660600

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