#13211

Committed 19 Oct 2024 06:15PM UTC coverage: 86.838% (-1.4%) from 88.214%

Build Type

push

Committed by

Commit Message

Merge 65d0479eb into 7cfaaa047

Run Details

11593 of 14113 branches covered (82.14%)

Branch coverage included in aggregate %.

7018 of 7610 new or added lines in 100 files covered. (92.22%)

87 existing lines in 18 files now uncovered.

12720 of 13885 relevant lines covered (91.61%)

29935.05 hits per line

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

80.12

/src/types/ReferenceType.ts

import type { GetTypeOptions, TypeChainEntry, TypeCompatibilityData } from '../interfaces';
import type { GetSymbolTypeOptions, SymbolTypeGetterProvider } from '../SymbolTable';
import type { SymbolTypeFlag } from '../SymbolTypeFlag';
import { isAnyReferenceType, isArrayDefaultTypeReferenceType, isArrayType, isBinaryOperatorReferenceType, isComponentType, isDynamicType, isReferenceType, isTypePropertyReferenceType } from '../astUtils/reflection';
import { BscType } from './BscType';
import { DynamicType } from './DynamicType';
import { BscTypeKind } from './BscTypeKind';
import type { Token } from '../lexer/Token';

export type AnyReferenceType = ReferenceType | TypePropertyReferenceType | BinaryOperatorReferenceType | ArrayDefaultTypeReferenceType;

export function referenceTypeFactory(memberKey: string, fullName, flags: SymbolTypeFlag, tableProvider: SymbolTypeGetterProvider) {
    return new ReferenceType(memberKey, fullName, flags, tableProvider);
}

export class ReferenceType extends BscType {

