1015529893

Build Type

push

github

Committed by Hector Peeters

Commit Message

Change a few occurences of annotateAst to true

Run Details

4346 of 4684 branches covered (92.78%)

Branch coverage included in aggregate %.

1 of 2 new or added lines in 2 files covered. (50.0%)

11 existing lines in 2 files now uncovered.

8460 of 8733 relevant lines covered (96.87%)

1191949.49 hits per line

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

46.15

/src/typeInference/annotateBinaryOperator.ts

import { SequenceType, sequenceTypeToString, ValueType } from '../expressions/dataTypes/Value';
import {
        addDuration as addDurationToDateTime,
        subtractDuration as subDurationFromDateTime,
} from '../expressions/dataTypes/valueTypes/DateTime';
import {
        add as dayTimeDurationAdd,
        divideByDayTimeDuration as dayTimeDurationDivideByDayTimeDuration,
        multiply as dayTimeDurationMultiply,
        subtract as dayTimeDurationSub,
} from '../expressions/dataTypes/valueTypes/DayTimeDuration';
import {
        add as yearMonthDurationAdd,
        divide as yearMonthDurationDivide,
        divideByYearMonthDuration as yearMonthDurationDivideByYearMonthDuration,
        multiply as yearMonthDurationMultiply,
        subtract as yearMonthDurationSub,
} from '../expressions/dataTypes/valueTypes/YearMonthDuration';
import { IAST } from '../parsing/astHelper';
import { BinaryEvaluationFunction } from './binaryEvaluationFunction';
import { insertAttribute } from './insertAttribute';

function hash(left: ValueType, right: ValueType, op: string): number {
        return (
                ((left as number) << 20) +
                ((right as number) << 12) +
                (op.charCodeAt(0) << 8) +
                op.charCodeAt(1)
        );
}

type EvalFuncTable = {
        [key: number]: [BinaryEvaluationFunction, ValueType];
};

