#15049

Committed 01 Jan 2026 11:17PM UTC coverage: 87.033% (-0.02%) from 87.048%

Build Type

push

Committed by

Commit Message

Merge 02ba2bb57 into 2ea4d2108

Run Details

14496 of 17595 branches covered (82.39%)

Branch coverage included in aggregate %.

192 of 261 new or added lines in 12 files covered. (73.56%)

142 existing lines in 9 files now uncovered.

15245 of 16577 relevant lines covered (91.96%)

24110.78 hits per line

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

63.43

/src/types/IntersectionType.ts

import type { GetTypeOptions, TypeCompatibilityData } from '../interfaces';
import { isAssociativeArrayType, isDynamicType, isIntersectionType, isObjectType, isTypedFunctionType } from '../astUtils/reflection';
import { BscType } from './BscType';
import { ReferenceType } from './ReferenceType';
import { addAssociatedTypesTableAsSiblingToMemberTable, getAllTypesFromComplexType, isEnumTypeCompatible, joinTypesString, reduceTypesForIntersectionType } from './helpers';
import { BscTypeKind } from './BscTypeKind';
import type { TypeCacheEntry } from '../SymbolTable';
import { SymbolTable } from '../SymbolTable';
import { SymbolTypeFlag } from '../SymbolTypeFlag';
import { BuiltInInterfaceAdder } from './BuiltInInterfaceAdder';
import { util } from '../util';
import { DynamicType } from './DynamicType';

export function intersectionTypeFactory(types: BscType[]) {
    return new IntersectionType(types);
}

export class IntersectionType extends BscType {
    constructor(
        public types: BscType[]
    ) {
        super(joinTypesString(types, 'and', BscTypeKind.IntersectionType));
        this.callFuncAssociatedTypesTable = new SymbolTable(`Intersection: CallFuncAssociatedTypes`);
    }

    public readonly kind = BscTypeKind.IntersectionType;

    public readonly callFuncAssociatedTypesTable: SymbolTable;

    public addType(type: BscType) {
        this.types.push(type);
    }

    isResolvable(): boolean {
        for (const type of this.types) {
            // resolvable if any inner type is resolvable
            if (type.isResolvable()) {
                return true;
            }
        }
        return false;
    }

    private getMemberTypeFromInnerTypes(name: string, options: GetTypeOptions): BscType {
        const typeFromMembers = this.types.map((innerType) => {
            return innerType?.getMemberType(name, { ...options, ignoreAADefaultDynamicMembers: true });
        });
        const filteredTypes = reduceTypesForIntersectionType(typeFromMembers.filter(t => t !== undefined));

        if (filteredTypes.length === 0) {
            if (this.types.some(isAssociativeArrayType)) {
                return DynamicType.instance;
            }
            return undefined;
        } else if (filteredTypes.length === 1) {
            return filteredTypes[0];
        }
        return new IntersectionType(filteredTypes);
    }

    private getCallFuncFromInnerTypes(name: string, options: GetTypeOptions): BscType {
        const typeFromMembers = reduceTypesForIntersectionType(this.types.map((innerType) => innerType?.getCallFuncType(name, options)).filter(t => t !== undefined));

        if (typeFromMembers.length === 0) {
            return undefined;
        } else if (typeFromMembers.length === 1) {
            return typeFromMembers[0];
        }
        return new IntersectionType(typeFromMembers);
    }

    getMemberType(name: string, options: GetTypeOptions) {
        const innerTypesMemberType = this.getMemberTypeFromInnerTypes(name, options);
        if (!innerTypesMemberType) {
            // We don't have any members of any inner types that match
            // so instead, create reference type that will
            return new ReferenceType(name, name, options.flags, () => {
                return {
                    name: `IntersectionType MemberTable: '${this.__identifier}'`,
                    getSymbolType: (innerName: string, innerOptions: GetTypeOptions) => {
                        const referenceTypeInnerMemberTypes = this.getMemberTypeFromInnerTypes(name, options);
                        if (!referenceTypeInnerMemberTypes) {
                            return undefined;
                        }
                        return referenceTypeInnerMemberTypes;
                    },
                    setCachedType: (innerName: string, innerCacheEntry: TypeCacheEntry, innerOptions: GetTypeOptions) => {
                        // TODO: is this even cachable? This is a NO-OP for now, and it shouldn't hurt anything
                    },
                    addSibling: (symbolTable: SymbolTable) => {
                        // TODO: I don't know what this means in this context?
                    }
                };
            });
        }
        return innerTypesMemberType;
    }

