#13231

Committed 24 Oct 2024 01:02PM UTC coverage: 86.866% (-1.3%) from 88.214%

Build Type

push

Committed by

Commit Message

Merge cc3491b40 into 7cfaaa047

Run Details

11613 of 14131 branches covered (82.18%)

Branch coverage included in aggregate %.

7028 of 7618 new or added lines in 100 files covered. (92.26%)

87 existing lines in 18 files now uncovered.

12732 of 13895 relevant lines covered (91.63%)

30018.29 hits per line

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

85.05

/src/types/helpers.ts

import type { TypeCompatibilityData } from '../interfaces';
import { isAnyReferenceType, isDynamicType, isEnumMemberType, isEnumType, isInheritableType, isInterfaceType, isUnionType } from '../astUtils/reflection';
import type { BscType } from './BscType';
import type { UnionType } from './UnionType';

export function findTypeIntersection(typesArr1: BscType[], typesArr2: BscType[]) {
    if (!typesArr1 || !typesArr2) {
        return undefined;
    }
    return typesArr1?.filter((currentType) => {
        if (!currentType) {
            return false;
        }
        const indexOfCurrentTypeInArr2 = typesArr2.findIndex((checkType) => {
            return currentType.isEqual(checkType);
        });
        return indexOfCurrentTypeInArr2 >= 0;
    });
}

export function findTypeUnion(...typesArr: BscType[][]) {
    return getUniqueTypesFromArray([].concat(...typesArr));
}

export function getUniqueTypesFromArray(types: BscType[]) {
    if (!types) {
        return undefined;
    }
    return types?.filter((currentType, currentIndex) => {
        if (!currentType) {
            return false;
        }
        const latestIndex = types.findIndex((checkType) => {
            return currentType.isEqual(checkType);
        });
        // the index that was found is the index we're checking --- there are no equal types after this
        return latestIndex === currentIndex;
    });
}

/**
 * Reduces a list of types based on equality or inheritance
 * If all types are the same - just that type is returned
 * If one of the types is Dynamic, then Dynamic.instance is returned
 * If any types inherit another type, the more general type is returned
 * @param types array of types
 * @returns an array of the most general types
 */
export function reduceTypesToMostGeneric(types: BscType[]): BscType[] {
    if (!types || types?.length === 0) {
        return undefined;
    }

    if (types.length === 1) {
        // only one type
        return [types[0]];
    }

    // Get a list of unique types, based on the `isEqual()` method
    const uniqueTypes = getUniqueTypesFromArray(types).map(t => {
        // map to object with `shouldIgnore` flag
        return { type: t, shouldIgnore: false };
    });

    if (uniqueTypes.length === 1) {
        // only one type after filtering
        return [uniqueTypes[0].type];
    }
    const existingDynamicType = uniqueTypes.find(t => !isAnyReferenceType(t.type) && isDynamicType(t.type));
    if (existingDynamicType) {
        // If it includes dynamic, then the result is dynamic
        return [existingDynamicType.type];
    }
    const generalizedTypes = [];
    //check assignability:
    for (let i = 0; i < uniqueTypes.length; i++) {
        const currentType = uniqueTypes[i].type;
        if (i === uniqueTypes.length - 1) {
            if (!uniqueTypes[i].shouldIgnore) {
                //this type was not convertible to anything else... it is as general as possible
                generalizedTypes.push(currentType);
            }
            break;
        }
        for (let j = i + 1; j < uniqueTypes.length; j++) {
            if (uniqueTypes[j].shouldIgnore) {
                continue;
            }
            const checkType = uniqueTypes[j].type;

            if (currentType.isEqual(uniqueTypes[j].type)) {
                uniqueTypes[j].shouldIgnore = true;
            } else if (isInheritableType(currentType) && isInheritableType(checkType)) {
                if (currentType.isTypeDescendent(checkType)) {
                    //the type we're checking is less general than the current type... it can be ignored
                    uniqueTypes[j].shouldIgnore = true;
                }
                if (checkType.isTypeDescendent(currentType)) {
                    // the currentType is a descendent to some other type - it won't be in the final set
                    break;
                }
            }
            if (j === uniqueTypes.length - 1) {
                //this type was not convertible to anything else... it is as general as possible
                generalizedTypes.push(currentType);
            }
        }
    }
    return generalizedTypes;
}


