brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.50

package/dist/types/ReferenceType.js

@@ -0,0 +1,720 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllRequiredSymbolNames = exports.ReferenceTypeWithDefault = exports.ParamTypeFromValueReferenceType = exports.ArrayDefaultTypeReferenceType = exports.BinaryOperatorReferenceType = exports.TypePropertyReferenceType = exports.ReferenceType = exports.referenceTypeFactory = void 0;
+const reflection_1 = require("../astUtils/reflection");
+const BscType_1 = require("./BscType");
+const DynamicType_1 = require("./DynamicType");
+const BscTypeKind_1 = require("./BscTypeKind");
+const util_1 = require("../util");
+function referenceTypeFactory(memberKey, fullName, flags, tableProvider) {
+    return new ReferenceType(memberKey, fullName, flags, tableProvider);
+}
+exports.referenceTypeFactory = referenceTypeFactory;
+class ReferenceType extends BscType_1.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(memberKey, fullName, flags, tableProvider) {
+        super(memberKey);
+        this.memberKey = memberKey;
+        this.fullName = fullName;
+        this.flags = flags;
+        this.tableProvider = tableProvider;
+        this.kind = BscTypeKind_1.BscTypeKind.ReferenceType;
+        this.circRefCount = 0;
+        this.referenceChain = new Set();
+        this.propertyTypeReference = new Map();
+        this.memberTypeReferences = new Map();
+        this.callFuncMemberTypeReferences = new Map();
+        this.futureMemberTableProvider = () => {
+            return {
+                name: `FutureMemberTableProvider: '${this.__identifier}'`,
+                getSymbolType: (innerName, innerOptions) => {
+                    const resolvedType = this.resolve();
+                    if (resolvedType) {
+                        return resolvedType.getMemberType(innerName, innerOptions);
+                    }
+                },
+                setCachedType: (innerName, innerResolvedTypeCacheEntry, options) => {
+                    const resolvedType = this.resolve();
+                    if (resolvedType) {
+                        resolvedType.memberTable.setCachedType(innerName, innerResolvedTypeCacheEntry, options);
+                    }
+                },
+                addSibling: (symbolTable) => {
+                    var _a, _b;
+                    const resolvedType = this.resolve();
+                    if (resolvedType) {
+                        (_b = (_a = resolvedType.memberTable) === null || _a === void 0 ? void 0 : _a.addSibling) === null || _b === void 0 ? void 0 : _b.call(_a, symbolTable);
+                    }
+                }
+            };
+        };
+        this.futureCallFuncMemberTableProvider = () => {
+            return {
+                name: `FutureCallFuncMemberTableProvider: '${this.__identifier}'`,
+                getSymbolType: (innerName, innerOptions) => {
+                    const resolvedType = this.resolve();
+                    if ((0, reflection_1.isComponentType)(resolvedType)) {
+                        return resolvedType.getCallFuncType(innerName, innerOptions);
+                    }
+                },
+                setCachedType: (innerName, innerResolvedTypeCacheEntry, options) => {
+                    const resolvedType = this.resolve();
+                    if ((0, reflection_1.isComponentType)(resolvedType)) {
+                        resolvedType.getCallFuncTable().setCachedType(innerName, innerResolvedTypeCacheEntry, options);
+                    }
+                },
+                addSibling: (symbolTable) => {
+                    var _a, _b;
+                    const resolvedType = this.resolve();
+                    if ((0, reflection_1.isComponentType)(resolvedType)) {
+                        (_b = (_a = resolvedType.getCallFuncTable()) === null || _a === void 0 ? void 0 : _a.addSibling) === null || _b === void 0 ? void 0 : _b.call(_a, symbolTable);
+                    }
+                }
+            };
+        };
+        // 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 () => {
+                        var _a, _b;
+                        let resultSoFar = this.resolve();
+                        while (resultSoFar && (0, reflection_1.isReferenceType)(resultSoFar)) {
+                            resultSoFar = (_b = (_a = resultSoFar).getTarget) === null || _b === void 0 ? void 0 : _b.call(_a);
+                        }
+                        return !!resultSoFar;
+                    };
+                }
+                if (propName === 'getCircularReferenceInfo') {
+                    return (stopAtTypes = []) => {
+                        return this.getCircularReferenceInfo(stopAtTypes);
+                    };
+                }
+                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, data) => {
+                        if (!targetType) {
+                            return false;
+                        }
+                        const resolvedType = this.resolve();
+                        let equal = false;
+                        if (resolvedType && !(0, reflection_1.isReferenceType)(resolvedType)) {
+                            equal = resolvedType.isEqual(targetType, data);
+                        }
+                        else if ((0, reflection_1.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, data) => {
+                        if (!targetType) {
+                            return false;
+                        }
+                        if ((0, reflection_1.isDynamicType)(targetType)) {
+                            return true;
+                        }
+                        const resolvedType = this.resolve();
+                        if (resolvedType && !(0, reflection_1.isReferenceType)(resolvedType)) {
+                            return resolvedType.isTypeCompatible(targetType, data);
+                        }
+                        else if ((0, reflection_1.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, options) => {
+                            const resolvedType = this.resolve();
+                            if (resolvedType) {
+                                return resolvedType.getMemberType(memberName, options);
+                            }
+                            const refLookUp = `${memberName.toLowerCase()}-${options === null || options === void 0 ? void 0 : 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, options) => {
+                            const resolvedType = this.resolve();
+                            if ((0, reflection_1.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.callFuncMemberTable;
+                    }
+                    else if (propName === 'getCallFuncTable') {
+                        return () => {
+                            return this.callFuncMemberTable;
+                        };
+                    }
+                    else if (propName === 'isTypeCompatible') {
+                        return (targetType) => {
+                            return (0, reflection_1.isDynamicType)(targetType);
+                        };
+                    }
+                    else if (propName === 'isEqual') {
+                        return (targetType) => {
+                            if ((0, reflection_1.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;
+                    }
+                    else if (propName === 'isBuiltIn') {
+                        return false;
+                    }
+                }
+                if (!innerType) {
+                    innerType = DynamicType_1.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)) {
+                    if (name === 'hasAddedBuiltInInterfaces') {
+                        // ignore this
+                        return true;
+                    }
+                    console.log(`Proxy set error`, name, value, innerType);
+                    const error = new Error(`Reference Type Proxy set error: ${{ memberKey: memberKey, name: name, value: value }}`);
+                    console.log(error.stack);
+                    return false;
+                }
+                const result = Reflect.set(innerType, name, value, innerType);
+                this.referenceChain.clear();
+                return result;
+            }
+        });
+    }
+    getTarget() {
+        return this.resolve();
+    }
+    /**
+     * Resolves the type based on the original name and the table provider
+     */
+    resolve() {
+        var _a;
+        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 ((0, reflection_1.isAnyReferenceType)(resolvedType)) {
+            // If this is a referenceType, keep digging down until we have a non reference Type.
+            while (resolvedType && (0, reflection_1.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 = (_a = resolvedType === null || resolvedType === void 0 ? void 0 : resolvedType.getTarget) === null || _a === void 0 ? void 0 : _a.call(resolvedType);
+            }
+            this.tableProvider().setCachedType(this.memberKey, { type: resolvedType }, { flags: this.flags });
+        }
+        if (resolvedType && !(0, reflection_1.isAnyReferenceType)(resolvedType)) {
+            this.circRefCount = 0;
+            this.referenceChain.clear();
+        }
+        return resolvedType;
+    }
+    get __reflection() {
+        return { name: 'ReferenceType' };
+    }
+    makeMemberFullName(memberName) {
+        return this.fullName + '.' + memberName;
+    }
+    getCircularReferenceInfo(stopAtTypes = []) {
+        this.resolve();
+        const isCircRef = this.circRefCount > 1;
+        const referenceChainNames = [];
+        stopAtTypes.push(this);
+        if (isCircRef) {
+            referenceChainNames.push(this.fullName);
+            for (const chainItem of this.referenceChain) {
+                if (!(0, reflection_1.isReferenceType)(chainItem) || chainItem === this) {
+                    continue;
+                }
+                if (stopAtTypes.map(t => t.fullName).includes(chainItem.fullName)) {
+                    break;
+                }
+                const chainItemCircInfo = chainItem.getCircularReferenceInfo(stopAtTypes);
+                referenceChainNames.push(...chainItemCircInfo.referenceChainNames);
+            }
+        }
+        return { isCircularReference: isCircRef, referenceChainNames: referenceChainNames };
+    }
+}
+exports.ReferenceType = ReferenceType;
+/**
+ * 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.
+ */
+class TypePropertyReferenceType extends BscType_1.BscType {
+    constructor(outerType, propertyName) {
+        super(propertyName);
+        this.outerType = outerType;
+        this.propertyName = 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 (propName === 'getTarget') {
+                    return () => {
+                        return this.getTarget();
+                    };
+                }
+                if (propName === 'isResolvable') {
+                    return () => {
+                        var _a;
+                        return !!((0, reflection_1.isAnyReferenceType)(this.outerType) ? this.outerType.getTarget() : (_a = this.outerType) === null || _a === void 0 ? void 0 : _a.isResolvable());
+                    };
+                }
+                if ((0, reflection_1.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, options) => {
+                            const fullMemberName = this.outerType.toString() + '.' + memberName;
+                            return new ReferenceType(memberName, fullMemberName, options.flags, () => {
+                                return {
+                                    name: `TypePropertyReferenceType : '${fullMemberName}'`,
+                                    getSymbolType: (innerName, innerOptions) => {
+                                        var _a, _b;
+                                        return (_b = (_a = this.outerType) === null || _a === void 0 ? void 0 : _a[this.propertyName]) === null || _b === void 0 ? void 0 : _b.getMemberType(innerName, innerOptions);
+                                    },
+                                    setCachedType: (innerName, innerTypeCacheEntry, innerOptions) => {
+                                        var _a, _b;
+                                        return (_b = (_a = this.outerType) === null || _a === void 0 ? void 0 : _a[this.propertyName]) === null || _b === void 0 ? void 0 : _b.memberTable.setCachedType(innerName, innerTypeCacheEntry, innerOptions);
+                                    },
+                                    addSibling: (symbolTable) => {
+                                        var _a, _b, _c, _d;
+                                        return (_d = (_c = (_b = (_a = this.outerType) === null || _a === void 0 ? void 0 : _a[this.propertyName]) === null || _b === void 0 ? void 0 : _b.memberTable) === null || _c === void 0 ? void 0 : _c.addSibling) === null || _d === void 0 ? void 0 : _d.call(_c, symbolTable);
+                                    }
+                                };
+                            });
+                        };
+                    }
+                    if (propName === 'isResolvable') {
+                        return () => false;
+                    }
+                }
+                let inner = this.getTarget();
+                if (!inner) {
+                    inner = DynamicType_1.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;
+                }
+            }
+        });
+    }
+    getTarget() {
+        var _a;
+        let actualOuterType = this.outerType;
+        if ((0, reflection_1.isAnyReferenceType)(this.outerType)) {
+            if (this.outerType.isResolvable()) {
+                actualOuterType = (_a = this.outerType) === null || _a === void 0 ? void 0 : _a.getTarget();
+            }
+        }
+        return actualOuterType === null || actualOuterType === void 0 ? void 0 : actualOuterType[this.propertyName];
+    }
+}
+exports.TypePropertyReferenceType = TypePropertyReferenceType;
+/**
+ * Use this class for when there is a binary operator and either the left hand side and/or the right hand side
+ * are ReferenceTypes
+ */
+class BinaryOperatorReferenceType extends BscType_1.BscType {
+    constructor(leftType, operator, rightType, binaryOpResolver) {
+        super(operator.text);
+        this.leftType = leftType;
+        this.operator = operator;
+        this.rightType = rightType;
+        // eslint-disable-next-line no-constructor-return
+        return new Proxy(this, {
+            get: (target, propName, receiver) => {
+                var _a, _b;
+                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 = (_a = this.cachedType) !== null && _a !== void 0 ? _a : DynamicType_1.DynamicType.instance;
+                if (!this.cachedType) {
+                    if (((0, reflection_1.isAnyReferenceType)(this.leftType) && !this.leftType.isResolvable()) ||
+                        ((0, reflection_1.isAnyReferenceType)(this.rightType) && !this.rightType.isResolvable())) {
+                        if (propName === 'isResolvable') {
+                            return () => false;
+                        }
+                        if (propName === 'getTarget') {
+                            return () => undefined;
+                        }
+                    }
+                    else {
+                        resultType = (_b = binaryOpResolver(this.leftType, this.operator, this.rightType)) !== null && _b !== void 0 ? _b : DynamicType_1.DynamicType.instance;
+                        this.cachedType = resultType;
+                    }
+                }
+                if (resultType) {
+                    const result = Reflect.get(resultType, propName, resultType);
+                    return result;
+                }
+            }
+        });
+    }
+}
+exports.BinaryOperatorReferenceType = BinaryOperatorReferenceType;
+/**
+ * Use this class for when there is a presumable array type that is a referenceType
+ */
+class ArrayDefaultTypeReferenceType extends BscType_1.BscType {
+    constructor(objType) {
+        super('ArrayDefaultType');
+        this.objType = objType;
+        // 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;
+                }
+                if (propName === 'getTarget') {
+                    return () => {
+                        if ((0, reflection_1.isReferenceType)(this.objType)) {
+                            this.objType.getTarget();
+                        }
+                        return this.objType;
+                    };
+                }
+                let resultType = DynamicType_1.DynamicType.instance;
+                if (((0, reflection_1.isAnyReferenceType)(this.objType) && !this.objType.isResolvable())) {
+                    if (propName === 'isResolvable') {
+                        return () => false;
+                    }
+                    if (propName === 'getTarget') {
+                        return () => undefined;
+                    }
+                }
+                else {
+                    resultType = util_1.util.getIteratorDefaultType(this.objType);
+                }
+                if (resultType) {
+                    const result = Reflect.get(resultType, propName, resultType);
+                    return result;
+                }
+            }
+        });
+    }
+}
+exports.ArrayDefaultTypeReferenceType = ArrayDefaultTypeReferenceType;
+/**
+ * Used for when a Param's initial value is unresolved
+ * Generally, this will be resolved later *except* for Enum
+ * Enum Types will have an initial value of an EnumMemberType, but the param
+ * should be an EnumType
+ */
+class ParamTypeFromValueReferenceType extends BscType_1.BscType {
+    constructor(objType) {
+        super('ParamInitialValueType');
+        this.objType = objType;
+        // eslint-disable-next-line no-constructor-return
+        return new Proxy(this, {
+            get: (target, propName, receiver) => {
+                var _a;
+                if (propName === '__reflection') {
+                    // Cheeky way to get reflection to work
+                    return { name: 'ParamTypeFromValueReferenceType' };
+                }
+                if (propName === 'objType') {
+                    return objType;
+                }
+                if (propName === 'getTarget') {
+                    return () => {
+                        if (this.cachedType) {
+                            return this.cachedType;
+                        }
+                        if ((0, reflection_1.isReferenceType)(this.objType)) {
+                            this.objType.getTarget();
+                        }
+                        return this.objType;
+                    };
+                }
+                let resultType = (_a = this.cachedType) !== null && _a !== void 0 ? _a : DynamicType_1.DynamicType.instance;
+                if (!this.cachedType) {
+                    if (((0, reflection_1.isAnyReferenceType)(this.objType) && !this.objType.isResolvable())) {
+                        if (propName === 'isResolvable') {
+                            return () => false;
+                        }
+                        if (propName === 'getTarget') {
+                            return () => undefined;
+                        }
+                    }
+                    else {
+                        resultType = util_1.util.getDefaultTypeFromValueType(this.objType);
+                        this.cachedType = resultType;
+                    }
+                }
+                if (resultType) {
+                    const result = Reflect.get(resultType, propName, resultType);
+                    return result;
+                }
+            }
+        });
+    }
+}
+exports.ParamTypeFromValueReferenceType = ParamTypeFromValueReferenceType;
+/**
+ * Used when an IntersectionType has at least one member that may have default dynamic members.
+ * If the inner type is not resolvable, this type will resolve to the given type instead.
+ * @example
+ * ```brighterscript
+ *   interface HasAge
+ *       age as integer
+ *   end interface
+ *
+ *   type foo = HasAge and roAssociativeArray
+ *
+ *   sub useFoo(f as foo)
+ *       print f.age ' f.age is an integer
+ *       print f.doesExist("key") ' will result in a boolean, from roAssociativeArray
+ *       print f.someKey ' no idea - so this is dynamic, and will not cause a validation error
+ *   end sub
+ * ```
+ */
+class ReferenceTypeWithDefault extends BscType_1.BscType {
+    constructor(baseType, defaultType) {
+        super('ReferenceTypeWithDefault');
+        this.baseType = baseType;
+        this.defaultType = defaultType;
+        // eslint-disable-next-line no-constructor-return
+        return new Proxy(this, {
+            get: (target, propName, receiver) => {
+                if (propName === '__reflection') {
+                    // Cheeky way to get `isReferenceTypeWithDefault` reflection to work
+                    return { name: 'ReferenceTypeWithDefault' };
+                }
+                if (propName === 'isResolvable') {
+                    return () => {
+                        return true;
+                    };
+                }
+                let innerType = this.getTarget();
+                if (!innerType) {
+                    innerType = this.defaultType;
+                }
+                if (innerType) {
+                    const result = Reflect.get(innerType, propName, innerType);
+                    return result;
+                }
+            }
+        });
+    }
+    getTarget() {
+        var _a;
+        if ((0, reflection_1.isAnyReferenceType)(this.baseType)) {
+            if (this.baseType.isResolvable()) {
+                return (_a = this.baseType) === null || _a === void 0 ? void 0 : _a.getTarget();
+            }
+        }
+        return this.baseType;
+    }
+}
+exports.ReferenceTypeWithDefault = ReferenceTypeWithDefault;
+/**
+ * Gives an array of all the symbol names that need to be resolved to make the given reference type be resolved
+ */
+function getAllRequiredSymbolNames(refType, namespaceLower) {
+    if (refType.isResolvable()) {
+        return [];
+    }
+    if ((0, reflection_1.isReferenceType)(refType)) {
+        return [{ name: refType.fullName, namespacedName: namespaceLower ? `${namespaceLower}.${refType.fullName}` : null }];
+    }
+    if ((0, reflection_1.isTypePropertyReferenceType)(refType)) {
+        const outer = refType.outerType;
+        if ((0, reflection_1.isAnyReferenceType)(outer)) {
+            return getAllRequiredSymbolNames(outer);
+        }
+        else {
+            return [];
+        }
+    }
+    if ((0, reflection_1.isArrayDefaultTypeReferenceType)(refType)) {
+        const objType = refType.objType;
+        if ((0, reflection_1.isAnyReferenceType)(objType)) {
+            return getAllRequiredSymbolNames(objType);
+        }
+        else {
+            return [];
+        }
+    }
+    if ((0, reflection_1.isBinaryOperatorReferenceType)(refType)) {
+        const left = refType.leftType;
+        const right = refType.rightType;
+        const result = [];
+        if ((0, reflection_1.isAnyReferenceType)(left)) {
+            result.push(...getAllRequiredSymbolNames(left, namespaceLower));
+        }
+        if ((0, reflection_1.isAnyReferenceType)(right)) {
+            result.push(...getAllRequiredSymbolNames(right, namespaceLower));
+        }
+        return result;
+    }
+    if ((0, reflection_1.isParamTypeFromValueReferenceType)(refType)) {
+        const objType = refType.objType;
+        if ((0, reflection_1.isAnyReferenceType)(objType)) {
+            return getAllRequiredSymbolNames(objType);
+        }
+        else {
+            return [];
+        }
+    }
+    return [];
+}
+exports.getAllRequiredSymbolNames = getAllRequiredSymbolNames;
+//# sourceMappingURL=ReferenceType.js.map