#15078

Committed 13 Jan 2026 02:24PM UTC coverage: 87.152% (+0.006%) from 87.146%

Build Type

push

Committed by

Commit Message

Merge 492e7ad7c into 2ea4d2108

Run Details

14580 of 17682 branches covered (82.46%)

Branch coverage included in aggregate %.

288 of 337 new or added lines in 16 files covered. (85.46%)

206 existing lines in 10 files now uncovered.

15327 of 16634 relevant lines covered (92.14%)

24501.48 hits per line

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

77.48

/src/types/BuiltInInterfaceAdder.ts

import type { BRSInterfaceData, BRSInterfaceMethodData, SGNodeData } from '../roku-types';
import { components, events, interfaces, nodes } from '../roku-types';
import { Cache } from '../Cache';
import type { TypedFunctionType } from './TypedFunctionType';
import type { SymbolTable } from '../SymbolTable';
import { SymbolTypeFlag } from '../SymbolTypeFlag';
import type { BscType } from './BscType';
import { isArrayType, isAssociativeArrayType, isBooleanType, isCallableType, isComponentType, isDoubleType, isEnumMemberType, isFloatType, isIntegerType, isInterfaceType, isInvalidType, isLongIntegerType, isStringType } from '../astUtils/reflection';
import type { ComponentType } from './ComponentType';
import { util } from '../util';
import type { UnionType } from './UnionType';
import type { ExtraSymbolData } from '../interfaces';
import type { IntersectionType } from './IntersectionType';


export interface BuiltInInterfaceOverride {
    type?: BscType;
    parameterTypes?: BscType[];
    returnType?: BscType;
}

const builtInSymbolData: ExtraSymbolData = {
    completionPriority: 1,
    isBuiltIn: true
};

// eslint-disable-next-line @typescript-eslint/no-extraneous-class
export class BuiltInInterfaceAdder {

    static readonly primitiveTypeInstanceCache = new Cache<string, BscType>();

    static typedFunctionFactory: (type: BscType) => TypedFunctionType;
    static intersectionTypeFactory: (types: BscType[]) => IntersectionType;
    static unionTypeFactory: (types: BscType[]) => UnionType;

    static getLookupTable: () => SymbolTable;

    static addBuiltInInterfacesToType(thisType: BscType, overrides?: Map<string, BuiltInInterfaceOverride>) {
        const builtInMemberTable = thisType.getBuiltInMemberTable();
        if (!builtInMemberTable) {
            // no memberTable to add to
            // this could be because it's a class that has a parent
            // the original ancestor should get the built ins
            return;
        }
        //const realMemberTable = thisType.getMemberTable();
        //const checkForExistingMembers = realMemberTable && realMemberTable !== builtInMemberTable;
        const builtInComponent = this.getMatchingRokuComponent(thisType);
        if (!builtInComponent) {
            // TODO: Perhaps have error here, but docs have some references to unknown types
            //throw new Error(`Unknown Roku component '${this.getMatchingRokuComponentName(thisType)}' for type '${thisType.toString()}'`);
            return;
        }
        if (!this.typedFunctionFactory) {
            throw new Error(`Unable to build typed functions - no typed function factory`);
        }
        const interfacesToLoop = builtInComponent.interfaces ?? [builtInComponent];

        //add any direct methods from this component to the member table
        if (this.isBrightScriptComponent(thisType)) {
            for (const method of builtInComponent.methods ?? []) {
                const methodFuncType = this.buildMethodFromDocData(method, overrides, thisType);
                let flags = SymbolTypeFlag.runtime;
                //set the deprecated flag if applicable
                if ((method as any).isDeprecated) {
                    flags |= SymbolTypeFlag.deprecated; // eslint-disable-line no-bitwise
                }
                builtInMemberTable.addSymbol(method.name, { ...builtInSymbolData, description: method.description }, methodFuncType, flags);
            }
        }

        for (const iface of interfacesToLoop) {
            const lowerIfaceName = iface.name.toLowerCase();
            const ifaceData = (interfaces[lowerIfaceName] ?? events[lowerIfaceName]) as BRSInterfaceData;

            if (builtInComponent.interfaces) {
                // this type has interfaces - add them directly as members
                const ifaceType = this.getLookupTable()?.getSymbolType(iface.name, { flags: SymbolTypeFlag.typetime });
                if (ifaceType) {
                    builtInMemberTable.addSymbol(iface.name, { ...builtInSymbolData }, ifaceType, SymbolTypeFlag.runtime);
                }
            }

            for (const method of ifaceData.methods ?? []) {
                if (ifaceData.name.toLowerCase() === 'ifintops' && method.name.toLowerCase() === 'tostr') {
                    // handle special case - this messed up the .toStr() method on integers
                    continue;
                }
                const methodFuncType = this.buildMethodFromDocData(method, overrides, thisType);
                builtInMemberTable.addSymbol(method.name, { ...builtInSymbolData, description: method.description }, methodFuncType, SymbolTypeFlag.runtime);
            }
            for (const property of ifaceData.properties ?? []) {
                const override = overrides?.get(property.name.toLowerCase());
                builtInMemberTable.addSymbol(property.name, { ...builtInSymbolData, description: property.description }, override?.type ??
                    this.getPrimitiveType(property.type) ?? this.getPrimitiveType('dynamic'), SymbolTypeFlag.runtime);
            }
        }
    }