/**
 * Gets a Unique type from a list of types
 * @param types array of types
 * @returns either the singular most general type, if there is one, otherwise a UnionType of the most general types
 */
export function getUniqueType(types: BscType[], unionTypeFactory: (types: BscType[]) => BscType): BscType {
    if (!types || types.length === 0) {
        return undefined;
    }
    const dynType = types.find((x) => !isAnyReferenceType(x) && isDynamicType(x));
    if (dynType) {
        return dynType;
    }
    types = types?.map(type => {
        if (!isAnyReferenceType(type) && isUnionType(type)) {
            return type.types;
        }
        return type;
    }).flat();
    const generalizedTypes = reduceTypesToMostGeneric(types);
    if (!generalizedTypes || generalizedTypes.length === 0) {
        return undefined;
    }
    if (generalizedTypes?.length === 1) {
        // only one type
        return generalizedTypes[0];
    }
    return unionTypeFactory(generalizedTypes);
}


export function isUnionTypeCompatible(thisType: BscType, maybeUnionType: BscType, data?: TypeCompatibilityData): boolean {
    if (isUnionType(maybeUnionType)) {
        for (const innerType of maybeUnionType.types) {
            if (!thisType.isTypeCompatible(innerType, data)) {
                return false;
            }
        }
        return true;
    }
    return false;
}


export function isEnumTypeCompatible(thisType: BscType, maybeEnumType: BscType, data?: TypeCompatibilityData): boolean {
    if (isEnumMemberType(maybeEnumType) || isEnumType(maybeEnumType)) {
        return thisType.isTypeCompatible(maybeEnumType.underlyingType, data);
    }
    return false;
}

export function isNativeInterfaceCompatible(thisType: BscType, otherType: BscType, allowedType: string, data?: TypeCompatibilityData): boolean {
    if (isInterfaceType(otherType)) {
        // TODO: it is not great to do type checking based on interface name
        const lowerOtherName = otherType.name.toLowerCase();
        return allowedType === lowerOtherName;
    }
    return false;
}

export function isNativeInterfaceCompatibleNumber(thisType: BscType, otherType: BscType, data?: TypeCompatibilityData): boolean {
    if (isInterfaceType(otherType)) {
        // TODO: it is not great to do type checking based on interface name
        const lowerOtherName = otherType.name.toLowerCase();
        return lowerOtherName === 'roint' ||
            lowerOtherName === 'rofloat' ||
            lowerOtherName === 'rodouble' ||
            lowerOtherName === 'rolonginteger';
    }
    return false;
}

export function getAllTypesFromUnionType(union: UnionType): BscType[] {
    const results = [];

    for (const type of union.types) {
        if (isUnionType(type)) {
            results.push(...getAllTypesFromUnionType(type));
        } else {
            results.push(type);
        }
    }
    return results;
}