    /**
     * ReferenceTypes are used when the actual type may be resolved later from a Symbol table
     * @param memberKey which key do we use to look up this type in the given table?
     * @param fullName the full/display name for this type
     * @param flags is this type available at typetime, runtime, etc.
     * @param tableProvider function that returns a SymbolTable that we use for the lookup.
     */
    constructor(public memberKey: string, public fullName, public flags: SymbolTypeFlag, private tableProvider: SymbolTypeGetterProvider) {
        super(memberKey);
        // eslint-disable-next-line no-constructor-return
        return new Proxy(this, {
            get: (target, propName, receiver) => {

                if (propName === '__reflection') {
                    // Cheeky way to get `isReferenceType` reflection to work
                    return this.__reflection;
                }
                if (propName === '__identifier') {
                    // Cheeky way to get `isReferenceType` reflection to work
                    return this.__identifier;
                }
                if (propName === 'fullName') {
                    return this.fullName;
                }
                if (propName === 'isResolvable') {
                    return () => {
                        let resultSoFar = this.resolve();
                        while (resultSoFar && isReferenceType(resultSoFar)) {
                            resultSoFar = (resultSoFar as any).getTarget?.();
                        }
                        return !!resultSoFar;
                    };
                }
                if (propName === 'getTarget') {
                    return () => {
                        return this.resolve();
                    };
                }
                if (propName === 'tableProvider') {
                    return this.tableProvider;
                }
                if (propName === 'isEqual') {
                    //Need to be able to check equality without resolution, because resolution need to check equality
                    //To see if you need to make a UnionType
                    return (targetType: BscType, data?: TypeCompatibilityData) => {
                        if (!targetType) {
                            return false;
                        }
                        const resolvedType = this.resolve();
                        let equal = false;
                        if (resolvedType && !isReferenceType(resolvedType)) {
                            equal = resolvedType.isEqual(targetType, data);
                        } else if (isReferenceType(targetType)) {
                            equal = this.fullName.toLowerCase() === targetType.fullName.toLowerCase() &&
                                (this.tableProvider === targetType.tableProvider ||
                                    this.tableProvider().name === targetType.tableProvider().name);
                        } else {
                            equal = targetType.isEqual(this, data);
                        }
                        return equal;
                    };
                }
                if (propName === 'isTypeCompatible') {
                    //Need to be able to check equality without resolution, because resolution need to check equality
                    //To see if you need to make a UnionType
                    return (targetType: BscType, data?: TypeCompatibilityData) => {
                        if (!targetType) {
                            return false;
                        }
                        if (isDynamicType(targetType)) {
                            return true;
                        }
                        const resolvedType = this.resolve();
                        if (resolvedType && !isReferenceType(resolvedType)) {
                            return resolvedType.isTypeCompatible(targetType, data);
                        } else if (isReferenceType(targetType)) {
                            return this.fullName.toLowerCase() === targetType.fullName.toLowerCase() &&
                                this.tableProvider === targetType.tableProvider;
                        }
                        return targetType.isTypeCompatible(this, data);
                    };
                }

                //There may be some need to specifically get members on ReferenceType in the future
                // eg: if (Reflect.has(target, name)) {
                //   return Reflect.get(target, propName, receiver);

                let innerType = this.resolve();

                if (!innerType) {
                    // No real BscType found - we may need to handle some specific cases

                    if (propName === 'getMemberType') {
                        // We're looking for a member of a reference type
                        // Since we don't know what type this is, yet, return ReferenceType
                        return (memberName: string, options: GetTypeOptions) => {
                            const resolvedType = this.resolve();
                            if (resolvedType) {
                                return resolvedType.getMemberType(memberName, options);
                            }
                            const refLookUp = `${memberName.toLowerCase()}-${options?.flags}`;
                            let memberTypeReference = this.memberTypeReferences.get(refLookUp);
                            if (memberTypeReference) {
                                return memberTypeReference;

                            }
                            memberTypeReference = new ReferenceType(memberName, this.makeMemberFullName(memberName), options.flags, this.futureMemberTableProvider);
                            this.memberTypeReferences.set(refLookUp, memberTypeReference);
                            return memberTypeReference;
                        };
                    } else if (propName === 'getCallFuncType') {
                        // We're looking for a callfunc member of a reference type
                        // Since we don't know what type this is, yet, return ReferenceType
                        return (memberName: string, options: GetTypeOptions) => {
                            const resolvedType = this.resolve();
                            if (isComponentType(resolvedType)) {
                                return resolvedType.getCallFuncType(memberName, options);
                            }
                            const refLookUp = `${memberName.toLowerCase()}-${options.flags}-callfunc`;
                            let callFuncMemberTypeReference = this.callFuncMemberTypeReferences.get(refLookUp);
                            if (callFuncMemberTypeReference) {
                                return callFuncMemberTypeReference;

                            }
                            callFuncMemberTypeReference = new ReferenceType(memberName, this.makeMemberFullName(memberName), options.flags, this.futureCallFuncMemberTableProvider);
                            this.callFuncMemberTypeReferences.set(refLookUp, callFuncMemberTypeReference);
                            return callFuncMemberTypeReference;
                        };
                    } else if (propName === 'toString') {
                        // This type was never found
                        // For diagnostics, we should return the expected name of of the type
                        return () => this.fullName;
                    } else if (propName === 'toTypeString') {
                        // For transpilation, we should 'dynamic'
                        return () => 'dynamic';
                    } else if (propName === 'returnType') {
                        let propRefType = this.propertyTypeReference.get(propName);
                        if (!propRefType) {
                            propRefType = new TypePropertyReferenceType(this, propName);
                            this.propertyTypeReference.set(propName, propRefType);
                        }
                        return propRefType;
                    } else if (propName === 'memberTable') {
                        return this.memberTable;
                    } else if (propName === 'getMemberTable') {
                        return () => {
                            return this.memberTable;
                        };
                    } else if (propName === 'callFuncTable') {
                        return (this as any).callFuncMemberTable;
                    } else if (propName === 'getCallFuncTable') {
                        return () => {
                            return (this as any).callFuncMemberTable;
                        };
                    } else if (propName === 'isTypeCompatible') {
                        return (targetType: BscType) => {
                            return isDynamicType(targetType);
                        };
                    } else if (propName === 'isEqual') {
                        return (targetType: BscType) => {
                            if (isReferenceType(targetType)) {
                                return this.fullName.toLowerCase() === targetType.toString().toLowerCase() &&
                                    this.tableProvider() === targetType.tableProvider();
                            }
                            return false;
                        };
                    } else if (propName === 'addBuiltInInterfaces') {
                        // this is an unknown type. There is no use in adding built in interfaces
                        // return no-op function
                        return () => { };
                    } else if (propName === 'hasAddedBuiltInInterfaces') {
                        // this is an unknown type. There is no use in adding built in interfaces
                        return true;
                    }
                }

                if (!innerType) {
                    innerType = DynamicType.instance;
                }
                const result = Reflect.get(innerType, propName, innerType);
                return result;
            },
            set: (target, name, value, receiver) => {
                //There may be some need to specifically set members on ReferenceType in the future
                // eg: if (Reflect.has(target, name)) {
                //   return Reflect.set(target, name, value, receiver);

                let innerType = this.resolve();

                // Look for circular references
                if (!innerType || this.referenceChain.has(innerType)) {
                    return false;
                }
                const result = Reflect.set(innerType, name, value, innerType);
                this.referenceChain.clear();
                return result;
            }
        });
    }

    public readonly kind = BscTypeKind.ReferenceType;

    /**
     * Resolves the type based on the original name and the table provider
     */
    private resolve(): BscType {
        const symbolTable = this.tableProvider();
        if (!symbolTable) {
            return;
        }
        // Look for circular references
        let resolvedType = symbolTable.getSymbolType(this.memberKey, { flags: this.flags, onlyCacheResolvedTypes: true });
        if (!resolvedType) {
            // could not find this member
            return;
        }
        if (isAnyReferenceType(resolvedType)) {
            // If this is a referenceType, keep digging down until we have a non reference Type.
            while (resolvedType && isAnyReferenceType(resolvedType)) {
                if (this.referenceChain.has(resolvedType)) {
                    // this is a circular reference
                    this.circRefCount++;
                }
                if (this.circRefCount > 1) {
                    //It is possible that we could properly resolve the case that one reference points to itself
                    //see test: '[Scope][symbolTable lookups with enhanced typing][finds correct class field type with default value enums are used]
                    return;
                }
                this.referenceChain.add(resolvedType);
                resolvedType = (resolvedType as any).getTarget?.();
            }
            this.tableProvider().setCachedType(this.memberKey, { type: resolvedType }, { flags: this.flags });
        }

        if (resolvedType && !isAnyReferenceType(resolvedType)) {
            this.circRefCount = 0;
            this.referenceChain.clear();
        }
        return resolvedType;
    }

    get __reflection() {
        return { name: 'ReferenceType' };
    }