    getCallFuncType(name: string, options: GetTypeOptions) {
        const resultCallFuncType = this.getCallFuncFromInnerTypes(name, options);
        if (!resultCallFuncType) {
            // We don't have any members of any inner types that match
            // so instead, create reference type that will
            return new ReferenceType(name, name, options.flags, () => {
                return {
                    name: `IntersectionType CallFunc MemberTable: '${this.__identifier}'`,
                    getSymbolType: (innerName: string, innerOptions: GetTypeOptions) => {
                        const referenceTypeInnerMemberType = this.getCallFuncFromInnerTypes(name, options);
                        if (!referenceTypeInnerMemberType) {
                            return undefined;
                        }
                        return referenceTypeInnerMemberType;
                    },
                    setCachedType: (innerName: string, innerCacheEntry: TypeCacheEntry, innerOptions: GetTypeOptions) => {
                        // TODO: is this even cachable? This is a NO-OP for now, and it shouldn't hurt anything
                    },
                    addSibling: (symbolTable: SymbolTable) => {
                        // TODO: I don't know what this means in this context?
                    }
                };
            });
        }

        if (isTypedFunctionType(resultCallFuncType)) {
            const typesToCheck = [...resultCallFuncType.params.map(p => p.type), resultCallFuncType.returnType];

            for (const type of typesToCheck) {
                addAssociatedTypesTableAsSiblingToMemberTable(type, this.callFuncAssociatedTypesTable, SymbolTypeFlag.runtime);
            }
        }
        return resultCallFuncType;
    }

    get returnType() {
        return util.getReturnTypeOfIntersectionOfFunctions(this);
    }


    isTypeCompatible(targetType: BscType, data?: TypeCompatibilityData): boolean {
        if (isDynamicType(targetType) || isObjectType(targetType) || this === targetType) {
            return true;
        }
        if (isEnumTypeCompatible(this, targetType, data)) {
            return true;
        }
        if (isIntersectionType(targetType)) {
            // check if this all the types of this type are in the target (eg, target is a super set of this types)
            for (const memberType of this.types) {
                let foundCompatibleInnerType = false;
                for (const targetInnerType of targetType.types) {
                    if (memberType.isTypeCompatible(targetInnerType, data)) {
                        foundCompatibleInnerType = true;
                        continue;
                    }
                }
                if (!foundCompatibleInnerType) {
                    return false;
                }
            }
            return true;
        }
        for (const innerType of this.types) {
            const foundCompatibleInnerType = innerType.isTypeCompatible(targetType, data);
            if (foundCompatibleInnerType) {
                return true;
            }
        }

        return false;
    }
    toString(): string {
        return joinTypesString(this.types, 'and', BscTypeKind.IntersectionType);
    }

    /**
     * Used for transpilation
     */
    toTypeString(): string {
        const uniqueTypeStrings = new Set<string>(getAllTypesFromComplexType(this).map(t => t.toTypeString()));

        if (uniqueTypeStrings.size === 1) {
            return uniqueTypeStrings.values().next().value;
        }
        return 'dynamic';
    }

    checkAllMemberTypes(predicate: (BscType) => boolean) {
        return this.types.reduce((acc, type) => {
            return acc && predicate(type);
        }, true);
    }

    isEqual(targetType: BscType): boolean {
        if (!isIntersectionType(targetType)) {
            return false;
        }
        if (this === targetType) {
            return true;
        }
        for (const type of this.types) {
            let foundMatch = false;
            for (const targetTypeInner of targetType.types) {
                if (type.isEqual(targetTypeInner)) {
                    foundMatch = true;
                    break;
                }
            }
            if (!foundMatch) {
                return false;
            }
        }
        return true;
    }