const BINOP_EVAL_FUNCTIONS: EvalFuncTable = {
        [hash(ValueType.XSINTEGER, ValueType.XSINTEGER, 'add')]: [
                (l: number, r: number) => l + r,
                ValueType.XSINTEGER,
        ],
        [hash(ValueType.XSFLOAT, ValueType.XSFLOAT, 'add')]: [
                (l: number, r: number) => l + r,
                ValueType.XSFLOAT,
        ],
        [hash(ValueType.XSDOUBLE, ValueType.XSDOUBLE, 'add')]: [
                (l: number, r: number) => l + r,
                ValueType.XSDOUBLE,
        ],
        [hash(ValueType.XSDECIMAL, ValueType.XSDECIMAL, 'add')]: [
                (l: number, r: number) => l + r,
                ValueType.XSDECIMAL,
        ],
        [hash(ValueType.XSNUMERIC, ValueType.XSNUMERIC, 'add')]: [
                (l: number, r: number) => l + r,
                ValueType.XSDECIMAL,
        ],
        [hash(ValueType.XSYEARMONTHDURATION, ValueType.XSYEARMONTHDURATION, 'add')]: [
                yearMonthDurationAdd,
                ValueType.XSYEARMONTHDURATION,
        ],
        [hash(ValueType.XSDAYTIMEDURATION, ValueType.XSDAYTIMEDURATION, 'add')]: [
                dayTimeDurationAdd,
                ValueType.XSDAYTIMEDURATION,
        ],
        [hash(ValueType.XSDATETIME, ValueType.XSYEARMONTHDURATION, 'add')]: [
                addDurationToDateTime,
                ValueType.XSDATETIME,
        ],
        [hash(ValueType.XSDATETIME, ValueType.XSDAYTIMEDURATION, 'add')]: [
                addDurationToDateTime,
                ValueType.XSDATETIME,
        ],
        [hash(ValueType.XSDATE, ValueType.XSYEARMONTHDURATION, 'add')]: [
                addDurationToDateTime,
                ValueType.XSDATE,
        ],
        [hash(ValueType.XSDATE, ValueType.XSDAYTIMEDURATION, 'add')]: [
                addDurationToDateTime,
                ValueType.XSDATE,
        ],
        [hash(ValueType.XSTIME, ValueType.XSDAYTIMEDURATION, 'add')]: [
                addDurationToDateTime,
                ValueType.XSTIME,
        ],
        [hash(ValueType.XSDATETIME, ValueType.XSYEARMONTHDURATION, 'add')]: [
                addDurationToDateTime,
                ValueType.XSDATETIME,
        ],
        [hash(ValueType.XSTIME, ValueType.XSDAYTIMEDURATION, 'add')]: [
                addDurationToDateTime,
                ValueType.XSDATETIME,
        ],
        [hash(ValueType.XSINTEGER, ValueType.XSINTEGER, 'sub')]: [
                (l: number, r: number) => l - r,
                ValueType.XSINTEGER,
        ],
        [hash(ValueType.XSFLOAT, ValueType.XSFLOAT, 'sub')]: [
                (l: number, r: number) => l - r,
                ValueType.XSFLOAT,
        ],
        [hash(ValueType.XSDOUBLE, ValueType.XSDOUBLE, 'sub')]: [
                (l: number, r: number) => l - r,
                ValueType.XSDOUBLE,
        ],
        [hash(ValueType.XSDECIMAL, ValueType.XSDECIMAL, 'sub')]: [
                (l: number, r: number) => l - r,
                ValueType.XSDECIMAL,
        ],
        [hash(ValueType.XSNUMERIC, ValueType.XSNUMERIC, 'sub')]: [
                (l: number, r: number) => l - r,
                ValueType.XSDECIMAL,
        ],
        [hash(ValueType.XSYEARMONTHDURATION, ValueType.XSYEARMONTHDURATION, 'sub')]: [
                yearMonthDurationSub,
                ValueType.XSYEARMONTHDURATION,
        ],
        [hash(ValueType.XSDAYTIMEDURATION, ValueType.XSDAYTIMEDURATION, 'sub')]: [
                dayTimeDurationSub,
                ValueType.XSDAYTIMEDURATION,
        ],
        [hash(ValueType.XSDATETIME, ValueType.XSYEARMONTHDURATION, 'sub')]: [
                subDurationFromDateTime,
                ValueType.XSDATETIME,
        ],
        [hash(ValueType.XSDATETIME, ValueType.XSDAYTIMEDURATION, 'sub')]: [
                subDurationFromDateTime,
                ValueType.XSDATETIME,
        ],
        [hash(ValueType.XSDATE, ValueType.XSYEARMONTHDURATION, 'sub')]: [
                subDurationFromDateTime,
                ValueType.XSDATE,
        ],
        [hash(ValueType.XSDATE, ValueType.XSDAYTIMEDURATION, 'sub')]: [
                subDurationFromDateTime,
                ValueType.XSDATE,
        ],
        [hash(ValueType.XSTIME, ValueType.XSDAYTIMEDURATION, 'sub')]: [
                subDurationFromDateTime,
                ValueType.XSTIME,
        ],
        [hash(ValueType.XSDATETIME, ValueType.XSYEARMONTHDURATION, 'sub')]: [
                subDurationFromDateTime,
                ValueType.XSDATETIME,
        ],
        [hash(ValueType.XSTIME, ValueType.XSDAYTIMEDURATION, 'sub')]: [
                subDurationFromDateTime,
                ValueType.XSDATETIME,
        ],
        [hash(ValueType.XSINTEGER, ValueType.XSINTEGER, 'mod')]: [
                (l: number, r: number) => l % r,
                ValueType.XSINTEGER,
        ],
        [hash(ValueType.XSDOUBLE, ValueType.XSDOUBLE, 'mod')]: [
                (l: number, r: number) => l % r,
                ValueType.XSDOUBLE,
        ],
        [hash(ValueType.XSFLOAT, ValueType.XSFLOAT, 'mod')]: [
                (l: number, r: number) => l % r,
                ValueType.XSFLOAT,
        ],
        [hash(ValueType.XSDECIMAL, ValueType.XSDECIMAL, 'mod')]: [
                (l: number, r: number) => l % r,
                ValueType.XSDECIMAL,
        ],
        [hash(ValueType.XSNUMERIC, ValueType.XSNUMERIC, 'multiply')]: [
                (l: number, r: number) => l * r,
                ValueType.XSINTEGER,
        ],
        [hash(ValueType.XSFLOAT, ValueType.XSFLOAT, 'multiply')]: [
                (l: number, r: number) => l * r,
                ValueType.XSFLOAT,
        ],
        [hash(ValueType.XSDOUBLE, ValueType.XSDOUBLE, 'multiply')]: [
                (l: number, r: number) => l * r,
                ValueType.XSDOUBLE,
        ],
        [hash(ValueType.XSDECIMAL, ValueType.XSDECIMAL, 'multiply')]: [
                (l: number, r: number) => l * r,
                ValueType.XSDECIMAL,
        ],
        [hash(ValueType.XSINTEGER, ValueType.XSINTEGER, 'multiply')]: [
                (l: number, r: number) => l * r,
                ValueType.XSDECIMAL,
        ],
        [hash(ValueType.XSYEARMONTHDURATION, ValueType.XSNUMERIC, 'multiply')]: [
                yearMonthDurationMultiply,
                ValueType.XSYEARMONTHDURATION,
        ],
        [hash(ValueType.XSNUMERIC, ValueType.XSYEARMONTHDURATION, 'multiply')]: [
                yearMonthDurationMultiply,
                ValueType.XSYEARMONTHDURATION,
        ],
        [hash(ValueType.XSDAYTIMEDURATION, ValueType.XSNUMERIC, 'multiply')]: [
                dayTimeDurationMultiply,
                ValueType.XSDAYTIMEDURATION,
        ],
        [hash(ValueType.XSNUMERIC, ValueType.XSDAYTIMEDURATION, 'multiply')]: [
                dayTimeDurationMultiply,
                ValueType.XSDAYTIMEDURATION,
        ],
        [hash(ValueType.XSINTEGER, ValueType.XSINTEGER, 'div')]: [
                (l: number, r: number) => l / r,
                ValueType.XSDECIMAL,
        ],
        [hash(ValueType.XSINTEGER, ValueType.XSDOUBLE, 'div')]: [
                (l: number, r: number) => l / r,
                ValueType.XSDOUBLE,
        ],
        [hash(ValueType.XSFLOAT, ValueType.XSFLOAT, 'div')]: [
                (l: number, r: number) => l / r,
                ValueType.XSFLOAT,
        ],
        [hash(ValueType.XSDOUBLE, ValueType.XSDOUBLE, 'div')]: [
                (l: number, r: number) => l / r,
                ValueType.XSDOUBLE,
        ],
        [hash(ValueType.XSDECIMAL, ValueType.XSDECIMAL, 'div')]: [
                (l: number, r: number) => l / r,
                ValueType.XSDECIMAL,
        ],
        [hash(ValueType.XSNUMERIC, ValueType.XSNUMERIC, 'div')]: [
                (l: number, r: number) => l / r,
                ValueType.XSDOUBLE,
        ],
        [hash(ValueType.XSYEARMONTHDURATION, ValueType.XSYEARMONTHDURATION, 'div')]: [
                yearMonthDurationDivideByYearMonthDuration,
                ValueType.XSDECIMAL,
        ],
        [hash(ValueType.XSYEARMONTHDURATION, ValueType.XSINTEGER, 'div')]: [
                yearMonthDurationDivide,
                ValueType.XSYEARMONTHDURATION,
        ],
        [hash(ValueType.XSYEARMONTHDURATION, ValueType.XSFLOAT, 'div')]: [
                yearMonthDurationDivide,
                ValueType.XSYEARMONTHDURATION,
        ],
        [hash(ValueType.XSYEARMONTHDURATION, ValueType.XSDOUBLE, 'div')]: [
                yearMonthDurationDivide,
                ValueType.XSYEARMONTHDURATION,
        ],
        [hash(ValueType.XSYEARMONTHDURATION, ValueType.XSDECIMAL, 'div')]: [
                yearMonthDurationDivide,
                ValueType.XSYEARMONTHDURATION,
        ],
        [hash(ValueType.XSYEARMONTHDURATION, ValueType.XSNUMERIC, 'div')]: [
                yearMonthDurationDivide,
                ValueType.XSYEARMONTHDURATION,
        ],
        [hash(ValueType.XSDAYTIMEDURATION, ValueType.XSDAYTIMEDURATION, 'div')]: [
                dayTimeDurationDivideByDayTimeDuration,
                ValueType.XSDECIMAL,
        ],
        [hash(ValueType.XSDAYTIMEDURATION, ValueType.XSINTEGER, 'div')]: [
                yearMonthDurationDivide,
                ValueType.XSDAYTIMEDURATION,
        ],
        [hash(ValueType.XSDAYTIMEDURATION, ValueType.XSFLOAT, 'div')]: [
                yearMonthDurationDivide,
                ValueType.XSDAYTIMEDURATION,
        ],
        [hash(ValueType.XSDAYTIMEDURATION, ValueType.XSDOUBLE, 'div')]: [
                yearMonthDurationDivide,
                ValueType.XSDAYTIMEDURATION,
        ],
        [hash(ValueType.XSDAYTIMEDURATION, ValueType.XSDECIMAL, 'div')]: [
                yearMonthDurationDivide,
                ValueType.XSDAYTIMEDURATION,
        ],
        [hash(ValueType.XSDAYTIMEDURATION, ValueType.XSNUMERIC, 'div')]: [
                yearMonthDurationDivide,
                ValueType.XSDAYTIMEDURATION,
        ],

        // Integer Division, numerator and denominator of the same type
        [hash(ValueType.XSINTEGER, ValueType.XSINTEGER, 'idiv')]: [
                (l: number, r: number) => Math.trunc(l / r),
                ValueType.XSINTEGER,
        ],
        [hash(ValueType.XSFLOAT, ValueType.XSFLOAT, 'idiv')]: [
                (l: number, r: number) => Math.trunc(l / r),
                ValueType.XSINTEGER,
        ],
        [hash(ValueType.XSDOUBLE, ValueType.XSDOUBLE, 'idiv')]: [
                (l: number, r: number) => Math.trunc(l / r),
                ValueType.XSINTEGER,
        ],
        [hash(ValueType.XSDECIMAL, ValueType.XSDECIMAL, 'idiv')]: [
                (l: number, r: number) => Math.trunc(l / r),
                ValueType.XSINTEGER,
        ],
        [hash(ValueType.XSNUMERIC, ValueType.XSNUMERIC, 'idiv')]: [
                (l: number, r: number) => Math.trunc(l / r),
                ValueType.XSINTEGER,
        ],

        // Integer Division, float over integer
        [hash(ValueType.XSFLOAT, ValueType.XSINTEGER, 'idiv')]: [
                (l: number, r: number) => Math.trunc(l / r),
                ValueType.XSINTEGER,
        ],
        // Integer Division, integer over float
        [hash(ValueType.XSINTEGER, ValueType.XSFLOAT, 'idiv')]: [
                (l: number, r: number) => Math.trunc(l / r),
                ValueType.XSINTEGER,
        ],

        // Integer Division, double over integer
        [hash(ValueType.XSDOUBLE, ValueType.XSINTEGER, 'idiv')]: [
                (l: number, r: number) => Math.trunc(l / r),
                ValueType.XSINTEGER,
        ],
        // Integer Division, integer over double
        [hash(ValueType.XSINTEGER, ValueType.XSDOUBLE, 'idiv')]: [
                (l: number, r: number) => Math.trunc(l / r),
                ValueType.XSINTEGER,
        ],

        // Integer Division, decimal over integer
        [hash(ValueType.XSDECIMAL, ValueType.XSINTEGER, 'idiv')]: [
                (l: number, r: number) => Math.trunc(l / r),
                ValueType.XSINTEGER,
        ],
        // Integer Division, integer over decimal
        [hash(ValueType.XSINTEGER, ValueType.XSDECIMAL, 'idiv')]: [
                (l: number, r: number) => Math.trunc(l / r),
                ValueType.XSINTEGER,
        ],

        // Integer Division, numeric over integer
        [hash(ValueType.XSNUMERIC, ValueType.XSINTEGER, 'idiv')]: [
                (l: number, r: number) => Math.trunc(l / r),
                ValueType.XSINTEGER,
        ],
        // Integer Division, integer over numeric
        [hash(ValueType.XSINTEGER, ValueType.XSNUMERIC, 'idiv')]: [
                (l: number, r: number) => Math.trunc(l / r),
                ValueType.XSINTEGER,
        ],
};