    private static builtInMethodCache = new Cache<BRSInterfaceMethodData, TypedFunctionType>();

    private static buildMethodFromDocData(method: BRSInterfaceMethodData, overrides?: Map<string, BuiltInInterfaceOverride>, thisType?: BscType): TypedFunctionType {
        const override = overrides?.get(method.name.toLowerCase());
        const getMethodType = () => {

            let returnType = override?.returnType ?? this.getPrimitiveType(method.returnType);
            if (!returnType && method.returnType.toLowerCase() === (thisType as any)?.name?.toLowerCase()) {
                returnType = thisType;
            }
            const methodFuncType = this.typedFunctionFactory(returnType);
            methodFuncType.name = method.name;
            methodFuncType.isVariadic = method.isVariadic ?? false;
            // eslint-disable-next-line @typescript-eslint/prefer-for-of
            for (let i = 0; i < method.params.length; i++) {
                const param = method.params[i];
                let paramType = override?.parameterTypes?.[i] ?? this.getPrimitiveType(param.type);
                if (!paramType && param.type.toLowerCase() === (thisType as any)?.name?.toLowerCase()) {
                    paramType = thisType;
                }
                paramType ??= this.primitiveTypeInstanceCache.get('dynamic');
                methodFuncType.addParameter(param.name, paramType, !param.isRequired);
            }
            return methodFuncType;
        };

        if (override) {
            return getMethodType();
        }

        return this.builtInMethodCache.getOrAdd(method, getMethodType);
    }

    private static getPrimitiveType(typeName: string): BscType {
        if (typeName.includes(' or ')) {
            if (!this.unionTypeFactory) {
                throw new Error(`Unable to build union types - no union type factory`);
            }
            // union types!
            const unionOfTypeNames = typeName.split(' or ');
            return this.unionTypeFactory(unionOfTypeNames.map(name => this.getPrimitiveType(name)));
        }
        const returnType = this.primitiveTypeInstanceCache.get(typeName.toLowerCase());
        if (!returnType) {
            if (!this.getLookupTable) {
                throw new Error(`Unable to find type instance '${typeName}'`);
            }
            return this.getLookupTable()?.getSymbolType(typeName, { flags: SymbolTypeFlag.typetime, fullName: typeName, tableProvider: this.getLookupTable });
        }

        return returnType;
    }