1	import type { TypeCompatibilityData } from '../interfaces';
2	import { isAnyReferenceType, isDynamicType, isEnumMemberType, isEnumType, isInheritableType, isInterfaceType, isUnionType } from '../astUtils/reflection';	1✔
3	import type { BscType } from './BscType';
4	import type { UnionType } from './UnionType';
5
6	export function findTypeIntersection(typesArr1: BscType[], typesArr2: BscType[]) {	1✔
7	if (!typesArr1 \|\| !typesArr2) {	4!
NEW 8	return undefined;	×
9	}
10	return typesArr1?.filter((currentType) => {	4!
11	if (!currentType) {	7!
NEW 12	return false;	×
13	}
14	const indexOfCurrentTypeInArr2 = typesArr2.findIndex((checkType) => {	7✔
15	return currentType.isEqual(checkType);	14✔
16	});
17	return indexOfCurrentTypeInArr2 >= 0;	7✔
18	});
19	}
20
21	export function findTypeUnion(...typesArr: BscType[][]) {	1✔
22	return getUniqueTypesFromArray([].concat(...typesArr));	25✔
23	}
24
25	export function getUniqueTypesFromArray(types: BscType[]) {	1✔
26	if (!types) {	145!
NEW 27	return undefined;	×
28	}
29	return types?.filter((currentType, currentIndex) => {	145!
30	if (!currentType) {	345!
NEW 31	return false;	×
32	}
33	const latestIndex = types.findIndex((checkType) => {	345✔
34	return currentType.isEqual(checkType);	444✔
35	});
36	// the index that was found is the index we're checking --- there are no equal types after this
37	return latestIndex === currentIndex;	345✔
38	});
39	}
40
41	/**
42	* Reduces a list of types based on equality or inheritance
43	* If all types are the same - just that type is returned
44	* If one of the types is Dynamic, then Dynamic.instance is returned
45	* If any types inherit another type, the more general type is returned
46	* @param types array of types
47	* @returns an array of the most general types
48	*/
49	export function reduceTypesToMostGeneric(types: BscType[]): BscType[] {	1✔
50	if (!types \|\| types?.length === 0) {	212,452!
NEW 51	return undefined;	×
52	}
53
54	if (types.length === 1) {	212,452✔
55	// only one type
56	return [types[0]];	212,336✔
57	}
58
59	// Get a list of unique types, based on the `isEqual()` method
60	const uniqueTypes = getUniqueTypesFromArray(types).map(t => {	116✔
61	// map to object with `shouldIgnore` flag
62	return { type: t, shouldIgnore: false };	176✔
63	});
64
65	if (uniqueTypes.length === 1) {	116✔
66	// only one type after filtering
67	return [uniqueTypes[0].type];	64✔
68	}
69	const existingDynamicType = uniqueTypes.find(t => !isAnyReferenceType(t.type) && isDynamicType(t.type));	112✔
70	if (existingDynamicType) {	52✔
71	// If it includes dynamic, then the result is dynamic
72	return [existingDynamicType.type];	1✔
73	}
74	const generalizedTypes = [];	51✔
75	//check assignability:
76	for (let i = 0; i < uniqueTypes.length; i++) {	51✔
77	const currentType = uniqueTypes[i].type;	110✔
78	if (i === uniqueTypes.length - 1) {	110✔
79	if (!uniqueTypes[i].shouldIgnore) {	51✔
80	//this type was not convertible to anything else... it is as general as possible
81	generalizedTypes.push(currentType);	50✔
82	}
83	break;	51✔
84	}
85	for (let j = i + 1; j < uniqueTypes.length; j++) {	59✔
86	if (uniqueTypes[j].shouldIgnore) {	67!
NEW 87	continue;	×
88	}
89	const checkType = uniqueTypes[j].type;	67✔
90
91	if (currentType.isEqual(uniqueTypes[j].type)) {	67!
NEW 92	uniqueTypes[j].shouldIgnore = true;	×
93	} else if (isInheritableType(currentType) && isInheritableType(checkType)) {	67✔
94	if (currentType.isTypeDescendent(checkType)) {	8✔
95	//the type we're checking is less general than the current type... it can be ignored
96	uniqueTypes[j].shouldIgnore = true;	1✔
97	}
98	if (checkType.isTypeDescendent(currentType)) {	8✔
99	// the currentType is a descendent to some other type - it won't be in the final set
100	break;	2✔
101	}
102	}
103	if (j === uniqueTypes.length - 1) {	65✔
104	//this type was not convertible to anything else... it is as general as possible
105	generalizedTypes.push(currentType);	57✔
106	}
107	}
108	}
109	return generalizedTypes;	51✔
110	}
111
112
113	/**
114	* Gets a Unique type from a list of types
115	* @param types array of types
116	* @returns either the singular most general type, if there is one, otherwise a UnionType of the most general types
117	*/
118	export function getUniqueType(types: BscType[], unionTypeFactory: (types: BscType[]) => BscType): BscType {	1✔
119	if (!types \|\| types.length === 0) {	433,762✔
120	return undefined;	221,104✔
121	}
122	const dynType = types.find((x) => !isAnyReferenceType(x) && isDynamicType(x));	212,796✔
123	if (dynType) {	212,658✔
124	return dynType;	206✔
125	}
126	types = types?.map(type => {	212,452!
127	if (!isAnyReferenceType(type) && isUnionType(type)) {	212,582✔
128	return type.types;	26✔
129	}
130	return type;	212,556✔
131	}).flat();
132	const generalizedTypes = reduceTypesToMostGeneric(types);	212,452✔
133	if (!generalizedTypes \|\| generalizedTypes.length === 0) {	212,452!
NEW 134	return undefined;	×
135	}
136	if (generalizedTypes?.length === 1) {	212,452!
137	// only one type
138	return generalizedTypes[0];	212,404✔
139	}
140	return unionTypeFactory(generalizedTypes);	48✔
141	}
142
143
144	export function isUnionTypeCompatible(thisType: BscType, maybeUnionType: BscType, data?: TypeCompatibilityData): boolean {	1✔
145	if (isUnionType(maybeUnionType)) {	705✔
146	for (const innerType of maybeUnionType.types) {	4✔
147	if (!thisType.isTypeCompatible(innerType, data)) {	7✔
148	return false;	2✔
149	}
150	}
151	return true;	2✔
152	}
153	return false;	701✔
154	}
155
156
157	export function isEnumTypeCompatible(thisType: BscType, maybeEnumType: BscType, data?: TypeCompatibilityData): boolean {	1✔
158	if (isEnumMemberType(maybeEnumType) \|\| isEnumType(maybeEnumType)) {	156✔
159	return thisType.isTypeCompatible(maybeEnumType.underlyingType, data);	15✔
160	}
161	return false;	141✔
162	}
163
164	export function isNativeInterfaceCompatible(thisType: BscType, otherType: BscType, allowedType: string, data?: TypeCompatibilityData): boolean {	1✔
165	if (isInterfaceType(otherType)) {	46✔
166	// TODO: it is not great to do type checking based on interface name
167	const lowerOtherName = otherType.name.toLowerCase();	1✔
168	return allowedType === lowerOtherName;	1✔
169	}
170	return false;	45✔
171	}
172
173	export function isNativeInterfaceCompatibleNumber(thisType: BscType, otherType: BscType, data?: TypeCompatibilityData): boolean {	1✔
174	if (isInterfaceType(otherType)) {	54✔
175	// TODO: it is not great to do type checking based on interface name
176	const lowerOtherName = otherType.name.toLowerCase();	4✔
177	return lowerOtherName === 'roint' \|\|	4✔
178	lowerOtherName === 'rofloat' \|\|
179	lowerOtherName === 'rodouble' \|\|
180	lowerOtherName === 'rolonginteger';
181	}
182	return false;	50✔
183	}
184
185	export function getAllTypesFromUnionType(union: UnionType): BscType[] {	1✔
NEW 186	const results = [];	×
187
NEW 188	for (const type of union.types) {	×
NEW 189	if (isUnionType(type)) {	×
NEW 190	results.push(...getAllTypesFromUnionType(type));	×
191	} else {
NEW 192	results.push(type);	×
193	}
194	}
NEW 195	return results;	×
196	}

rokucommunity / brighterscript / #13231

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