    makeMemberFullName(memberName: string) {
        return this.fullName + '.' + memberName;
    }
    private circRefCount = 0;

    private referenceChain = new Set<BscType>();

    private propertyTypeReference = new Map<string, TypePropertyReferenceType>();

    private memberTypeReferences = new Map<string, ReferenceType>();
    private callFuncMemberTypeReferences = new Map<string, ReferenceType>();

    private futureMemberTableProvider = () => {
        return {
            name: `FutureMemberTableProvider: '${this.__identifier}'`,
            getSymbolType: (innerName: string, innerOptions: GetTypeOptions) => {
                const resolvedType = this.resolve();
                if (resolvedType) {
                    return resolvedType.getMemberType(innerName, innerOptions);
                }
            },
            setCachedType: (innerName: string, innerResolvedTypeCacheEntry: TypeChainEntry, options: GetSymbolTypeOptions) => {
                const resolvedType = this.resolve();
                if (resolvedType) {
                    resolvedType.memberTable.setCachedType(innerName, innerResolvedTypeCacheEntry, options);
                }
            }
        };
    };

    private futureCallFuncMemberTableProvider = () => {
        return {
            name: `FutureCallFuncMemberTableProvider: '${this.__identifier}'`,
            getSymbolType: (innerName: string, innerOptions: GetTypeOptions) => {
                const resolvedType = this.resolve();
                if (isComponentType(resolvedType)) {
                    return resolvedType.getCallFuncType(innerName, innerOptions);
                }
            },
            setCachedType: (innerName: string, innerResolvedTypeCacheEntry: TypeChainEntry, options: GetSymbolTypeOptions) => {
                const resolvedType = this.resolve();
                if (isComponentType(resolvedType)) {
                    resolvedType.getCallFuncTable().setCachedType(innerName, innerResolvedTypeCacheEntry, options);
                }
            }
        };
    };
}

/**
 * Use this class for when you need to reference a property of a BscType, and that property is also a BscType,
 * Especially when the instance with the property may not have been instantiated/discovered yet
 *
 * For Example, FunctionType.returnType --- if the FunctionExpression has not been walked yet, it will be a ReferenceType
 * if we just access .returnType on a ReferenceType that doesn't have access to an actual FunctionType yet, .returnType will be undefined
 * So when we use this class, it maintains that reference to a potential ReferenceType, and this class will change from
 * returning undefined to the ACTUAL .returnType when the ReferenceType can be resolved.
 *
 * This is really cool. It's like programming with time-travel.
 */
export class TypePropertyReferenceType extends BscType {
    constructor(public outerType: BscType, public propertyName: string) {
        super(propertyName);
        // eslint-disable-next-line no-constructor-return
        return new Proxy(this, {
            get: (target, propName, receiver) => {

                if (propName === '__reflection') {
                    // Cheeky way to get `isTypePropertyReferenceType` reflection to work
                    return { name: 'TypePropertyReferenceType' };
                }

                if (propName === 'outerType') {
                    return outerType;
                }

                if (isAnyReferenceType(this.outerType) && !this.outerType.isResolvable()) {
                    if (propName === 'getMemberType') {
                        //If we're calling `getMemberType()`, we need it to proxy to using the actual symbol table
                        //So if that symbol is ever populated, the correct type is passed through
                        return (memberName: string, options: GetSymbolTypeOptions) => {
                            const fullMemberName = this.outerType.toString() + '.' + memberName;
                            return new ReferenceType(memberName, fullMemberName, options.flags, () => {
                                return {
                                    name: `TypePropertyReferenceType : '${fullMemberName}'`,
                                    getSymbolType: (innerName: string, innerOptions: GetTypeOptions) => {
                                        return this.outerType?.[this.propertyName]?.getMemberType(innerName, innerOptions);
                                    },
                                    setCachedType: (innerName: string, innerTypeCacheEntry: TypeChainEntry, innerOptions: GetTypeOptions) => {
                                        return this.outerType?.[this.propertyName]?.memberTable.setCachedType(innerName, innerTypeCacheEntry, innerOptions);
                                    }
                                };
                            });
                        };
                    }
                    if (propName === 'isResolvable') {
                        return () => false;
                    }
                }
                let inner = this.outerType?.[this.propertyName];

                if (!inner) {
                    inner = DynamicType.instance;
                }

                if (inner) {
                    const result = Reflect.get(inner, propName, inner);
                    return result;
                }
            },
            set: (target, name, value, receiver) => {
                //There may be some need to specifically set members on ReferenceType in the future
                // eg: if (Reflect.has(target, name)) {
                //   return Reflect.set(target, name, value, receiver);

                let inner = this.outerType[this.propertyName];

                if (inner) {
                    const result = Reflect.set(inner, name, value, inner);
                    return result;
                }
            }
        });
    }
}


/**
 * Use this class for when there is a binary operator and either the left hand side and/or the right hand side
 * are ReferenceTypes
 */
export class BinaryOperatorReferenceType extends BscType {
    cachedType: BscType;

