#13071

Committed 25 Sep 2024 04:16PM UTC coverage: 86.525% (-1.4%) from 87.933%

Build Type

push

Committed by

Commit Message

Merge c610b9e4e into 56dcaaa63

Run Details

10903 of 13389 branches covered (81.43%)

Branch coverage included in aggregate %.

6936 of 7533 new or added lines in 100 files covered. (92.07%)

83 existing lines in 18 files now uncovered.

12548 of 13714 relevant lines covered (91.5%)

27591.0 hits per line

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

86.67

/src/types/BscType.ts

import type { GetSymbolTypeOptions, SymbolTableProvider } from '../SymbolTable';
import { SymbolTable } from '../SymbolTable';
import { SymbolTypeFlag } from '../SymbolTypeFlag';
import { BuiltInInterfaceAdder } from './BuiltInInterfaceAdder';
import type { ExtraSymbolData, TypeCompatibilityData } from '../interfaces';
import { isArrayType, isInheritableType, isReferenceType } from '../astUtils/reflection';

export abstract class BscType {

    public readonly memberTable: SymbolTable;
    protected __identifier: string;
    protected hasAddedBuiltInInterfaces = false;

    constructor(name = '') {
        this.__identifier = `${this.constructor.name}${name ? ': ' + name : ''}`;
        this.memberTable = new SymbolTable(this.__identifier);
    }

    pushMemberProvider(provider: SymbolTableProvider) {
        this.memberTable.pushParentProvider(provider);
    }

    popMemberProvider() {
        this.memberTable.popParentProvider();
    }

    getBuiltInMemberTable(): SymbolTable {
        return this.memberTable;
    }

    addMember(name: string, data: ExtraSymbolData, type: BscType, flags: SymbolTypeFlag) {
        this.memberTable.addSymbol(name, data, type, flags);
    }

    getMemberType(name: string, options: GetSymbolTypeOptions) {
        this.addBuiltInInterfaces();
        return this.memberTable.getSymbolType(name, options);
    }

    getMemberTable() {
        this.addBuiltInInterfaces();
        return this.memberTable;
    }

    isResolvable(): boolean {
        return true;
    }

    /**
     * Check if this type can be assigned to the target type
     * @param targetType the type that we're trying to assign this type to
     * @deprecated
     */
    isAssignableTo(targetType: BscType): boolean {
        return targetType.isTypeCompatible(this);
    }

    /**
     * Check if a different type can be assigned to this type - eg. does the other type convert into this type?
     * @param _otherType the type to check if it can be used as this type, or can automatically be converted into this type
     */
    isTypeCompatible(_otherType: BscType, data?: TypeCompatibilityData): boolean {
        throw new Error('Method not implemented.');
    }
    toString(): string {
        throw new Error('Method not implemented.');
    }
    toTypeString(): string {
        throw new Error('Method not implemented.');
    }

    isEqual(targetType: BscType, data: TypeCompatibilityData = {}): boolean {
        throw new Error('Method not implemented.');
    }