    static getMatchingRokuComponentName(theType: BscType) {
        if (isStringType(theType)) {
            return 'roString';
        } else if (isIntegerType(theType)) {
            return 'roInt';
        } else if (isBooleanType(theType)) {
            return 'roBoolean';
        } else if (isFloatType(theType)) {
            return 'roFloat';
        } else if (isDoubleType(theType)) {
            return 'roDouble';
        } else if (isLongIntegerType(theType)) {
            return 'roLongInteger';
        } else if (isInvalidType(theType)) {
            return 'roInvalid';
        } else if (isCallableType(theType)) {
            return 'roFunction';
        } else if (isAssociativeArrayType(theType)) {
            return 'roAssociativeArray';
        } else if (isArrayType(theType)) {
            return 'roArray';
        } else if (isEnumMemberType(theType)) {
            return this.getMatchingRokuComponentName(theType.underlyingType);
        } else if (isInterfaceType(theType)) {
            return theType.name;
        } else if (isComponentType(theType)) {
            return 'roSGNode';
        }
    }

    static isBrightScriptComponent(theType: BscType) {
        const componentName = this.getMatchingRokuComponentName(theType);
        if (!componentName) {
            // No component matches the given type
            return;
        }
        const lowerComponentName = componentName.toLowerCase();
        return !!components[lowerComponentName];
    }

    //the return type is a union of the three data types. Just pick the first item from each collection, as every item in the collection should have the same shape
    static getMatchingRokuComponent(theType: BscType): typeof components['roappinfo'] & typeof interfaces['ifappinfo'] & typeof events['rourlevent'] {
        const componentName = this.getMatchingRokuComponentName(theType);
        if (!componentName) {
            // No component matches the given type
            return;
        }
        const lowerComponentName = componentName.toLowerCase();
        return components[lowerComponentName] ?? interfaces[lowerComponentName] ?? events[lowerComponentName];
    }

    static addBuiltInFieldsToNodeType(thisType: ComponentType) {
        const nodeName = thisType.name;
        const memberTable = thisType.memberTable;
        if (!memberTable) {
            // no memberTable to add to
            return;
        }
        const builtInNode = nodes[nodeName.toLowerCase()] as SGNodeData;
        if (!builtInNode) {
            return;
        }
        if (!this.typedFunctionFactory) {
            throw new Error(`Unable to build typed functions - no typed function factory`);
        }
        const lookupTable = this.getLookupTable();
        for (const field of builtInNode.fields) {
            memberTable.addSymbol(field.name, { ...builtInSymbolData, description: field.description }, util.getNodeFieldType(field.type, lookupTable), SymbolTypeFlag.runtime);
        }
        for (const method of builtInNode.methods ?? []) {
            const methodFuncType = this.buildMethodFromDocData(method, null, thisType);
            let flags = SymbolTypeFlag.runtime;
            //set the deprecated flag if applicable
            if (method.isDeprecated) {
                flags |= SymbolTypeFlag.deprecated; // eslint-disable-line no-bitwise
            }
            memberTable.addSymbol(method.name, { ...builtInSymbolData, description: method.description }, methodFuncType, flags);
        }
    }

}