export function annotateBinOp(
        ast: IAST,
        left: SequenceType | undefined,
        right: SequenceType | undefined,
        operator: string
): SequenceType | undefined {
        if (!left || !right) {
                return undefined;
        }

        if (left.mult !== right.mult) {
                throw new Error("Multiplicities in binary addition operator don't match");
        }

        const funcData: [BinaryEvaluationFunction, ValueType] | undefined =
                BINOP_EVAL_FUNCTIONS[hash(left.type, right.type, operator)];

        if (funcData) {
                const type = { type: funcData[1], mult: left.mult };
                insertAttribute(ast, 'type', type);
                insertAttribute(ast, 'evalFunc', funcData[0]);
                return type;
        }

        throw new Error(
                `XPTY0004: ${operator} not available for types ${sequenceTypeToString(
                        left
                )} and ${sequenceTypeToString(right)}`
        );
}

1	import { SequenceType, sequenceTypeToString, ValueType } from '../expressions/dataTypes/Value';	5✔
2	import {	5✔
3	addDuration as addDurationToDateTime,
4	subtractDuration as subDurationFromDateTime,
5	} from '../expressions/dataTypes/valueTypes/DateTime';
6	import {	5✔
7	add as dayTimeDurationAdd,
8	divideByDayTimeDuration as dayTimeDurationDivideByDayTimeDuration,
9	multiply as dayTimeDurationMultiply,
10	subtract as dayTimeDurationSub,
11	} from '../expressions/dataTypes/valueTypes/DayTimeDuration';
12	import {	5✔
13	add as yearMonthDurationAdd,
14	divide as yearMonthDurationDivide,
15	divideByYearMonthDuration as yearMonthDurationDivideByYearMonthDuration,
16	multiply as yearMonthDurationMultiply,
17	subtract as yearMonthDurationSub,
18	} from '../expressions/dataTypes/valueTypes/YearMonthDuration';
19	import { IAST } from '../parsing/astHelper';
20	import { BinaryEvaluationFunction } from './binaryEvaluationFunction';
21	import { insertAttribute } from './insertAttribute';	5✔
22
23	function hash(left: ValueType, right: ValueType, op: string): number {
24	return (	380✔
25	((left as number) << 20) +
26	((right as number) << 12) +
27	(op.charCodeAt(0) << 8) +
28	op.charCodeAt(1)
29	);
30	}
31
32	type EvalFuncTable = {
33	[key: number]: [BinaryEvaluationFunction, ValueType];
34	};
35
36	const BINOP_EVAL_FUNCTIONS: EvalFuncTable = {	5✔
37	[hash(ValueType.XSINTEGER, ValueType.XSINTEGER, 'add')]: [
38	(l: number, r: number) => l + r,	8✔
39	ValueType.XSINTEGER,
40	],
41	[hash(ValueType.XSFLOAT, ValueType.XSFLOAT, 'add')]: [
42	(l: number, r: number) => l + r,	×
43	ValueType.XSFLOAT,
44	],
45	[hash(ValueType.XSDOUBLE, ValueType.XSDOUBLE, 'add')]: [
46	(l: number, r: number) => l + r,	×
47	ValueType.XSDOUBLE,
48	],
49	[hash(ValueType.XSDECIMAL, ValueType.XSDECIMAL, 'add')]: [
50	(l: number, r: number) => l + r,	×
51	ValueType.XSDECIMAL,
52	],
53	[hash(ValueType.XSNUMERIC, ValueType.XSNUMERIC, 'add')]: [
54	(l: number, r: number) => l + r,	×
55	ValueType.XSDECIMAL,
56	],
57	[hash(ValueType.XSYEARMONTHDURATION, ValueType.XSYEARMONTHDURATION, 'add')]: [
58	yearMonthDurationAdd,
59	ValueType.XSYEARMONTHDURATION,
60	],
61	[hash(ValueType.XSDAYTIMEDURATION, ValueType.XSDAYTIMEDURATION, 'add')]: [
62	dayTimeDurationAdd,
63	ValueType.XSDAYTIMEDURATION,
64	],
65	[hash(ValueType.XSDATETIME, ValueType.XSYEARMONTHDURATION, 'add')]: [
66	addDurationToDateTime,
67	ValueType.XSDATETIME,
68	],
69	[hash(ValueType.XSDATETIME, ValueType.XSDAYTIMEDURATION, 'add')]: [
70	addDurationToDateTime,
71	ValueType.XSDATETIME,
72	],
73	[hash(ValueType.XSDATE, ValueType.XSYEARMONTHDURATION, 'add')]: [
74	addDurationToDateTime,
75	ValueType.XSDATE,
76	],
77	[hash(ValueType.XSDATE, ValueType.XSDAYTIMEDURATION, 'add')]: [
78	addDurationToDateTime,
79	ValueType.XSDATE,
80	],
81	[hash(ValueType.XSTIME, ValueType.XSDAYTIMEDURATION, 'add')]: [
82	addDurationToDateTime,
83	ValueType.XSTIME,
84	],
85	[hash(ValueType.XSDATETIME, ValueType.XSYEARMONTHDURATION, 'add')]: [
86	addDurationToDateTime,
87	ValueType.XSDATETIME,
88	],
89	[hash(ValueType.XSTIME, ValueType.XSDAYTIMEDURATION, 'add')]: [
90	addDurationToDateTime,
91	ValueType.XSDATETIME,
92	],
93	[hash(ValueType.XSINTEGER, ValueType.XSINTEGER, 'sub')]: [
94	(l: number, r: number) => l - r,	×
95	ValueType.XSINTEGER,
96	],
97	[hash(ValueType.XSFLOAT, ValueType.XSFLOAT, 'sub')]: [
98	(l: number, r: number) => l - r,	×
99	ValueType.XSFLOAT,
100	],
101	[hash(ValueType.XSDOUBLE, ValueType.XSDOUBLE, 'sub')]: [
102	(l: number, r: number) => l - r,	×
103	ValueType.XSDOUBLE,
104	],
105	[hash(ValueType.XSDECIMAL, ValueType.XSDECIMAL, 'sub')]: [
106	(l: number, r: number) => l - r,	×
107	ValueType.XSDECIMAL,
108	],
109	[hash(ValueType.XSNUMERIC, ValueType.XSNUMERIC, 'sub')]: [
110	(l: number, r: number) => l - r,	×
111	ValueType.XSDECIMAL,
112	],
113	[hash(ValueType.XSYEARMONTHDURATION, ValueType.XSYEARMONTHDURATION, 'sub')]: [
114	yearMonthDurationSub,
115	ValueType.XSYEARMONTHDURATION,
116	],
117	[hash(ValueType.XSDAYTIMEDURATION, ValueType.XSDAYTIMEDURATION, 'sub')]: [
118	dayTimeDurationSub,
119	ValueType.XSDAYTIMEDURATION,
120	],
121	[hash(ValueType.XSDATETIME, ValueType.XSYEARMONTHDURATION, 'sub')]: [
122	subDurationFromDateTime,
123	ValueType.XSDATETIME,
124	],
125	[hash(ValueType.XSDATETIME, ValueType.XSDAYTIMEDURATION, 'sub')]: [
126	subDurationFromDateTime,
127	ValueType.XSDATETIME,
128	],
129	[hash(ValueType.XSDATE, ValueType.XSYEARMONTHDURATION, 'sub')]: [
130	subDurationFromDateTime,
131	ValueType.XSDATE,
132	],
133	[hash(ValueType.XSDATE, ValueType.XSDAYTIMEDURATION, 'sub')]: [
134	subDurationFromDateTime,
135	ValueType.XSDATE,
136	],
137	[hash(ValueType.XSTIME, ValueType.XSDAYTIMEDURATION, 'sub')]: [
138	subDurationFromDateTime,
139	ValueType.XSTIME,
140	],
141	[hash(ValueType.XSDATETIME, ValueType.XSYEARMONTHDURATION, 'sub')]: [
142	subDurationFromDateTime,
143	ValueType.XSDATETIME,
144	],
145	[hash(ValueType.XSTIME, ValueType.XSDAYTIMEDURATION, 'sub')]: [
146	subDurationFromDateTime,
147	ValueType.XSDATETIME,
148	],
149	[hash(ValueType.XSINTEGER, ValueType.XSINTEGER, 'mod')]: [
150	(l: number, r: number) => l % r,	3✔
151	ValueType.XSINTEGER,
152	],
153	[hash(ValueType.XSDOUBLE, ValueType.XSDOUBLE, 'mod')]: [
154	(l: number, r: number) => l % r,	×
155	ValueType.XSDOUBLE,
156	],
157	[hash(ValueType.XSFLOAT, ValueType.XSFLOAT, 'mod')]: [
158	(l: number, r: number) => l % r,	×
159	ValueType.XSFLOAT,
160	],
161	[hash(ValueType.XSDECIMAL, ValueType.XSDECIMAL, 'mod')]: [
162	(l: number, r: number) => l % r,	×
163	ValueType.XSDECIMAL,
164	],
165	[hash(ValueType.XSNUMERIC, ValueType.XSNUMERIC, 'multiply')]: [
166	(l: number, r: number) => l * r,	×
167	ValueType.XSINTEGER,
168	],
169	[hash(ValueType.XSFLOAT, ValueType.XSFLOAT, 'multiply')]: [
170	(l: number, r: number) => l * r,	×
171	ValueType.XSFLOAT,
172	],
173	[hash(ValueType.XSDOUBLE, ValueType.XSDOUBLE, 'multiply')]: [
174	(l: number, r: number) => l * r,	×
175	ValueType.XSDOUBLE,
176	],
177	[hash(ValueType.XSDECIMAL, ValueType.XSDECIMAL, 'multiply')]: [
178	(l: number, r: number) => l * r,	×
179	ValueType.XSDECIMAL,
180	],
181	[hash(ValueType.XSINTEGER, ValueType.XSINTEGER, 'multiply')]: [
182	(l: number, r: number) => l * r,	4✔
183	ValueType.XSDECIMAL,
184	],
185	[hash(ValueType.XSYEARMONTHDURATION, ValueType.XSNUMERIC, 'multiply')]: [
186	yearMonthDurationMultiply,
187	ValueType.XSYEARMONTHDURATION,
188	],
189	[hash(ValueType.XSNUMERIC, ValueType.XSYEARMONTHDURATION, 'multiply')]: [
190	yearMonthDurationMultiply,
191	ValueType.XSYEARMONTHDURATION,
192	],
193	[hash(ValueType.XSDAYTIMEDURATION, ValueType.XSNUMERIC, 'multiply')]: [
194	dayTimeDurationMultiply,
195	ValueType.XSDAYTIMEDURATION,
196	],
197	[hash(ValueType.XSNUMERIC, ValueType.XSDAYTIMEDURATION, 'multiply')]: [
198	dayTimeDurationMultiply,
199	ValueType.XSDAYTIMEDURATION,
200	],
201	[hash(ValueType.XSINTEGER, ValueType.XSINTEGER, 'div')]: [
202	(l: number, r: number) => l / r,	3✔
203	ValueType.XSDECIMAL,
204	],
205	[hash(ValueType.XSINTEGER, ValueType.XSDOUBLE, 'div')]: [
NEW 206	(l: number, r: number) => l / r,	×
207	ValueType.XSDOUBLE,
208	],
209	[hash(ValueType.XSFLOAT, ValueType.XSFLOAT, 'div')]: [
210	(l: number, r: number) => l / r,	×
211	ValueType.XSFLOAT,
212	],
213	[hash(ValueType.XSDOUBLE, ValueType.XSDOUBLE, 'div')]: [
214	(l: number, r: number) => l / r,	×
215	ValueType.XSDOUBLE,
216	],
217	[hash(ValueType.XSDECIMAL, ValueType.XSDECIMAL, 'div')]: [
218	(l: number, r: number) => l / r,	×
219	ValueType.XSDECIMAL,
220	],
221	[hash(ValueType.XSNUMERIC, ValueType.XSNUMERIC, 'div')]: [
222	(l: number, r: number) => l / r,	×
223	ValueType.XSDOUBLE,
224	],
225	[hash(ValueType.XSYEARMONTHDURATION, ValueType.XSYEARMONTHDURATION, 'div')]: [
226	yearMonthDurationDivideByYearMonthDuration,
227	ValueType.XSDECIMAL,
228	],
229	[hash(ValueType.XSYEARMONTHDURATION, ValueType.XSINTEGER, 'div')]: [
230	yearMonthDurationDivide,
231	ValueType.XSYEARMONTHDURATION,
232	],
233	[hash(ValueType.XSYEARMONTHDURATION, ValueType.XSFLOAT, 'div')]: [
234	yearMonthDurationDivide,
235	ValueType.XSYEARMONTHDURATION,
236	],
237	[hash(ValueType.XSYEARMONTHDURATION, ValueType.XSDOUBLE, 'div')]: [
238	yearMonthDurationDivide,
239	ValueType.XSYEARMONTHDURATION,
240	],
241	[hash(ValueType.XSYEARMONTHDURATION, ValueType.XSDECIMAL, 'div')]: [
242	yearMonthDurationDivide,
243	ValueType.XSYEARMONTHDURATION,
244	],
245	[hash(ValueType.XSYEARMONTHDURATION, ValueType.XSNUMERIC, 'div')]: [
246	yearMonthDurationDivide,
247	ValueType.XSYEARMONTHDURATION,
248	],
249	[hash(ValueType.XSDAYTIMEDURATION, ValueType.XSDAYTIMEDURATION, 'div')]: [
250	dayTimeDurationDivideByDayTimeDuration,
251	ValueType.XSDECIMAL,
252	],
253	[hash(ValueType.XSDAYTIMEDURATION, ValueType.XSINTEGER, 'div')]: [
254	yearMonthDurationDivide,
255	ValueType.XSDAYTIMEDURATION,
256	],
257	[hash(ValueType.XSDAYTIMEDURATION, ValueType.XSFLOAT, 'div')]: [
258	yearMonthDurationDivide,
259	ValueType.XSDAYTIMEDURATION,
260	],
261	[hash(ValueType.XSDAYTIMEDURATION, ValueType.XSDOUBLE, 'div')]: [
262	yearMonthDurationDivide,
263	ValueType.XSDAYTIMEDURATION,
264	],
265	[hash(ValueType.XSDAYTIMEDURATION, ValueType.XSDECIMAL, 'div')]: [
266	yearMonthDurationDivide,
267	ValueType.XSDAYTIMEDURATION,
268	],
269	[hash(ValueType.XSDAYTIMEDURATION, ValueType.XSNUMERIC, 'div')]: [
270	yearMonthDurationDivide,
271	ValueType.XSDAYTIMEDURATION,
272	],
273
274	// Integer Division, numerator and denominator of the same type
275	[hash(ValueType.XSINTEGER, ValueType.XSINTEGER, 'idiv')]: [
276	(l: number, r: number) => Math.trunc(l / r),	4✔
277	ValueType.XSINTEGER,
278	],
279	[hash(ValueType.XSFLOAT, ValueType.XSFLOAT, 'idiv')]: [
UNCOV 280	(l: number, r: number) => Math.trunc(l / r),	×
281	ValueType.XSINTEGER,
282	],
283	[hash(ValueType.XSDOUBLE, ValueType.XSDOUBLE, 'idiv')]: [
284	(l: number, r: number) => Math.trunc(l / r),	×
285	ValueType.XSINTEGER,
286	],
287	[hash(ValueType.XSDECIMAL, ValueType.XSDECIMAL, 'idiv')]: [
288	(l: number, r: number) => Math.trunc(l / r),	×
289	ValueType.XSINTEGER,
290	],
291	[hash(ValueType.XSNUMERIC, ValueType.XSNUMERIC, 'idiv')]: [
292	(l: number, r: number) => Math.trunc(l / r),	×
293	ValueType.XSINTEGER,
294	],
295
296	// Integer Division, float over integer
297	[hash(ValueType.XSFLOAT, ValueType.XSINTEGER, 'idiv')]: [
UNCOV 298	(l: number, r: number) => Math.trunc(l / r),	×
299	ValueType.XSINTEGER,
300	],
301	// Integer Division, integer over float
302	[hash(ValueType.XSINTEGER, ValueType.XSFLOAT, 'idiv')]: [
UNCOV 303	(l: number, r: number) => Math.trunc(l / r),	×
304	ValueType.XSINTEGER,
305	],
306
307	// Integer Division, double over integer
308	[hash(ValueType.XSDOUBLE, ValueType.XSINTEGER, 'idiv')]: [
UNCOV 309	(l: number, r: number) => Math.trunc(l / r),	×
310	ValueType.XSINTEGER,
311	],
312	// Integer Division, integer over double
313	[hash(ValueType.XSINTEGER, ValueType.XSDOUBLE, 'idiv')]: [
UNCOV 314	(l: number, r: number) => Math.trunc(l / r),	×
315	ValueType.XSINTEGER,
316	],
317
318	// Integer Division, decimal over integer
319	[hash(ValueType.XSDECIMAL, ValueType.XSINTEGER, 'idiv')]: [
UNCOV 320	(l: number, r: number) => Math.trunc(l / r),	×
321	ValueType.XSINTEGER,
322	],
323	// Integer Division, integer over decimal
324	[hash(ValueType.XSINTEGER, ValueType.XSDECIMAL, 'idiv')]: [
UNCOV 325	(l: number, r: number) => Math.trunc(l / r),	×
326	ValueType.XSINTEGER,
327	],
328
329	// Integer Division, numeric over integer
330	[hash(ValueType.XSNUMERIC, ValueType.XSINTEGER, 'idiv')]: [
UNCOV 331	(l: number, r: number) => Math.trunc(l / r),	×
332	ValueType.XSINTEGER,
333	],
334	// Integer Division, integer over numeric
335	[hash(ValueType.XSINTEGER, ValueType.XSNUMERIC, 'idiv')]: [
UNCOV 336	(l: number, r: number) => Math.trunc(l / r),	×
337	ValueType.XSINTEGER,
338	],
339	};
340
341	export function annotateBinOp(	5✔
342	ast: IAST,
343	left: SequenceType \| undefined,
344	right: SequenceType \| undefined,
345	operator: string
346	): SequenceType \| undefined {
347	if (!left \|\| !right) {	69✔
348	return undefined;	49✔
349	}
350
351	if (left.mult !== right.mult) {	20!
UNCOV 352	throw new Error("Multiplicities in binary addition operator don't match");	×
353	}
354
355	const funcData: [BinaryEvaluationFunction, ValueType] \| undefined =
356	BINOP_EVAL_FUNCTIONS[hash(left.type, right.type, operator)];	20✔
357
358	if (funcData) {	20✔
359	const type = { type: funcData[1], mult: left.mult };	19✔
360	insertAttribute(ast, 'type', type);	19✔
361	insertAttribute(ast, 'evalFunc', funcData[0]);	19✔
362	return type;	19✔
363	}
364
365	throw new Error(	1✔
366	`XPTY0004: ${operator} not available for types ${sequenceTypeToString(
367	left
368	)} and ${sequenceTypeToString(right)}`
369	);
370	}

FontoXML / fontoxpath / 1015529893

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