    checkCompatibilityBasedOnMembers(targetType: BscType, flags: SymbolTypeFlag, data: TypeCompatibilityData = {}) {
        if (!targetType) {
            return false;
        }
        let isSuperSet = true;
        data.missingFields ||= [];
        data.fieldMismatches ||= [];
        data.depth = data.depth ? data.depth + 1 : 1;
        //data.chain ||= [];
        this.addBuiltInInterfaces();
        targetType.addBuiltInInterfaces();

        if (this === targetType) {
            return true;
        }

        if (isReferenceType(targetType) && !targetType.isResolvable()) {
            // we can't resolve the other type. Assume it does not fail on member checks
            return true;
        }

        if (data.depth > 16) {
            // some sort of circular reference
            return false;
        }
        const mySymbols = this.getMemberTable()?.getAllSymbols(flags);
        for (const memberSymbol of mySymbols) {
            const targetTypesOfSymbol = targetType.getMemberTable()
                .getSymbolTypes(memberSymbol.name, { flags: flags })
                ?.map(symbol => symbol.type);
            if (!targetTypesOfSymbol || targetTypesOfSymbol.length === 0) {
                // eslint-disable-next-line no-bitwise
                if (!(memberSymbol.flags & SymbolTypeFlag.optional)) {
                    data.missingFields.push({ name: memberSymbol.name, expectedType: memberSymbol.type });
                    isSuperSet = false;
                }

            } else {
                isSuperSet =
                    (targetTypesOfSymbol ?? []).reduce((superSetSoFar, typeOfTargetSymbol) => {
                        if (!superSetSoFar) {
                            return superSetSoFar;
                        }
                        const typesAreInheritableWithSameName = isInheritableType(memberSymbol.type) && isInheritableType(typeOfTargetSymbol) &&
                            memberSymbol.type.name.toLowerCase() === typeOfTargetSymbol.name.toLowerCase();
                        const typesAreArraysWithSameDefault = isArrayType(memberSymbol.type) && isArrayType(typeOfTargetSymbol) &&
                            memberSymbol.type.defaultType.isEqual(typeOfTargetSymbol.defaultType);
                        const myMemberAllowsTargetType = typesAreInheritableWithSameName || typesAreArraysWithSameDefault || memberSymbol.type?.isTypeCompatible(typeOfTargetSymbol, { depth: data.depth });
                        if (!myMemberAllowsTargetType) {
                            data.fieldMismatches.push({ name: memberSymbol.name, expectedType: memberSymbol.type, actualType: targetType.getMemberType(memberSymbol.name, { flags: flags }) });
                        }
                        return superSetSoFar && myMemberAllowsTargetType;
                    }, true) && isSuperSet;
            }

        }
        data.depth = 0;
        return isSuperSet;
    }

    addBuiltInInterfaces() {
        if (!this.hasAddedBuiltInInterfaces) {
            BuiltInInterfaceAdder.addBuiltInInterfacesToType(this);
        }
        this.hasAddedBuiltInInterfaces = true;
    }
}