    getMemberTable(): SymbolTable {
        const intersectionTable = new SymbolTable(this.__identifier + ' IntersectionTable');

        for (const type of this.types) {
            type.addBuiltInInterfaces();
            for (const symbol of type.getMemberTable().getAllSymbols(SymbolTypeFlag.runtime)) {
                const foundType = this.getMemberTypeFromInnerTypes(symbol.name, { flags: SymbolTypeFlag.runtime });
                /*

                const allResolvableTypes = foundType.reduce((acc, curType) => {
                    return acc && curType?.isResolvable();
                }, true);

                if (!allResolvableTypes) {
                    continue;
                }
                const uniqueType = getUniqueType(findTypeUnion(foundType), intersectionTypeFactory);*/
                intersectionTable.addSymbol(symbol.name, {}, foundType, SymbolTypeFlag.runtime);
            }
        }
        const firstType = this.types[0];
        if (!firstType) {
            return intersectionTable;
        }
        firstType.addBuiltInInterfaces();
        for (const symbol of firstType.getMemberTable().getAllSymbols(SymbolTypeFlag.runtime)) {
            const foundType = this.getMemberTypeFromInnerTypes(symbol.name, { flags: SymbolTypeFlag.runtime });
            /* const allResolvableTypes = foundType.reduce((acc, curType) => {
                 return acc && curType?.isResolvable();
             }, true);

             if (!allResolvableTypes) {
                 continue;
             }
             const uniqueType = getUniqueType(findTypeUnion(foundType), unionTypeFactory);*/
            intersectionTable.addSymbol(symbol.name, {}, foundType, SymbolTypeFlag.runtime);
        }
        return intersectionTable;
    }
}

BuiltInInterfaceAdder.intersectionTypeFactory = (types: BscType[]) => {
    return new IntersectionType(types);
};