1	import type { BRSInterfaceData, BRSInterfaceMethodData, SGNodeData } from '../roku-types';
2	import { components, events, interfaces, nodes } from '../roku-types';	1✔
3	import { Cache } from '../Cache';	1✔
4	import type { TypedFunctionType } from './TypedFunctionType';
5	import type { SymbolTable } from '../SymbolTable';
6	import { SymbolTypeFlag } from '../SymbolTypeFlag';	1✔
7	import type { BscType } from './BscType';
8	import { isArrayType, isAssociativeArrayType, isBooleanType, isCallableType, isComponentType, isDoubleType, isEnumMemberType, isFloatType, isIntegerType, isInterfaceType, isInvalidType, isLongIntegerType, isStringType } from '../astUtils/reflection';	1✔
9	import type { ComponentType } from './ComponentType';
10	import { util } from '../util';	1✔
11	import type { UnionType } from './UnionType';
12	import type { ExtraSymbolData } from '../interfaces';
13	import type { IntersectionType } from './IntersectionType';
14
15
16	export interface BuiltInInterfaceOverride {
17	type?: BscType;
18	parameterTypes?: BscType[];
19	returnType?: BscType;
20	}
21
22	const builtInSymbolData: ExtraSymbolData = {	1✔
23	completionPriority: 1,
24	isBuiltIn: true
25	};
26
27	// eslint-disable-next-line @typescript-eslint/no-extraneous-class
28	export class BuiltInInterfaceAdder {	1✔
29
30	static readonly primitiveTypeInstanceCache = new Cache<string, BscType>();	1✔
31
32	static typedFunctionFactory: (type: BscType) => TypedFunctionType;
33	static intersectionTypeFactory: (types: BscType[]) => IntersectionType;
34	static unionTypeFactory: (types: BscType[]) => UnionType;
35
36	static getLookupTable: () => SymbolTable;
37
38	static addBuiltInInterfacesToType(thisType: BscType, overrides?: Map<string, BuiltInInterfaceOverride>) {
39	const builtInMemberTable = thisType.getBuiltInMemberTable();	581,213✔
40	if (!builtInMemberTable) {	581,213✔
41	// no memberTable to add to
42	// this could be because it's a class that has a parent
43	// the original ancestor should get the built ins
44	return;	193,807✔
45	}
46	//const realMemberTable = thisType.getMemberTable();
47	//const checkForExistingMembers = realMemberTable && realMemberTable !== builtInMemberTable;
48	const builtInComponent = this.getMatchingRokuComponent(thisType);	387,406✔
49	if (!builtInComponent) {	387,406✔
50	// TODO: Perhaps have error here, but docs have some references to unknown types
51	//throw new Error(`Unknown Roku component '${this.getMatchingRokuComponentName(thisType)}' for type '${thisType.toString()}'`);
52	return;	4,270✔
53	}
54	if (!this.typedFunctionFactory) {	383,136!
UNCOV 55	throw new Error(`Unable to build typed functions - no typed function factory`);	×
56	}
57	const interfacesToLoop = builtInComponent.interfaces ?? [builtInComponent];	383,136✔
58
59	//add any direct methods from this component to the member table
60	if (this.isBrightScriptComponent(thisType)) {	383,136✔
61	for (const method of builtInComponent.methods ?? []) {	157,596✔
62	const methodFuncType = this.buildMethodFromDocData(method, overrides, thisType);	15,036✔
63	let flags = SymbolTypeFlag.runtime;	15,036✔
64	//set the deprecated flag if applicable
65	if ((method as any).isDeprecated) {	15,036✔
66	flags \|= SymbolTypeFlag.deprecated; // eslint-disable-line no-bitwise	2,148✔
67	}
68	builtInMemberTable.addSymbol(method.name, { ...builtInSymbolData, description: method.description }, methodFuncType, flags);	15,036✔
69	}
70	}
71
72	for (const iface of interfacesToLoop) {	383,136✔
73	const lowerIfaceName = iface.name.toLowerCase();	620,826✔
74	const ifaceData = (interfaces[lowerIfaceName] ?? events[lowerIfaceName]) as BRSInterfaceData;	620,826✔
75
76	if (builtInComponent.interfaces) {	620,826✔
77	// this type has interfaces - add them directly as members
78	const ifaceType = this.getLookupTable()?.getSymbolType(iface.name, { flags: SymbolTypeFlag.typetime });	395,286!
79	if (ifaceType) {	395,286!
80	builtInMemberTable.addSymbol(iface.name, { ...builtInSymbolData }, ifaceType, SymbolTypeFlag.runtime);	395,286✔
81	}
82	}
83
84	for (const method of ifaceData.methods ?? []) {	620,826!
85	if (ifaceData.name.toLowerCase() === 'ifintops' && method.name.toLowerCase() === 'tostr') {	4,607,387✔
86	// handle special case - this messed up the .toStr() method on integers
87	continue;	4,357✔
88	}
89	const methodFuncType = this.buildMethodFromDocData(method, overrides, thisType);	4,603,030✔
90	builtInMemberTable.addSymbol(method.name, { ...builtInSymbolData, description: method.description }, methodFuncType, SymbolTypeFlag.runtime);	4,603,030✔
91	}
92	for (const property of ifaceData.properties ?? []) {	620,826!
UNCOV 93	const override = overrides?.get(property.name.toLowerCase());	×
UNCOV 94	builtInMemberTable.addSymbol(property.name, { ...builtInSymbolData, description: property.description }, override?.type ??	×
95	this.getPrimitiveType(property.type) ?? this.getPrimitiveType('dynamic'), SymbolTypeFlag.runtime);	×
96	}
97	}
98	}
99
100	private static builtInMethodCache = new Cache<BRSInterfaceMethodData, TypedFunctionType>();	1✔
101
102	private static buildMethodFromDocData(method: BRSInterfaceMethodData, overrides?: Map<string, BuiltInInterfaceOverride>, thisType?: BscType): TypedFunctionType {
103	const override = overrides?.get(method.name.toLowerCase());	4,618,066✔
104	const getMethodType = () => {	4,618,066✔
105
106	let returnType = override?.returnType ?? this.getPrimitiveType(method.returnType);	1,191✔
107	if (!returnType && method.returnType.toLowerCase() === (thisType as any)?.name?.toLowerCase()) {	1,191!
UNCOV 108	returnType = thisType;	×
109	}
110	const methodFuncType = this.typedFunctionFactory(returnType);	1,191✔
111	methodFuncType.name = method.name;	1,191✔
112	methodFuncType.isVariadic = method.isVariadic ?? false;	1,191✔
113	// eslint-disable-next-line @typescript-eslint/prefer-for-of
114	for (let i = 0; i < method.params.length; i++) {	1,191✔
115	const param = method.params[i];	700✔
116	let paramType = override?.parameterTypes?.[i] ?? this.getPrimitiveType(param.type);	700✔
117	if (!paramType && param.type.toLowerCase() === (thisType as any)?.name?.toLowerCase()) {	700!
UNCOV 118	paramType = thisType;	×
119	}
120	paramType ??= this.primitiveTypeInstanceCache.get('dynamic');	700!
121	methodFuncType.addParameter(param.name, paramType, !param.isRequired);	700✔
122	}
123	return methodFuncType;	1,191✔
124	};
125
126	if (override) {	4,618,066✔
127	return getMethodType();	406✔
128	}
129
130	return this.builtInMethodCache.getOrAdd(method, getMethodType);	4,617,660✔
131	}
132
133	private static getPrimitiveType(typeName: string): BscType {
134	if (typeName.includes(' or ')) {	1,499✔
135	if (!this.unionTypeFactory) {	7!
UNCOV 136	throw new Error(`Unable to build union types - no union type factory`);	×
137	}
138	// union types!
139	const unionOfTypeNames = typeName.split(' or ');	7✔
140	return this.unionTypeFactory(unionOfTypeNames.map(name => this.getPrimitiveType(name)));	14✔
141	}
142	const returnType = this.primitiveTypeInstanceCache.get(typeName.toLowerCase());	1,492✔
143	if (!returnType) {	1,492✔
144	if (!this.getLookupTable) {	38!
UNCOV 145	throw new Error(`Unable to find type instance '${typeName}'`);	×
146	}
147	return this.getLookupTable()?.getSymbolType(typeName, { flags: SymbolTypeFlag.typetime, fullName: typeName, tableProvider: this.getLookupTable });	38!
148	}
149
150	return returnType;	1,454✔
151	}
152
153	static getMatchingRokuComponentName(theType: BscType) {
154	if (isStringType(theType)) {	771,160✔
155	return 'roString';	234✔
156	} else if (isIntegerType(theType)) {	770,926✔
157	return 'roInt';	120✔
158	} else if (isBooleanType(theType)) {	770,806✔
159	return 'roBoolean';	10✔
160	} else if (isFloatType(theType)) {	770,796✔
161	return 'roFloat';	12✔
162	} else if (isDoubleType(theType)) {	770,784✔
163	return 'roDouble';	6✔
164	} else if (isLongIntegerType(theType)) {	770,778✔
165	return 'roLongInteger';	2✔
166	} else if (isInvalidType(theType)) {	770,776!
UNCOV 167	return 'roInvalid';	×
168	} else if (isCallableType(theType)) {	770,776✔
169	return 'roFunction';	4,590✔
170	} else if (isAssociativeArrayType(theType)) {	766,186✔
171	return 'roAssociativeArray';	724✔
172	} else if (isArrayType(theType)) {	765,462✔
173	return 'roArray';	118✔
174	} else if (isEnumMemberType(theType)) {	765,344✔
175	return this.getMatchingRokuComponentName(theType.underlyingType);	618✔
176	} else if (isInterfaceType(theType)) {	764,726✔
177	return theType.name;	732,868✔
178	} else if (isComponentType(theType)) {	31,858✔
179	return 'roSGNode';	30,128✔
180	}
181	}
182
183	static isBrightScriptComponent(theType: BscType) {
184	const componentName = this.getMatchingRokuComponentName(theType);	383,136✔
185	if (!componentName) {	383,136!
186	// No component matches the given type
UNCOV 187	return;	×
188	}
189	const lowerComponentName = componentName.toLowerCase();	383,136✔
190	return !!components[lowerComponentName];	383,136✔
191	}
192
193	//the return type is a union of the three data types. Just pick the first item from each collection, as every item in the collection should have the same shape
194	static getMatchingRokuComponent(theType: BscType): typeof components['roappinfo'] & typeof interfaces['ifappinfo'] & typeof events['rourlevent'] {
195	const componentName = this.getMatchingRokuComponentName(theType);	387,406✔
196	if (!componentName) {	387,406✔
197	// No component matches the given type
198	return;	1,867✔
199	}
200	const lowerComponentName = componentName.toLowerCase();	385,539✔
201	return components[lowerComponentName] ?? interfaces[lowerComponentName] ?? events[lowerComponentName];	385,539✔
202	}
203
204	static addBuiltInFieldsToNodeType(thisType: ComponentType) {
205	const nodeName = thisType.name;	208,766✔
206	const memberTable = thisType.memberTable;	208,766✔
207	if (!memberTable) {	208,766!
208	// no memberTable to add to
UNCOV 209	return;	×
210	}
211	const builtInNode = nodes[nodeName.toLowerCase()] as SGNodeData;	208,766✔
212	if (!builtInNode) {	208,766✔
213	return;	409✔
214	}
215	if (!this.typedFunctionFactory) {	208,357!
UNCOV 216	throw new Error(`Unable to build typed functions - no typed function factory`);	×
217	}
218	const lookupTable = this.getLookupTable();	208,357✔
219	for (const field of builtInNode.fields) {	208,357✔
220	memberTable.addSymbol(field.name, { ...builtInSymbolData, description: field.description }, util.getNodeFieldType(field.type, lookupTable), SymbolTypeFlag.runtime);	1,939,659✔
221	}
222	for (const method of builtInNode.methods ?? []) {	208,357!
UNCOV 223	const methodFuncType = this.buildMethodFromDocData(method, null, thisType);	×
UNCOV 224	let flags = SymbolTypeFlag.runtime;	×
225	//set the deprecated flag if applicable
226	if (method.isDeprecated) {	×
UNCOV 227	flags \|= SymbolTypeFlag.deprecated; // eslint-disable-line no-bitwise	×
228	}
229	memberTable.addSymbol(method.name, { ...builtInSymbolData, description: method.description }, methodFuncType, flags);	×
230	}
231	}
232
233	}

rokucommunity / brighterscript / #15078

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