    constructor(public leftType: BscType, public operator: Token, public rightType: BscType, binaryOpResolver: (lType: BscType, operator: Token, rType: BscType) => BscType) {
        super(operator.text);
        // eslint-disable-next-line no-constructor-return
        return new Proxy(this, {
            get: (target, propName, receiver) => {

                if (propName === '__reflection') {
                    // Cheeky way to get `BinaryOperatorReferenceType` reflection to work
                    return { name: 'BinaryOperatorReferenceType' };
                }

                if (propName === 'leftType') {
                    return leftType;
                }

                if (propName === 'rightType') {
                    return rightType;
                }

                let resultType: BscType = this.cachedType ?? DynamicType.instance;
                if (!this.cachedType) {
                    if ((isAnyReferenceType(this.leftType) && !this.leftType.isResolvable()) ||
                        (isAnyReferenceType(this.rightType) && !this.rightType.isResolvable())
                    ) {
                        if (propName === 'isResolvable') {
                            return () => false;
                        }
                        if (propName === 'getTarget') {
                            return () => undefined;
                        }
                    } else {
                        resultType = binaryOpResolver(this.leftType, this.operator, this.rightType);
                        this.cachedType = resultType;
                    }

                }
                if (resultType) {
                    const result = Reflect.get(resultType, propName, resultType);
                    return result;
                }
            }
        });
    }
}


/**
 * Use this class for when there is a presumable array type that is a referenceType
 */
export class ArrayDefaultTypeReferenceType extends BscType {
    cachedType: BscType;

    constructor(public objType: BscType) {
        super('ArrayDefaultType');
        // eslint-disable-next-line no-constructor-return
        return new Proxy(this, {
            get: (target, propName, receiver) => {

                if (propName === '__reflection') {
                    // Cheeky way to get `ArrayDefaultTypeReferenceType` reflection to work
                    return { name: 'ArrayDefaultTypeReferenceType' };
                }

                if (propName === 'objType') {
                    return objType;
                }

                let resultType: BscType = this.cachedType ?? DynamicType.instance;
                if (!this.cachedType) {
                    if ((isAnyReferenceType(this.objType) && !this.objType.isResolvable())
                    ) {
                        if (propName === 'isResolvable') {
                            return () => false;
                        }
                        if (propName === 'getTarget') {
                            return () => undefined;
                        }
                    } else {
                        if (isArrayType(this.objType)) {
                            resultType = this.objType.defaultType;
                        } else {
                            resultType = DynamicType.instance;
                        }
                        this.cachedType = resultType;
                    }

                }
                if (resultType) {
                    const result = Reflect.get(resultType, propName, resultType);
                    return result;
                }
            }
        });
    }
}

/**
 * Gives an array of all the symbol names that need to be resolved to make the given reference type be resolved
 */
export function getAllRequiredSymbolNames(refType: BscType, namespaceLower?: string): Array<{ name: string; namespacedName?: string }> {
    if (refType.isResolvable()) {
        return [];
    }
    if (isReferenceType(refType)) {
        return [{ name: refType.fullName, namespacedName: namespaceLower ? `${namespaceLower}.${refType.fullName}` : null }];
    }
    if (isTypePropertyReferenceType(refType)) {
        const outer = refType.outerType;
        if (isAnyReferenceType(outer)) {
            return getAllRequiredSymbolNames(outer);
        } else {
            return [];
        }

    }
    if (isArrayDefaultTypeReferenceType(refType)) {
        const objType = refType.objType;
        if (isAnyReferenceType(objType)) {
            return getAllRequiredSymbolNames(objType);
        } else {
            return [];
        }
    }
    if (isBinaryOperatorReferenceType(refType)) {
        const left = refType.leftType;
        const right = refType.rightType;
        const result = [];
        if (isAnyReferenceType(left)) {
            result.push(...getAllRequiredSymbolNames(left, namespaceLower));
        }
        if (isAnyReferenceType(right)) {
            result.push(...getAllRequiredSymbolNames(right, namespaceLower));

        }
        return result;
    }
    return [];
}