1	import type { GetTypeOptions, TypeCompatibilityData } from '../interfaces';
2	import { isAssociativeArrayType, isDynamicType, isIntersectionType, isObjectType, isTypedFunctionType } from '../astUtils/reflection';	1✔
3	import { BscType } from './BscType';	1✔
4	import { ReferenceType } from './ReferenceType';	1✔
5	import { addAssociatedTypesTableAsSiblingToMemberTable, getAllTypesFromComplexType, isEnumTypeCompatible, joinTypesString, reduceTypesForIntersectionType } from './helpers';	1✔
6	import { BscTypeKind } from './BscTypeKind';	1✔
7	import type { TypeCacheEntry } from '../SymbolTable';
8	import { SymbolTable } from '../SymbolTable';	1✔
9	import { SymbolTypeFlag } from '../SymbolTypeFlag';	1✔
10	import { BuiltInInterfaceAdder } from './BuiltInInterfaceAdder';	1✔
11	import { util } from '../util';	1✔
12	import { DynamicType } from './DynamicType';	1✔
13
14	export function intersectionTypeFactory(types: BscType[]) {	1✔
NEW 15	return new IntersectionType(types);	×
16	}
17
18	export class IntersectionType extends BscType {	1✔
19	constructor(
20	public types: BscType[]	39✔
21	) {
22	super(joinTypesString(types, 'and', BscTypeKind.IntersectionType));	39✔
23	this.callFuncAssociatedTypesTable = new SymbolTable(`Intersection: CallFuncAssociatedTypes`);	39✔
24	}
25
26	public readonly kind = BscTypeKind.IntersectionType;	39✔
27
28	public readonly callFuncAssociatedTypesTable: SymbolTable;
29
30	public addType(type: BscType) {
NEW 31	this.types.push(type);	×
32	}
33
34	isResolvable(): boolean {
35	for (const type of this.types) {	20✔
36	// resolvable if any inner type is resolvable
37	if (type.isResolvable()) {	23✔
38	return true;	17✔
39	}
40	}
41	return false;	3✔
42	}
43
44	private getMemberTypeFromInnerTypes(name: string, options: GetTypeOptions): BscType {
45	const typeFromMembers = this.types.map((innerType) => {	137✔
46	return innerType?.getMemberType(name, { ...options, ignoreAADefaultDynamicMembers: true });	274!
47	});
48	const filteredTypes = reduceTypesForIntersectionType(typeFromMembers.filter(t => t !== undefined));	274✔
49
50	if (filteredTypes.length === 0) {	137✔
51	if (this.types.some(isAssociativeArrayType)) {	38!
NEW 52	return DynamicType.instance;	×
53	}
54	return undefined;	38✔
55	} else if (filteredTypes.length === 1) {	99✔
56	return filteredTypes[0];	96✔
57	}
58	return new IntersectionType(filteredTypes);	3✔
59	}
60
61	private getCallFuncFromInnerTypes(name: string, options: GetTypeOptions): BscType {
NEW 62	const typeFromMembers = reduceTypesForIntersectionType(this.types.map((innerType) => innerType?.getCallFuncType(name, options)).filter(t => t !== undefined));	×
63
NEW 64	if (typeFromMembers.length === 0) {	×
NEW 65	return undefined;	×
NEW 66	} else if (typeFromMembers.length === 1) {	×
NEW 67	return typeFromMembers[0];	×
68	}
NEW 69	return new IntersectionType(typeFromMembers);	×
70	}
71
72	getMemberType(name: string, options: GetTypeOptions) {
73	const innerTypesMemberType = this.getMemberTypeFromInnerTypes(name, options);	50✔
74	if (!innerTypesMemberType) {	50✔
75	// We don't have any members of any inner types that match
76	// so instead, create reference type that will
77	return new ReferenceType(name, name, options.flags, () => {	9✔
78	return {	78✔
79	name: `IntersectionType MemberTable: '${this.__identifier}'`,
80	getSymbolType: (innerName: string, innerOptions: GetTypeOptions) => {
81	const referenceTypeInnerMemberTypes = this.getMemberTypeFromInnerTypes(name, options);	78✔
82	if (!referenceTypeInnerMemberTypes) {	78✔
83	return undefined;	29✔
84	}
85	return referenceTypeInnerMemberTypes;	49✔
86	},
87	setCachedType: (innerName: string, innerCacheEntry: TypeCacheEntry, innerOptions: GetTypeOptions) => {
88	// TODO: is this even cachable? This is a NO-OP for now, and it shouldn't hurt anything
89	},
90	addSibling: (symbolTable: SymbolTable) => {
91	// TODO: I don't know what this means in this context?
92	}
93	};
94	});
95	}
96	return innerTypesMemberType;	41✔
97	}
98
99	getCallFuncType(name: string, options: GetTypeOptions) {
NEW 100	const resultCallFuncType = this.getCallFuncFromInnerTypes(name, options);	×
NEW 101	if (!resultCallFuncType) {	×
102	// We don't have any members of any inner types that match
103	// so instead, create reference type that will
NEW 104	return new ReferenceType(name, name, options.flags, () => {	×
NEW 105	return {	×
106	name: `IntersectionType CallFunc MemberTable: '${this.__identifier}'`,
107	getSymbolType: (innerName: string, innerOptions: GetTypeOptions) => {
NEW 108	const referenceTypeInnerMemberType = this.getCallFuncFromInnerTypes(name, options);	×
NEW 109	if (!referenceTypeInnerMemberType) {	×
NEW 110	return undefined;	×
111	}
NEW 112	return referenceTypeInnerMemberType;	×
113	},
114	setCachedType: (innerName: string, innerCacheEntry: TypeCacheEntry, innerOptions: GetTypeOptions) => {
115	// TODO: is this even cachable? This is a NO-OP for now, and it shouldn't hurt anything
116	},
117	addSibling: (symbolTable: SymbolTable) => {
118	// TODO: I don't know what this means in this context?
119	}
120	};
121	});
122	}
123
NEW 124	if (isTypedFunctionType(resultCallFuncType)) {	×
NEW 125	const typesToCheck = [...resultCallFuncType.params.map(p => p.type), resultCallFuncType.returnType];	×
126
NEW 127	for (const type of typesToCheck) {	×
NEW 128	addAssociatedTypesTableAsSiblingToMemberTable(type, this.callFuncAssociatedTypesTable, SymbolTypeFlag.runtime);	×
129	}
130	}
NEW 131	return resultCallFuncType;	×
132	}
133
134	get returnType() {
NEW 135	return util.getReturnTypeOfIntersectionOfFunctions(this);	×
136	}
137
138
139	isTypeCompatible(targetType: BscType, data?: TypeCompatibilityData): boolean {
140	if (isDynamicType(targetType) \|\| isObjectType(targetType) \|\| this === targetType) {	7!
NEW 141	return true;	×
142	}
143	if (isEnumTypeCompatible(this, targetType, data)) {	7!
NEW 144	return true;	×
145	}
146	if (isIntersectionType(targetType)) {	7✔
147	// check if this all the types of this type are in the target (eg, target is a super set of this types)
148	for (const memberType of this.types) {	6✔
149	let foundCompatibleInnerType = false;	11✔
150	for (const targetInnerType of targetType.types) {	11✔
151	if (memberType.isTypeCompatible(targetInnerType, data)) {	26✔
152	foundCompatibleInnerType = true;	8✔
153	continue;	8✔
154	}
155	}
156	if (!foundCompatibleInnerType) {	11✔
157	return false;	3✔
158	}
159	}
160	return true;	3✔
161	}
162	for (const innerType of this.types) {	1✔
163	const foundCompatibleInnerType = innerType.isTypeCompatible(targetType, data);	1✔
164	if (foundCompatibleInnerType) {	1!
165	return true;	1✔
166	}
167	}
168
NEW 169	return false;	×
170	}
171	toString(): string {
172	return joinTypesString(this.types, 'and', BscTypeKind.IntersectionType);	1✔
173	}
174
175	/**
176	* Used for transpilation
177	*/
178	toTypeString(): string {
NEW 179	const uniqueTypeStrings = new Set<string>(getAllTypesFromComplexType(this).map(t => t.toTypeString()));	×
180
NEW 181	if (uniqueTypeStrings.size === 1) {	×
NEW 182	return uniqueTypeStrings.values().next().value;	×
183	}
NEW 184	return 'dynamic';	×
185	}
186
187	checkAllMemberTypes(predicate: (BscType) => boolean) {
NEW 188	return this.types.reduce((acc, type) => {	×
NEW 189	return acc && predicate(type);	×
190	}, true);
191	}
192
193	isEqual(targetType: BscType): boolean {
194	if (!isIntersectionType(targetType)) {	1!
NEW 195	return false;	×
196	}
197	if (this === targetType) {	1!
NEW 198	return true;	×
199	}
200	for (const type of this.types) {	1✔
201	let foundMatch = false;	3✔
202	for (const targetTypeInner of targetType.types) {	3✔
203	if (type.isEqual(targetTypeInner)) {	6✔
204	foundMatch = true;	3✔
205	break;	3✔
206	}
207	}
208	if (!foundMatch) {	3!
NEW 209	return false;	×
210	}
211	}
212	return true;	1✔
213	}
214
215	getMemberTable(): SymbolTable {
216	const intersectionTable = new SymbolTable(this.__identifier + ' IntersectionTable');	3✔
217
218	for (const type of this.types) {	3✔
219	type.addBuiltInInterfaces();	6✔
220	for (const symbol of type.getMemberTable().getAllSymbols(SymbolTypeFlag.runtime)) {	6✔
221	const foundType = this.getMemberTypeFromInnerTypes(symbol.name, { flags: SymbolTypeFlag.runtime });	6✔
222	/*
223
224	const allResolvableTypes = foundType.reduce((acc, curType) => {
225	return acc && curType?.isResolvable();
226	}, true);
227
228	if (!allResolvableTypes) {
229	continue;
230	}
231	const uniqueType = getUniqueType(findTypeUnion(foundType), intersectionTypeFactory);*/
232	intersectionTable.addSymbol(symbol.name, {}, foundType, SymbolTypeFlag.runtime);	6✔
233	}
234	}
235	const firstType = this.types[0];	3✔
236	if (!firstType) {	3!
NEW 237	return intersectionTable;	×
238	}
239	firstType.addBuiltInInterfaces();	3✔
240	for (const symbol of firstType.getMemberTable().getAllSymbols(SymbolTypeFlag.runtime)) {	3✔
241	const foundType = this.getMemberTypeFromInnerTypes(symbol.name, { flags: SymbolTypeFlag.runtime });	3✔
242	/* const allResolvableTypes = foundType.reduce((acc, curType) => {
243	return acc && curType?.isResolvable();
244	}, true);
245
246	if (!allResolvableTypes) {
247	continue;
248	}
249	const uniqueType = getUniqueType(findTypeUnion(foundType), unionTypeFactory);*/
250	intersectionTable.addSymbol(symbol.name, {}, foundType, SymbolTypeFlag.runtime);	3✔
251	}
252	return intersectionTable;	3✔
253	}
254	}
255
256	BuiltInInterfaceAdder.intersectionTypeFactory = (types: BscType[]) => {	1✔
NEW 257	return new IntersectionType(types);	×
258	};

rokucommunity / brighterscript / #15049

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