1	import type { GetSymbolTypeOptions, SymbolTableProvider } from '../SymbolTable';
2	import { SymbolTable } from '../SymbolTable';	1✔
3	import { SymbolTypeFlag } from '../SymbolTypeFlag';	1✔
4	import { BuiltInInterfaceAdder } from './BuiltInInterfaceAdder';	1✔
5	import type { ExtraSymbolData, TypeCompatibilityData } from '../interfaces';
6	import { isArrayType, isInheritableType, isReferenceType } from '../astUtils/reflection';	1✔
7
8	export abstract class BscType {	1✔
9
10	public readonly memberTable: SymbolTable;
11	protected __identifier: string;
12	protected hasAddedBuiltInInterfaces = false;	5,134,846✔
13
14	constructor(name = '') {	4,391,609✔
15	this.__identifier = `${this.constructor.name}${name ? ': ' + name : ''}`;	5,134,846✔
16	this.memberTable = new SymbolTable(this.__identifier);	5,134,846✔
17	}
18
19	pushMemberProvider(provider: SymbolTableProvider) {
20	this.memberTable.pushParentProvider(provider);	10,179✔
21	}
22
23	popMemberProvider() {
NEW 24	this.memberTable.popParentProvider();	×
25	}
26
27	getBuiltInMemberTable(): SymbolTable {
28	return this.memberTable;	274,113✔
29	}
30
31	addMember(name: string, data: ExtraSymbolData, type: BscType, flags: SymbolTypeFlag) {
32	this.memberTable.addSymbol(name, data, type, flags);	21,133✔
33	}
34
35	getMemberType(name: string, options: GetSymbolTypeOptions) {
36	this.addBuiltInInterfaces();	12,575✔
37	return this.memberTable.getSymbolType(name, options);	12,575✔
38	}
39
40	getMemberTable() {
41	this.addBuiltInInterfaces();	1,102✔
42	return this.memberTable;	1,102✔
43	}
44
45	isResolvable(): boolean {
46	return true;	15,152✔
47	}
48
49	/**
50	* Check if this type can be assigned to the target type
51	* @param targetType the type that we're trying to assign this type to
52	* @deprecated
53	*/
54	isAssignableTo(targetType: BscType): boolean {
NEW 55	return targetType.isTypeCompatible(this);	×
56	}
57
58	/**
59	* Check if a different type can be assigned to this type - eg. does the other type convert into this type?
60	* @param _otherType the type to check if it can be used as this type, or can automatically be converted into this type
61	*/
62	isTypeCompatible(_otherType: BscType, data?: TypeCompatibilityData): boolean {
NEW 63	throw new Error('Method not implemented.');	×
64	}
65	toString(): string {
NEW 66	throw new Error('Method not implemented.');	×
67	}
68	toTypeString(): string {
NEW 69	throw new Error('Method not implemented.');	×
70	}
71
72	isEqual(targetType: BscType, data: TypeCompatibilityData = {}): boolean {	×
NEW 73	throw new Error('Method not implemented.');	×
74	}
75
76	checkCompatibilityBasedOnMembers(targetType: BscType, flags: SymbolTypeFlag, data: TypeCompatibilityData = {}) {	52✔
77	if (!targetType) {	207✔
78	return false;	2✔
79	}
80	let isSuperSet = true;	205✔
81	data.missingFields \|\|= [];	205✔
82	data.fieldMismatches \|\|= [];	205✔
83	data.depth = data.depth ? data.depth + 1 : 1;	205✔
84	//data.chain \|\|= [];
85	this.addBuiltInInterfaces();	205✔
86	targetType.addBuiltInInterfaces();	205✔
87
88	if (this === targetType) {	205✔
89	return true;	18✔
90	}
91
92	if (isReferenceType(targetType) && !targetType.isResolvable()) {	187!
93	// we can't resolve the other type. Assume it does not fail on member checks
NEW 94	return true;	×
95	}
96
97	if (data.depth > 16) {	187!
98	// some sort of circular reference
NEW 99	return false;	×
100	}
101	const mySymbols = this.getMemberTable()?.getAllSymbols(flags);	187!
102	for (const memberSymbol of mySymbols) {	187✔
103	const targetTypesOfSymbol = targetType.getMemberTable()	845✔
104	.getSymbolTypes(memberSymbol.name, { flags: flags })	845✔
105	?.map(symbol => symbol.type);	725✔
106	if (!targetTypesOfSymbol \|\| targetTypesOfSymbol.length === 0) {	845✔
107	// eslint-disable-next-line no-bitwise
108	if (!(memberSymbol.flags & SymbolTypeFlag.optional)) {	120✔
109	data.missingFields.push({ name: memberSymbol.name, expectedType: memberSymbol.type });	115✔
110	isSuperSet = false;	115✔
111	}
112
113	} else {
114	isSuperSet =	725✔
115	(targetTypesOfSymbol ?? []).reduce((superSetSoFar, typeOfTargetSymbol) => {	3,605!
116	if (!superSetSoFar) {	725!
NEW 117	return superSetSoFar;	×
118	}
119	const typesAreInheritableWithSameName = isInheritableType(memberSymbol.type) && isInheritableType(typeOfTargetSymbol) &&	725✔
120	memberSymbol.type.name.toLowerCase() === typeOfTargetSymbol.name.toLowerCase();
121	const typesAreArraysWithSameDefault = isArrayType(memberSymbol.type) && isArrayType(typeOfTargetSymbol) &&	725✔
122	memberSymbol.type.defaultType.isEqual(typeOfTargetSymbol.defaultType);
123	const myMemberAllowsTargetType = typesAreInheritableWithSameName \|\| typesAreArraysWithSameDefault \|\| memberSymbol.type?.isTypeCompatible(typeOfTargetSymbol, { depth: data.depth });	725!
124	if (!myMemberAllowsTargetType) {	725✔
125	data.fieldMismatches.push({ name: memberSymbol.name, expectedType: memberSymbol.type, actualType: targetType.getMemberType(memberSymbol.name, { flags: flags }) });	20✔
126	}
127	return superSetSoFar && myMemberAllowsTargetType;	725✔
128	}, true) && isSuperSet;
129	}
130
131	}
132	data.depth = 0;	187✔
133	return isSuperSet;	187✔
134	}
135
136	addBuiltInInterfaces() {
137	if (!this.hasAddedBuiltInInterfaces) {	285,817✔
138	BuiltInInterfaceAdder.addBuiltInInterfacesToType(this);	274,357✔
139	}
140	this.hasAddedBuiltInInterfaces = true;	285,817✔
141	}
142	}

rokucommunity / brighterscript / #13071

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