1	import type { GetTypeOptions, TypeChainEntry, TypeCompatibilityData } from '../interfaces';
2	import type { GetSymbolTypeOptions, SymbolTypeGetterProvider } from '../SymbolTable';
3	import type { SymbolTypeFlag } from '../SymbolTypeFlag';
4	import { isAnyReferenceType, isArrayDefaultTypeReferenceType, isArrayType, isBinaryOperatorReferenceType, isComponentType, isDynamicType, isReferenceType, isTypePropertyReferenceType } from '../astUtils/reflection';	1✔
5	import { BscType } from './BscType';	1✔
6	import { DynamicType } from './DynamicType';	1✔
7	import { BscTypeKind } from './BscTypeKind';	1✔
8	import type { Token } from '../lexer/Token';
9
10	export type AnyReferenceType = ReferenceType \| TypePropertyReferenceType \| BinaryOperatorReferenceType \| ArrayDefaultTypeReferenceType;
11
12	export function referenceTypeFactory(memberKey: string, fullName, flags: SymbolTypeFlag, tableProvider: SymbolTypeGetterProvider) {	1✔
13	return new ReferenceType(memberKey, fullName, flags, tableProvider);	185,050✔
14	}
15
16	export class ReferenceType extends BscType {	1✔
17
18	/**
19	* ReferenceTypes are used when the actual type may be resolved later from a Symbol table
20	* @param memberKey which key do we use to look up this type in the given table?
21	* @param fullName the full/display name for this type
22	* @param flags is this type available at typetime, runtime, etc.
23	* @param tableProvider function that returns a SymbolTable that we use for the lookup.
24	*/
25	constructor(public memberKey: string, public fullName, public flags: SymbolTypeFlag, private tableProvider: SymbolTypeGetterProvider) {	186,010✔
26	super(memberKey);	186,010✔
27	// eslint-disable-next-line no-constructor-return
28	return new Proxy(this, {	186,010✔
29	get: (target, propName, receiver) => {
30
31	if (propName === '__reflection') {	424,611✔
32	// Cheeky way to get `isReferenceType` reflection to work
33	return this.__reflection;	382,379✔
34	}
35	if (propName === '__identifier') {	42,232✔
36	// Cheeky way to get `isReferenceType` reflection to work
37	return this.__identifier;	38✔
38	}
39	if (propName === 'fullName') {	42,194✔
40	return this.fullName;	734✔
41	}
42	if (propName === 'isResolvable') {	41,460✔
43	return () => {	3,497✔
44	let resultSoFar = this.resolve();	3,497✔
45	while (resultSoFar && isReferenceType(resultSoFar)) {	3,497✔
NEW 46	resultSoFar = (resultSoFar as any).getTarget?.();	×
47	}
48	return !!resultSoFar;	3,497✔
49	};
50	}
51	if (propName === 'getTarget') {	37,963✔
52	return () => {	6,491✔
53	return this.resolve();	6,491✔
54	};
55	}
56	if (propName === 'tableProvider') {	31,472✔
57	return this.tableProvider;	18✔
58	}
59	if (propName === 'isEqual') {	31,454✔
60	//Need to be able to check equality without resolution, because resolution need to check equality
61	//To see if you need to make a UnionType
62	return (targetType: BscType, data?: TypeCompatibilityData) => {	63✔
63	if (!targetType) {	63!
NEW 64	return false;	×
65	}
66	const resolvedType = this.resolve();	63✔
67	let equal = false;	63✔
68	if (resolvedType && !isReferenceType(resolvedType)) {	63✔
69	equal = resolvedType.isEqual(targetType, data);	31✔
70	} else if (isReferenceType(targetType)) {	32✔
71	equal = this.fullName.toLowerCase() === targetType.fullName.toLowerCase() &&	28!
72	(this.tableProvider === targetType.tableProvider \|\|
73	this.tableProvider().name === targetType.tableProvider().name);
74	} else {
75	equal = targetType.isEqual(this, data);	4✔
76	}
77	return equal;	63✔
78	};
79	}
80	if (propName === 'isTypeCompatible') {	31,391✔
81	//Need to be able to check equality without resolution, because resolution need to check equality
82	//To see if you need to make a UnionType
83	return (targetType: BscType, data?: TypeCompatibilityData) => {	81✔
84	if (!targetType) {	81!
NEW 85	return false;	×
86	}
87	if (isDynamicType(targetType)) {	81✔
88	return true;	1✔
89	}
90	const resolvedType = this.resolve();	80✔
91	if (resolvedType && !isReferenceType(resolvedType)) {	80✔
92	return resolvedType.isTypeCompatible(targetType, data);	79✔
93	} else if (isReferenceType(targetType)) {	1!
NEW 94	return this.fullName.toLowerCase() === targetType.fullName.toLowerCase() &&	×
95	this.tableProvider === targetType.tableProvider;
96	}
97	return targetType.isTypeCompatible(this, data);	1✔
98	};
99	}
100
101	//There may be some need to specifically get members on ReferenceType in the future
102	// eg: if (Reflect.has(target, name)) {
103	// return Reflect.get(target, propName, receiver);
104
105	let innerType = this.resolve();	31,310✔
106
107	if (!innerType) {	31,310✔
108	// No real BscType found - we may need to handle some specific cases
109
110	if (propName === 'getMemberType') {	23,600✔
111	// We're looking for a member of a reference type
112	// Since we don't know what type this is, yet, return ReferenceType
113	return (memberName: string, options: GetTypeOptions) => {	943✔
114	const resolvedType = this.resolve();	943✔
115	if (resolvedType) {	943!
NEW 116	return resolvedType.getMemberType(memberName, options);	×
117	}
118	const refLookUp = `${memberName.toLowerCase()}-${options?.flags}`;	943!
119	let memberTypeReference = this.memberTypeReferences.get(refLookUp);	943✔
120	if (memberTypeReference) {	943✔
121	return memberTypeReference;	25✔
122
123	}
124	memberTypeReference = new ReferenceType(memberName, this.makeMemberFullName(memberName), options.flags, this.futureMemberTableProvider);	918✔
125	this.memberTypeReferences.set(refLookUp, memberTypeReference);	918✔
126	return memberTypeReference;	918✔
127	};
128	} else if (propName === 'getCallFuncType') {	22,657✔
129	// We're looking for a callfunc member of a reference type
130	// Since we don't know what type this is, yet, return ReferenceType
131	return (memberName: string, options: GetTypeOptions) => {	1✔
132	const resolvedType = this.resolve();	1✔
133	if (isComponentType(resolvedType)) {	1!
NEW 134	return resolvedType.getCallFuncType(memberName, options);	×
135	}
136	const refLookUp = `${memberName.toLowerCase()}-${options.flags}-callfunc`;	1✔
137	let callFuncMemberTypeReference = this.callFuncMemberTypeReferences.get(refLookUp);	1✔
138	if (callFuncMemberTypeReference) {	1!
NEW 139	return callFuncMemberTypeReference;	×
140
141	}
142	callFuncMemberTypeReference = new ReferenceType(memberName, this.makeMemberFullName(memberName), options.flags, this.futureCallFuncMemberTableProvider);	1✔
143	this.callFuncMemberTypeReferences.set(refLookUp, callFuncMemberTypeReference);	1✔
144	return callFuncMemberTypeReference;	1✔
145	};
146	} else if (propName === 'toString') {	22,656✔
147	// This type was never found
148	// For diagnostics, we should return the expected name of of the type
149	return () => this.fullName;	5,472✔
150	} else if (propName === 'toTypeString') {	17,184!
151	// For transpilation, we should 'dynamic'
NEW 152	return () => 'dynamic';	×
153	} else if (propName === 'returnType') {	17,184✔
154	let propRefType = this.propertyTypeReference.get(propName);	40✔
155	if (!propRefType) {	40✔
156	propRefType = new TypePropertyReferenceType(this, propName);	21✔
157	this.propertyTypeReference.set(propName, propRefType);	21✔
158	}
159	return propRefType;	40✔
160	} else if (propName === 'memberTable') {	17,144✔
161	return this.memberTable;	10✔
162	} else if (propName === 'getMemberTable') {	17,134✔
163	return () => {	5✔
164	return this.memberTable;	5✔
165	};
166	} else if (propName === 'callFuncTable') {	17,129!
NEW 167	return (this as any).callFuncMemberTable;	×
168	} else if (propName === 'getCallFuncTable') {	17,129!
NEW 169	return () => {	×
NEW 170	return (this as any).callFuncMemberTable;	×
171	};
172	} else if (propName === 'isTypeCompatible') {	17,129!
NEW 173	return (targetType: BscType) => {	×
NEW 174	return isDynamicType(targetType);	×
175	};
176	} else if (propName === 'isEqual') {	17,129!
NEW 177	return (targetType: BscType) => {	×
NEW 178	if (isReferenceType(targetType)) {	×
NEW 179	return this.fullName.toLowerCase() === targetType.toString().toLowerCase() &&	×
180	this.tableProvider() === targetType.tableProvider();
181	}
NEW 182	return false;	×
183	};
184	} else if (propName === 'addBuiltInInterfaces') {	17,129✔
185	// this is an unknown type. There is no use in adding built in interfaces
186	// return no-op function
187	return () => { };	21✔
188	} else if (propName === 'hasAddedBuiltInInterfaces') {	17,108!
189	// this is an unknown type. There is no use in adding built in interfaces
NEW 190	return true;	×
191	}
192	}
193
194	if (!innerType) {	24,818✔
195	innerType = DynamicType.instance;	17,108✔
196	}
197	const result = Reflect.get(innerType, propName, innerType);	24,818✔
198	return result;	24,818✔
199	},
200	set: (target, name, value, receiver) => {
201	//There may be some need to specifically set members on ReferenceType in the future
202	// eg: if (Reflect.has(target, name)) {
203	// return Reflect.set(target, name, value, receiver);
204
205	let innerType = this.resolve();	412✔
206
207	// Look for circular references
208	if (!innerType \|\| this.referenceChain.has(innerType)) {	412!
NEW 209	return false;	×
210	}
211	const result = Reflect.set(innerType, name, value, innerType);	412✔
212	this.referenceChain.clear();	412✔
213	return result;	412✔
214	}
215	});
216	}
217
218	public readonly kind = BscTypeKind.ReferenceType;	186,010✔
219
220	/**
221	* Resolves the type based on the original name and the table provider
222	*/
223	private resolve(): BscType {
224	const symbolTable = this.tableProvider();	53,569✔
225	if (!symbolTable) {	53,569✔
226	return;	10✔
227	}
228	// Look for circular references
229	let resolvedType = symbolTable.getSymbolType(this.memberKey, { flags: this.flags, onlyCacheResolvedTypes: true });	53,559✔
230	if (!resolvedType) {	53,559✔
231	// could not find this member
232	return;	36,178✔
233	}
234	if (isAnyReferenceType(resolvedType)) {	17,381✔
235	// If this is a referenceType, keep digging down until we have a non reference Type.
236	while (resolvedType && isAnyReferenceType(resolvedType)) {	723✔
237	if (this.referenceChain.has(resolvedType)) {	723✔
238	// this is a circular reference
239	this.circRefCount++;	39✔
240	}
241	if (this.circRefCount > 1) {	723✔
242	//It is possible that we could properly resolve the case that one reference points to itself
243	//see test: '[Scope][symbolTable lookups with enhanced typing][finds correct class field type with default value enums are used]
244	return;	33✔
245	}
246	this.referenceChain.add(resolvedType);	690✔
247	resolvedType = (resolvedType as any).getTarget?.();	690!
248	}
249	this.tableProvider().setCachedType(this.memberKey, { type: resolvedType }, { flags: this.flags });	690✔
250	}
251
252	if (resolvedType && !isAnyReferenceType(resolvedType)) {	17,348✔
253	this.circRefCount = 0;	16,661✔
254	this.referenceChain.clear();	16,661✔
255	}
256	return resolvedType;	17,348✔
257	}
258
259	get __reflection() {
260	return { name: 'ReferenceType' };	382,419✔
261	}
262
263	makeMemberFullName(memberName: string) {
264	return this.fullName + '.' + memberName;	919✔
265	}
266	private circRefCount = 0;	186,010✔
267
268	private referenceChain = new Set<BscType>();	186,010✔
269
270	private propertyTypeReference = new Map<string, TypePropertyReferenceType>();	186,010✔
271
272	private memberTypeReferences = new Map<string, ReferenceType>();	186,010✔
273	private callFuncMemberTypeReferences = new Map<string, ReferenceType>();	186,010✔
274
275	private futureMemberTableProvider = () => {	186,010✔
276	return {	10,772✔
277	name: `FutureMemberTableProvider: '${this.__identifier}'`,
278	getSymbolType: (innerName: string, innerOptions: GetTypeOptions) => {
279	const resolvedType = this.resolve();	10,094✔
280	if (resolvedType) {	10,094✔
281	return resolvedType.getMemberType(innerName, innerOptions);	6,831✔
282	}
283	},
284	setCachedType: (innerName: string, innerResolvedTypeCacheEntry: TypeChainEntry, options: GetSymbolTypeOptions) => {
285	const resolvedType = this.resolve();	678✔
286	if (resolvedType) {	678!
287	resolvedType.memberTable.setCachedType(innerName, innerResolvedTypeCacheEntry, options);	678✔
288	}
289	}
290	};
291	};
292
293	private futureCallFuncMemberTableProvider = () => {	186,010✔
NEW 294	return {	×
295	name: `FutureCallFuncMemberTableProvider: '${this.__identifier}'`,
296	getSymbolType: (innerName: string, innerOptions: GetTypeOptions) => {
NEW 297	const resolvedType = this.resolve();	×
NEW 298	if (isComponentType(resolvedType)) {	×
NEW 299	return resolvedType.getCallFuncType(innerName, innerOptions);	×
300	}
301	},
302	setCachedType: (innerName: string, innerResolvedTypeCacheEntry: TypeChainEntry, options: GetSymbolTypeOptions) => {
NEW 303	const resolvedType = this.resolve();	×
NEW 304	if (isComponentType(resolvedType)) {	×
NEW 305	resolvedType.getCallFuncTable().setCachedType(innerName, innerResolvedTypeCacheEntry, options);	×
306	}
307	}
308	};
309	};
310	}
311
312	/**
313	* Use this class for when you need to reference a property of a BscType, and that property is also a BscType,
314	* Especially when the instance with the property may not have been instantiated/discovered yet
315	*
316	* For Example, FunctionType.returnType --- if the FunctionExpression has not been walked yet, it will be a ReferenceType
317	* if we just access .returnType on a ReferenceType that doesn't have access to an actual FunctionType yet, .returnType will be undefined
318	* So when we use this class, it maintains that reference to a potential ReferenceType, and this class will change from
319	* returning undefined to the ACTUAL .returnType when the ReferenceType can be resolved.
320	*
321	* This is really cool. It's like programming with time-travel.
322	*/
323	export class TypePropertyReferenceType extends BscType {	1✔
324	constructor(public outerType: BscType, public propertyName: string) {	69✔
325	super(propertyName);	69✔
326	// eslint-disable-next-line no-constructor-return
327	return new Proxy(this, {	69✔
328	get: (target, propName, receiver) => {
329
330	if (propName === '__reflection') {	305✔
331	// Cheeky way to get `isTypePropertyReferenceType` reflection to work
332	return { name: 'TypePropertyReferenceType' };	53✔
333	}
334
335	if (propName === 'outerType') {	252!
NEW 336	return outerType;	×
337	}
338
339	if (isAnyReferenceType(this.outerType) && !this.outerType.isResolvable()) {	252✔
340	if (propName === 'getMemberType') {	35✔
341	//If we're calling `getMemberType()`, we need it to proxy to using the actual symbol table
342	//So if that symbol is ever populated, the correct type is passed through
343	return (memberName: string, options: GetSymbolTypeOptions) => {	11✔
344	const fullMemberName = this.outerType.toString() + '.' + memberName;	11✔
345	return new ReferenceType(memberName, fullMemberName, options.flags, () => {	11✔
346	return {	21✔
347	name: `TypePropertyReferenceType : '${fullMemberName}'`,
348	getSymbolType: (innerName: string, innerOptions: GetTypeOptions) => {
349	return this.outerType?.[this.propertyName]?.getMemberType(innerName, innerOptions);	21!
350	},
351	setCachedType: (innerName: string, innerTypeCacheEntry: TypeChainEntry, innerOptions: GetTypeOptions) => {
NEW 352	return this.outerType?.[this.propertyName]?.memberTable.setCachedType(innerName, innerTypeCacheEntry, innerOptions);	×
353	}
354	};
355	});
356	};
357	}
358	if (propName === 'isResolvable') {	24✔
359	return () => false;	3✔
360	}
361	}
362	let inner = this.outerType?.[this.propertyName];	238✔
363
364	if (!inner) {	238✔
365	inner = DynamicType.instance;	41✔
366	}
367
368	if (inner) {	238!
369	const result = Reflect.get(inner, propName, inner);	238✔
370	return result;	238✔
371	}
372	},
373	set: (target, name, value, receiver) => {
374	//There may be some need to specifically set members on ReferenceType in the future
375	// eg: if (Reflect.has(target, name)) {
376	// return Reflect.set(target, name, value, receiver);
377
378	let inner = this.outerType[this.propertyName];	23✔
379
380	if (inner) {	23!
381	const result = Reflect.set(inner, name, value, inner);	23✔
382	return result;	23✔
383	}
384	}
385	});
386	}
387	}
388
389
390	/**
391	* Use this class for when there is a binary operator and either the left hand side and/or the right hand side
392	* are ReferenceTypes
393	*/
394	export class BinaryOperatorReferenceType extends BscType {	1✔
395	cachedType: BscType;
396
397	constructor(public leftType: BscType, public operator: Token, public rightType: BscType, binaryOpResolver: (lType: BscType, operator: Token, rType: BscType) => BscType) {	31✔
398	super(operator.text);	31✔
399	// eslint-disable-next-line no-constructor-return
400	return new Proxy(this, {	31✔
401	get: (target, propName, receiver) => {
402
403	if (propName === '__reflection') {	130✔
404	// Cheeky way to get `BinaryOperatorReferenceType` reflection to work
405	return { name: 'BinaryOperatorReferenceType' };	78✔
406	}
407
408	if (propName === 'leftType') {	52✔
409	return leftType;	6✔
410	}
411
412	if (propName === 'rightType') {	46✔
413	return rightType;	6✔
414	}
415
416	let resultType: BscType = this.cachedType ?? DynamicType.instance;	40✔
417	if (!this.cachedType) {	40✔
418	if ((isAnyReferenceType(this.leftType) && !this.leftType.isResolvable()) \|\|	26✔
419	(isAnyReferenceType(this.rightType) && !this.rightType.isResolvable())
420	) {
421	if (propName === 'isResolvable') {	24✔
422	return () => false;	13✔
423	}
424	if (propName === 'getTarget') {	11✔
425	return () => undefined;	2✔
426	}
427	} else {
428	resultType = binaryOpResolver(this.leftType, this.operator, this.rightType);	2✔
429	this.cachedType = resultType;	2✔
430	}
431
432	}
433	if (resultType) {	25!
434	const result = Reflect.get(resultType, propName, resultType);	25✔
435	return result;	25✔
436	}
437	}
438	});
439	}
440	}
441
442
443	/**
444	* Use this class for when there is a presumable array type that is a referenceType
445	*/
446	export class ArrayDefaultTypeReferenceType extends BscType {	1✔
447	cachedType: BscType;
448
449	constructor(public objType: BscType) {	2✔
450	super('ArrayDefaultType');	2✔
451	// eslint-disable-next-line no-constructor-return
452	return new Proxy(this, {	2✔
453	get: (target, propName, receiver) => {
454
455	if (propName === '__reflection') {	30✔
456	// Cheeky way to get `ArrayDefaultTypeReferenceType` reflection to work
457	return { name: 'ArrayDefaultTypeReferenceType' };	19✔
458	}
459
460	if (propName === 'objType') {	11!
NEW 461	return objType;	×
462	}
463
464	let resultType: BscType = this.cachedType ?? DynamicType.instance;	11✔
465	if (!this.cachedType) {	11✔
466	if ((isAnyReferenceType(this.objType) && !this.objType.isResolvable())	4✔
467	) {
468	if (propName === 'isResolvable') {	2✔
469	return () => false;	1✔
470	}
471	if (propName === 'getTarget') {	1!
NEW 472	return () => undefined;	×
473	}
474	} else {
475	if (isArrayType(this.objType)) {	2!
476	resultType = this.objType.defaultType;	2✔
477	} else {
NEW 478	resultType = DynamicType.instance;	×
479	}
480	this.cachedType = resultType;	2✔
481	}
482
483	}
484	if (resultType) {	10!
485	const result = Reflect.get(resultType, propName, resultType);	10✔
486	return result;	10✔
487	}
488	}
489	});
490	}
491	}
492
493	/**
494	* Gives an array of all the symbol names that need to be resolved to make the given reference type be resolved
495	*/
496	export function getAllRequiredSymbolNames(refType: BscType, namespaceLower?: string): Array<{ name: string; namespacedName?: string }> {	1✔
497	if (refType.isResolvable()) {	75✔
498	return [];	8✔
499	}
500	if (isReferenceType(refType)) {	67✔
501	return [{ name: refType.fullName, namespacedName: namespaceLower ? `${namespaceLower}.${refType.fullName}` : null }];	61✔
502	}
503	if (isTypePropertyReferenceType(refType)) {	6!
NEW 504	const outer = refType.outerType;	×
NEW 505	if (isAnyReferenceType(outer)) {	×
NEW 506	return getAllRequiredSymbolNames(outer);	×
507	} else {
NEW 508	return [];	×
509	}
510
511	}
512	if (isArrayDefaultTypeReferenceType(refType)) {	6!
NEW 513	const objType = refType.objType;	×
NEW 514	if (isAnyReferenceType(objType)) {	×
NEW 515	return getAllRequiredSymbolNames(objType);	×
516	} else {
NEW 517	return [];	×
518	}
519	}
520	if (isBinaryOperatorReferenceType(refType)) {	6!
521	const left = refType.leftType;	6✔
522	const right = refType.rightType;	6✔
523	const result = [];	6✔
524	if (isAnyReferenceType(left)) {	6✔
525	result.push(...getAllRequiredSymbolNames(left, namespaceLower));	4✔
526	}
527	if (isAnyReferenceType(right)) {	6!
528	result.push(...getAllRequiredSymbolNames(right, namespaceLower));	6✔
529
530	}
531	return result;	6✔
532	}
NEW 533	return [];	×
534	}

rokucommunity / brighterscript / #13211

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