brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.51

package/dist/CrossScopeValidator.js

@@ -0,0 +1,650 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrossScopeValidator = exports.ProvidedNode = void 0;
+const DiagnosticMessages_1 = require("./DiagnosticMessages");
+const util_1 = require("./util");
+const reflection_1 = require("./astUtils/reflection");
+const ReferenceType_1 = require("./types/ReferenceType");
+const BscTypeKind_1 = require("./types/BscTypeKind");
+const helpers_1 = require("./types/helpers");
+const Parser_1 = require("./parser/Parser");
+const globalCallables_1 = require("./globalCallables");
+const CrossScopeValidatorDiagnosticTag = 'CrossScopeValidator';
+class ProvidedNode {
+    constructor(key = '', componentsMap) {
+        this.key = key;
+        this.componentsMap = componentsMap;
+        this.namespaces = new Map();
+        this.symbols = new Map();
+    }
+    getSymbolByKey(symbolKeys) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.getSymbol(symbolKeys.namespacedKey)) !== null && _a !== void 0 ? _a : this.getSymbol(symbolKeys.key)) !== null && _b !== void 0 ? _b : this.getSymbol(symbolKeys.namespacedPotentialTypeKey)) !== null && _c !== void 0 ? _c : this.getSymbol(symbolKeys.potentialTypeKey);
+    }
+    getSymbol(symbolName) {
+        var _a;
+        if (!symbolName) {
+            return;
+        }
+        const lowerSymbolName = symbolName.toLowerCase();
+        if ((_a = this.componentsMap) === null || _a === void 0 ? void 0 : _a.has(lowerSymbolName)) {
+            return this.componentsMap.get(lowerSymbolName);
+        }
+        let lowerSymbolNameParts = lowerSymbolName.split('.');
+        return this.getSymbolByNameParts(lowerSymbolNameParts, this);
+    }
+    getNamespace(namespaceName) {
+        let lowerSymbolNameParts = namespaceName.toLowerCase().split('.');
+        return this.getNamespaceByNameParts(lowerSymbolNameParts);
+    }
+    getSymbolByNameParts(lowerSymbolNameParts, root) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
+        const first = lowerSymbolNameParts === null || lowerSymbolNameParts === void 0 ? void 0 : lowerSymbolNameParts[0];
+        const rest = lowerSymbolNameParts.slice(1);
+        if (!first) {
+            return;
+        }
+        if (this.symbols.has(first)) {
+            let result = this.symbols.get(first);
+            let currentType = result.symbol.type;
+            for (const namePart of rest) {
+                if ((0, reflection_1.isTypedFunctionType)(currentType)) {
+                    const returnType = currentType.returnType;
+                    if (returnType.isResolvable()) {
+                        currentType = returnType;
+                    }
+                    else if ((0, reflection_1.isReferenceType)(returnType)) {
+                        const fullName = returnType.fullName;
+                        if (fullName.includes('.')) {
+                            currentType = (_b = (_a = root.getSymbol(fullName)) === null || _a === void 0 ? void 0 : _a.symbol) === null || _b === void 0 ? void 0 : _b.type;
+                        }
+                        else {
+                            currentType = (_e = (_d = (_c = this.getSymbol(fullName)) === null || _c === void 0 ? void 0 : _c.symbol) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : (_g = (_f = root.getSymbol(fullName)) === null || _f === void 0 ? void 0 : _f.symbol) === null || _g === void 0 ? void 0 : _g.type;
+                        }
+                    }
+                }
+                let typesToTry = [currentType];
+                if ((0, reflection_1.isEnumType)(currentType)) {
+                    typesToTry.push(currentType.defaultMemberType);
+                }
+                if ((0, reflection_1.isInheritableType)(currentType)) {
+                    let inheritableType = currentType;
+                    while (inheritableType === null || inheritableType === void 0 ? void 0 : inheritableType.parentType) {
+                        let parentType = inheritableType.parentType;
+                        if ((0, reflection_1.isReferenceType)(inheritableType.parentType)) {
+                            const fullName = inheritableType.parentType.fullName;
+                            if (fullName.includes('.')) {
+                                parentType = (_j = (_h = root.getSymbol(fullName)) === null || _h === void 0 ? void 0 : _h.symbol) === null || _j === void 0 ? void 0 : _j.type;
+                            }
+                            else {
+                                parentType = (_m = (_l = (_k = this.getSymbol(fullName)) === null || _k === void 0 ? void 0 : _k.symbol) === null || _l === void 0 ? void 0 : _l.type) !== null && _m !== void 0 ? _m : (_p = (_o = root.getSymbol(fullName)) === null || _o === void 0 ? void 0 : _o.symbol) === null || _p === void 0 ? void 0 : _p.type;
+                            }
+                        }
+                        typesToTry.push(parentType);
+                        inheritableType = parentType;
+                    }
+                }
+                const extraData = {};
+                for (const curType of typesToTry) {
+                    currentType = curType === null || curType === void 0 ? void 0 : curType.getMemberType(namePart, { flags: 1 /* SymbolTypeFlag.runtime */, data: extraData });
+                    if ((0, reflection_1.isReferenceType)(currentType)) {
+                        const memberLookup = currentType.fullName;
+                        currentType = (_s = (_r = (_q = this.getSymbol(memberLookup.toLowerCase())) === null || _q === void 0 ? void 0 : _q.symbol) === null || _r === void 0 ? void 0 : _r.type) !== null && _s !== void 0 ? _s : (_u = (_t = root.getSymbol(memberLookup.toLowerCase())) === null || _t === void 0 ? void 0 : _t.symbol) === null || _u === void 0 ? void 0 : _u.type;
+                    }
+                    if (currentType) {
+                        break;
+                    }
+                }
+                if (!currentType) {
+                    return;
+                }
+                // get specific member
+                result = Object.assign(Object.assign({}, result), { symbol: { name: namePart, type: currentType, data: extraData, flags: 1 /* SymbolTypeFlag.runtime */ } });
+            }
+            return result;
+        }
+        else if (rest && this.namespaces.has(first)) {
+            const node = this.namespaces.get(first);
+            const parts = node.getSymbolByNameParts(rest, root);
+            return parts;
+        }
+    }
+    getNamespaceByNameParts(lowerSymbolNameParts) {
+        var _a;
+        const first = (_a = lowerSymbolNameParts === null || lowerSymbolNameParts === void 0 ? void 0 : lowerSymbolNameParts[0]) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        const rest = lowerSymbolNameParts.slice(1);
+        if (!first) {
+            return;
+        }
+        if (this.namespaces.has(first)) {
+            const node = this.namespaces.get(first);
+            const result = (rest === null || rest === void 0 ? void 0 : rest.length) > 0 ? node.getNamespaceByNameParts(rest) : node;
+            return result;
+        }
+    }
+    addSymbol(symbolName, symbolPair) {
+        let lowerSymbolNameParts = symbolName.toLowerCase().split('.');
+        return this.addSymbolByNameParts(lowerSymbolNameParts, symbolPair);
+    }
+    addSymbolByNameParts(lowerSymbolNameParts, symbolPair) {
+        var _a, _b;
+        const first = lowerSymbolNameParts === null || lowerSymbolNameParts === void 0 ? void 0 : lowerSymbolNameParts[0];
+        const rest = lowerSymbolNameParts === null || lowerSymbolNameParts === void 0 ? void 0 : lowerSymbolNameParts.slice(1);
+        let isDuplicate = false;
+        if (!first) {
+            return;
+        }
+        if ((rest === null || rest === void 0 ? void 0 : rest.length) > 0) {
+            // first must be a namespace
+            let namespaceNode = this.namespaces.get(first);
+            if (!namespaceNode) {
+                namespaceNode = new ProvidedNode(first);
+                this.namespaces.set(first, namespaceNode);
+            }
+            return namespaceNode.addSymbolByNameParts(rest, symbolPair);
+        }
+        else {
+            if (this.namespaces.get(first)) {
+                // trying to add a symbol that already exists as a namespace - this is a duplicate
+                return true;
+            }
+            // just add it to the symbols
+            const existingSymbolPair = this.symbols.get(first);
+            if (!existingSymbolPair) {
+                this.symbols.set(first, symbolPair);
+            }
+            else {
+                isDuplicate = ((_a = existingSymbolPair.symbol.data) === null || _a === void 0 ? void 0 : _a.definingNode) !== ((_b = symbolPair.symbol.data) === null || _b === void 0 ? void 0 : _b.definingNode);
+            }
+        }
+        return isDuplicate;
+    }
+}
+exports.ProvidedNode = ProvidedNode;
+class CrossScopeValidator {
+    constructor(program) {
+        this.program = program;
+        this.resolutionsMap = new Map();
+        this.providedTreeMap = new Map();
+        this.componentsMap = new Map();
+    }
+    symbolMapKeys(symbol) {
+        var _a, _b, _c, _d, _e, _f;
+        let keysArray = new Array();
+        let unnamespacedNameLowers = [];
+        function joinTypeChainForKey(typeChain, firstType) {
+            firstType || (firstType = typeChain[0].type);
+            const unnamespacedNameLower = typeChain.map((tce, i) => {
+                if (i === 0) {
+                    if ((0, reflection_1.isReferenceType)(firstType)) {
+                        return firstType.fullName;
+                    }
+                    else if ((0, reflection_1.isInheritableType)(firstType)) {
+                        return tce.type.toString();
+                    }
+                    return tce.name;
+                }
+                return tce.name;
+            }).join('.').toLowerCase();
+            return unnamespacedNameLower;
+        }
+        if ((0, reflection_1.isUnionType)(symbol.typeChain[0].type) && symbol.typeChain[0].data.isInstance) {
+            const allUnifiedTypes = (0, helpers_1.getAllTypesFromCompoundType)(symbol.typeChain[0].type);
+            for (const unifiedType of allUnifiedTypes) {
+                unnamespacedNameLowers.push(joinTypeChainForKey(symbol.typeChain, unifiedType));
+            }
+        }
+        else {
+            unnamespacedNameLowers.push(joinTypeChainForKey(symbol.typeChain));
+        }
+        for (const unnamespacedNameLower of unnamespacedNameLowers) {
+            const lowerFirst = (_c = (_b = (_a = symbol.typeChain[0]) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.toLowerCase()) !== null && _c !== void 0 ? _c : '';
+            let namespacedName = '';
+            let lowerNamespacePrefix = '';
+            let namespacedPotentialTypeKey = '';
+            if (((_d = symbol.containingNamespaces) === null || _d === void 0 ? void 0 : _d.length) > 0 && ((_e = symbol.typeChain[0]) === null || _e === void 0 ? void 0 : _e.name.toLowerCase()) !== symbol.containingNamespaces[0].toLowerCase()) {
+                lowerNamespacePrefix = `${((_f = symbol.containingNamespaces) !== null && _f !== void 0 ? _f : []).join('.')}`.toLowerCase();
+            }
+            if (lowerNamespacePrefix) {
+                namespacedName = `${lowerNamespacePrefix}.${unnamespacedNameLower}`;
+                namespacedPotentialTypeKey = `${lowerNamespacePrefix}.${lowerFirst}`;
+            }
+            keysArray.push({
+                potentialTypeKey: lowerFirst,
+                key: unnamespacedNameLower,
+                namespacedKey: namespacedName,
+                namespacedPotentialTypeKey: namespacedPotentialTypeKey //first entry in chain, prefixed with current namespace
+            });
+        }
+        return keysArray;
+    }
+    getRequiredMap(scope) {
+        const map = new Map();
+        scope.enumerateBrsFiles((file) => {
+            for (const symbol of file.requiredSymbols) {
+                const symbolKeysArray = this.symbolMapKeys(symbol);
+                for (const symbolKeys of symbolKeysArray) {
+                    map.set(symbolKeys, symbol);
+                }
+            }
+        });
+        return map;
+    }
+    getProvidedTree(scope) {
+        var _a;
+        if (this.providedTreeMap.has(scope.name)) {
+            return this.providedTreeMap.get(scope.name);
+        }
+        const providedTree = new ProvidedNode('', this.componentsMap);
+        let duplicatesMap = null;
+        const referenceTypesMap = new Map();
+        const addSymbolWithDuplicates = (symbolName, file, symbolObj) => {
+            var _a, _b;
+            // eslint-disable-next-line no-bitwise
+            const globalSymbol = this.program.globalScope.symbolTable.getSymbol(symbolName, 2 /* SymbolTypeFlag.typetime */ | 1 /* SymbolTypeFlag.runtime */);
+            const symbolIsNamespace = providedTree.getNamespace(symbolName);
+            const isDupe = providedTree.addSymbol(symbolName, { file: file, symbol: symbolObj.symbol });
+            if (symbolIsNamespace || globalSymbol || isDupe || symbolObj.duplicates.length > 0) {
+                let dupesSet = (_a = duplicatesMap === null || duplicatesMap === void 0 ? void 0 : duplicatesMap.get(symbolName)) !== null && _a !== void 0 ? _a : null;
+                if (!dupesSet) {
+                    dupesSet = new Set();
+                    if (!duplicatesMap) {
+                        duplicatesMap = new Map();
+                    }
+                    duplicatesMap.set(symbolName, dupesSet);
+                    const existing = providedTree.getSymbol(symbolName);
+                    if (existing) {
+                        dupesSet.add(existing);
+                    }
+                }
+                if (!dupesSet.has({ file: file, symbol: symbolObj.symbol })) {
+                    dupesSet.add({ file: file, symbol: symbolObj.symbol });
+                }
+                if (symbolIsNamespace) {
+                    const namespaceContainer = scope.getNamespace(symbolName);
+                    const nsNode = (_b = namespaceContainer === null || namespaceContainer === void 0 ? void 0 : namespaceContainer.namespaceStatements) === null || _b === void 0 ? void 0 : _b[0];
+                    if (nsNode) {
+                        const nsFile = namespaceContainer.file;
+                        const nsType = nsNode.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+                        let nsSymbol = {
+                            name: nsNode.getName(Parser_1.ParseMode.BrighterScript),
+                            type: nsType,
+                            data: { definingNode: nsNode },
+                            flags: 2 /* SymbolTypeFlag.typetime */
+                        };
+                        if (nsSymbol && !dupesSet.has({ file: nsFile, symbol: nsSymbol })) {
+                            dupesSet.add({ file: nsFile, symbol: nsSymbol });
+                        }
+                    }
+                }
+                for (const providedDupeSymbol of symbolObj.duplicates) {
+                    if (!dupesSet.has({ file: file, symbol: providedDupeSymbol })) {
+                        dupesSet.add({ file: file, symbol: providedDupeSymbol });
+                    }
+                }
+                if (globalSymbol) {
+                    dupesSet.add({ file: globalCallables_1.globalFile, symbol: globalSymbol[0] });
+                }
+            }
+        };
+        scope.enumerateBrsFiles((file) => {
+            var _a, _b, _c;
+            for (const [_, nameMap] of file.providedSymbols.symbolMap.entries()) {
+                for (const [symbolName, symbolObj] of nameMap.entries()) {
+                    if ((0, reflection_1.isNamespaceType)(symbolObj.symbol.type)) {
+                        continue;
+                    }
+                    addSymbolWithDuplicates(symbolName, file, symbolObj);
+                }
+            }
+            // find all "provided symbols" that are reference types
+            for (const [_, nameMap] of file.providedSymbols.referenceSymbolMap.entries()) {
+                for (const [symbolName, symbolObj] of nameMap.entries()) {
+                    const symbolType = symbolObj.symbol.type;
+                    const namespaceLower = (_c = (_b = (_a = symbolObj.symbol.data) === null || _a === void 0 ? void 0 : _a.definingNode) === null || _b === void 0 ? void 0 : _b.findAncestor(reflection_1.isNamespaceStatement)) === null || _c === void 0 ? void 0 : _c.getName(Parser_1.ParseMode.BrighterScript).toLowerCase();
+                    const allNames = (0, ReferenceType_1.getAllRequiredSymbolNames)(symbolType, namespaceLower);
+                    referenceTypesMap.set({ symbolName: symbolName, file: file, symbolObj: symbolObj }, allNames);
+                }
+            }
+        });
+        // check provided reference types to see if they exist yet!
+        while (referenceTypesMap.size > 0) {
+            let addedSymbol = false;
+            for (const [refTypeDetails, neededNames] of referenceTypesMap.entries()) {
+                let foundNames = 0;
+                for (const neededName of neededNames) {
+                    // check if name exists or namespaced version exists
+                    if ((_a = providedTree.getSymbol(neededName.name)) !== null && _a !== void 0 ? _a : providedTree.getSymbol(neededName.namespacedName)) {
+                        foundNames++;
+                    }
+                }
+                if (neededNames.length === foundNames) {
+                    //found all that were needed
+                    addSymbolWithDuplicates(refTypeDetails.symbolName, refTypeDetails.file, refTypeDetails.symbolObj);
+                    referenceTypesMap.delete(refTypeDetails);
+                    addedSymbol = true;
+                }
+            }
+            if (!addedSymbol) {
+                break;
+            }
+        }
+        const result = { duplicatesMap: duplicatesMap, providedTree: providedTree };
+        this.providedTreeMap.set(scope.name, result);
+        return result;
+    }
+    getIssuesForScope(scope) {
+        var _a, _b, _c, _d, _e;
+        const requiredMap = this.getRequiredMap(scope);
+        const { providedTree, duplicatesMap } = this.getProvidedTree(scope);
+        const missingSymbols = new Set();
+        for (const [symbolKeys, unresolvedSymbol] of requiredMap.entries()) {
+            // check global scope for components
+            if (unresolvedSymbol.typeChain.length === 1 && this.program.globalScope.symbolTable.getSymbol(unresolvedSymbol.typeChain[0].name, unresolvedSymbol.flags)) {
+                //symbol is available in global scope. ignore it
+                continue;
+            }
+            let foundSymbol = providedTree.getSymbolByKey(symbolKeys);
+            if (foundSymbol) {
+                if (!((_a = unresolvedSymbol.typeChain[0].data) === null || _a === void 0 ? void 0 : _a.isInstance)) {
+                    let resolvedListForSymbol = this.resolutionsMap.get(unresolvedSymbol);
+                    if (!resolvedListForSymbol) {
+                        resolvedListForSymbol = new Set();
+                        this.resolutionsMap.set(unresolvedSymbol, resolvedListForSymbol);
+                    }
+                    resolvedListForSymbol.add({
+                        scope: scope,
+                        sourceFile: foundSymbol.file,
+                        providedSymbol: foundSymbol.symbol
+                    });
+                }
+            }
+            else {
+                let foundNamespace = providedTree.getNamespace(symbolKeys.key);
+                if (foundNamespace) {
+                    // this symbol turned out to be a namespace. This is allowed for alias statements
+                    // TODO: add check to make sure this usage is from an alias statement
+                }
+                else {
+                    // did not find symbol!
+                    const missing = Object.assign({}, unresolvedSymbol);
+                    let namespaceNode = providedTree;
+                    let currentKnownType;
+                    for (const chainEntry of missing.typeChain) {
+                        if (!chainEntry.isResolved) {
+                            // for each unresolved part of a chain, see if we can resolve it with stuff from the provided tree
+                            // and if so, mark it as resolved
+                            const lookupName = (_c = (_b = chainEntry.type) === null || _b === void 0 ? void 0 : _b.fullName) !== null && _c !== void 0 ? _c : chainEntry.name;
+                            if (!currentKnownType) {
+                                namespaceNode = namespaceNode === null || namespaceNode === void 0 ? void 0 : namespaceNode.getNamespaceByNameParts([chainEntry.name]);
+                            }
+                            if (namespaceNode) {
+                                chainEntry.isResolved = true;
+                            }
+                            else {
+                                if (currentKnownType) {
+                                    currentKnownType = currentKnownType.getMemberType(chainEntry.name, { flags: 1 /* SymbolTypeFlag.runtime */ });
+                                }
+                                else {
+                                    currentKnownType = (_e = (_d = providedTree.getSymbol(lookupName.toLowerCase())) === null || _d === void 0 ? void 0 : _d.symbol) === null || _e === void 0 ? void 0 : _e.type;
+                                }
+                                if (currentKnownType === null || currentKnownType === void 0 ? void 0 : currentKnownType.isResolvable()) {
+                                    chainEntry.isResolved = true;
+                                }
+                                else {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    missingSymbols.add(unresolvedSymbol);
+                }
+            }
+        }
+        return { missingSymbols: missingSymbols, duplicatesMap: duplicatesMap };
+    }
+    clearResolutionsForFile(file) {
+        for (const symbol of this.resolutionsMap.keys()) {
+            if (symbol.file === file) {
+                this.resolutionsMap.delete(symbol);
+            }
+        }
+    }
+    clearResolutionsForScopes(scopes) {
+        const lowerScopeNames = new Set(scopes.map(scope => scope.name.toLowerCase()));
+        for (const [symbol, resolutionInfos] of this.resolutionsMap.entries()) {
+            for (const info of resolutionInfos.values()) {
+                if (lowerScopeNames.has(info.scope.name.toLowerCase())) {
+                    resolutionInfos.delete(info);
+                }
+            }
+            if (resolutionInfos.size === 0) {
+                this.resolutionsMap.delete(symbol);
+            }
+        }
+    }
+    getFilesRequiringChangedSymbol(scopes, changedSymbols) {
+        const filesThatNeedRevalidation = new Set();
+        const filesThatDoNotNeedRevalidation = new Set();
+        for (const scope of scopes) {
+            scope.enumerateBrsFiles((file) => {
+                if (filesThatNeedRevalidation.has(file) || filesThatDoNotNeedRevalidation.has(file)) {
+                    return;
+                }
+                if (util_1.util.hasAnyRequiredSymbolChanged(file.requiredSymbols, changedSymbols)) {
+                    filesThatNeedRevalidation.add(file);
+                    return;
+                }
+                filesThatDoNotNeedRevalidation.add(file);
+            });
+        }
+        return filesThatNeedRevalidation;
+    }
+    getScopesRequiringChangedSymbol(scopes, changedSymbols) {
+        const scopesThatNeedRevalidation = new Set();
+        const filesAlreadyChecked = new Set();
+        for (const scope of scopes) {
+            scope.enumerateBrsFiles((file) => {
+                if (filesAlreadyChecked.has(file) || scopesThatNeedRevalidation.has(scope)) {
+                    return;
+                }
+                filesAlreadyChecked.add(file);
+                if (util_1.util.hasAnyRequiredSymbolChanged(file.requiredSymbols, changedSymbols)) {
+                    scopesThatNeedRevalidation.add(scope);
+                }
+            });
+        }
+        return scopesThatNeedRevalidation;
+    }
+    buildComponentsMap() {
+        var _a;
+        this.componentsMap.clear();
+        // Add custom components
+        for (let componentName of this.program.getSortedComponentNames()) {
+            const typeName = 'rosgnode' + componentName;
+            const component = this.program.getComponent(componentName);
+            const componentSymbol = (_a = this.program.globalScope.symbolTable.getSymbol(typeName, 2 /* SymbolTypeFlag.typetime */)) === null || _a === void 0 ? void 0 : _a[0];
+            if (componentSymbol && component) {
+                this.componentsMap.set(typeName, { file: component.file, symbol: componentSymbol });
+            }
+        }
+    }
+    addDiagnosticsForScopes(scopes) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        const addDuplicateSymbolDiagnostics = true;
+        const missingSymbolInScope = new Map();
+        this.providedTreeMap.clear();
+        this.clearResolutionsForScopes(scopes);
+        // Check scope for duplicates and missing symbols
+        for (const scope of scopes) {
+            this.program.diagnostics.clearByFilter({
+                scope: scope,
+                tag: CrossScopeValidatorDiagnosticTag
+            });
+            const { missingSymbols, duplicatesMap } = this.getIssuesForScope(scope);
+            if (addDuplicateSymbolDiagnostics && duplicatesMap) {
+                for (const [_flag, dupeSet] of duplicatesMap.entries()) {
+                    if (dupeSet.size > 1) {
+                        const dupesArray = [...dupeSet.values()];
+                        for (let i = 0; i < dupesArray.length; i++) {
+                            const dupe = dupesArray[i];
+                            const dupeNode = (_b = (_a = dupe === null || dupe === void 0 ? void 0 : dupe.symbol) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.definingNode;
+                            if (!dupeNode) {
+                                continue;
+                            }
+                            let thisName = (_c = dupe.symbol) === null || _c === void 0 ? void 0 : _c.name;
+                            const wrappingNameSpace = dupeNode === null || dupeNode === void 0 ? void 0 : dupeNode.findAncestor(reflection_1.isNamespaceStatement);
+                            if (wrappingNameSpace) {
+                                thisName = `${wrappingNameSpace.getName(Parser_1.ParseMode.BrighterScript)}.` + thisName;
+                            }
+                            const thisNodeKindName = (_d = util_1.util.getAstNodeFriendlyName(dupeNode)) !== null && _d !== void 0 ? _d : 'Item';
+                            for (let j = 0; j < dupesArray.length; j++) {
+                                if (i === j) {
+                                    continue;
+                                }
+                                const otherDupe = dupesArray[j];
+                                if (!otherDupe || dupe.symbol === otherDupe.symbol) {
+                                    continue;
+                                }
+                                const otherDupeNode = (_e = otherDupe.symbol.data) === null || _e === void 0 ? void 0 : _e.definingNode;
+                                const otherIsGlobal = otherDupe.file.srcPath === 'global';
+                                if ((0, reflection_1.isFunctionStatement)(dupeNode) && (0, reflection_1.isFunctionStatement)(otherDupeNode)) {
+                                    // duplicate functions are handled in ScopeValidator
+                                    continue;
+                                }
+                                if (otherIsGlobal &&
+                                    ((0, reflection_1.isInterfaceStatement)(dupeNode) ||
+                                        (0, reflection_1.isEnumStatement)(dupeNode) ||
+                                        (0, reflection_1.isConstStatement)(dupeNode))) {
+                                    // these are allowed to shadow global functions
+                                    continue;
+                                }
+                                let thatName = (_f = otherDupe.symbol) === null || _f === void 0 ? void 0 : _f.name;
+                                if (otherDupeNode) {
+                                    const otherWrappingNameSpace = otherDupeNode === null || otherDupeNode === void 0 ? void 0 : otherDupeNode.findAncestor(reflection_1.isNamespaceStatement);
+                                    if (otherWrappingNameSpace) {
+                                        thatName = `${otherWrappingNameSpace.getName(Parser_1.ParseMode.BrighterScript)}.` + thatName;
+                                    }
+                                }
+                                const thatNodeKindName = otherIsGlobal ? 'Global Function' : (_g = util_1.util.getAstNodeFriendlyName(otherDupeNode)) !== null && _g !== void 0 ? _g : 'Item';
+                                let thisNameRange = (_l = (_k = (_j = (_h = dupeNode === null || dupeNode === void 0 ? void 0 : dupeNode.tokens) === null || _h === void 0 ? void 0 : _h.name) === null || _j === void 0 ? void 0 : _j.location) === null || _k === void 0 ? void 0 : _k.range) !== null && _l !== void 0 ? _l : (_m = dupeNode.location) === null || _m === void 0 ? void 0 : _m.range;
+                                let thatNameRange = (_r = (_q = (_p = (_o = otherDupeNode === null || otherDupeNode === void 0 ? void 0 : otherDupeNode.tokens) === null || _o === void 0 ? void 0 : _o.name) === null || _p === void 0 ? void 0 : _p.location) === null || _q === void 0 ? void 0 : _q.range) !== null && _r !== void 0 ? _r : (_s = otherDupeNode === null || otherDupeNode === void 0 ? void 0 : otherDupeNode.location) === null || _s === void 0 ? void 0 : _s.range;
+                                const relatedInformation = thatNameRange ? [{
+                                        message: `${thatNodeKindName} declared here`,
+                                        location: util_1.util.createLocationFromFileRange(otherDupe.file, thatNameRange)
+                                    }] : undefined;
+                                this.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.nameCollision(thisNodeKindName, thatNodeKindName, thatName)), { location: util_1.util.createLocationFromFileRange(dupe.file, thisNameRange), relatedInformation: relatedInformation }), {
+                                    scope: scope,
+                                    tags: [CrossScopeValidatorDiagnosticTag]
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            // build map of the symbols and scopes where the symbols are missing per file
+            for (const missingSymbol of missingSymbols) {
+                let scopesWithMissingSymbol = missingSymbolInScope.get(missingSymbol);
+                if (!scopesWithMissingSymbol) {
+                    scopesWithMissingSymbol = new Set();
+                    missingSymbolInScope.set(missingSymbol, scopesWithMissingSymbol);
+                }
+                scopesWithMissingSymbol.add(scope);
+            }
+        }
+        // If symbols are missing in SOME scopes, add diagnostic
+        for (const [symbol, scopeList] of missingSymbolInScope.entries()) {
+            const typeChainResult = util_1.util.processTypeChain(symbol.typeChain);
+            //roku built-in type names (rosgnode*, etc.) aren't tracked in any symbol table;
+            //skip cannot-find-name when the symbol's name is one of those built-ins.
+            if (typeChainResult.itemName && util_1.util.isBuiltInType(typeChainResult.itemName)) {
+                continue;
+            }
+            for (const scope of scopeList) {
+                this.program.diagnostics.register(Object.assign(Object.assign({}, this.getCannotFindDiagnostic(scope, symbol, typeChainResult)), { location: typeChainResult.location }), {
+                    scope: scope,
+                    tags: [CrossScopeValidatorDiagnosticTag]
+                });
+            }
+        }
+        for (const resolution of this.getIncompatibleSymbolResolutions()) {
+            const symbol = resolution.symbol;
+            const incompatibleScopes = resolution.incompatibleScopes;
+            if (incompatibleScopes.size > 1) {
+                const typeChainResult = util_1.util.processTypeChain(symbol.typeChain);
+                const scopeList = [...incompatibleScopes.values()].map(s => s.name);
+                this.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.incompatibleSymbolDefinition(typeChainResult.fullChainName, { scopes: scopeList })), { location: typeChainResult.location }), {
+                    tags: [CrossScopeValidatorDiagnosticTag]
+                });
+            }
+        }
+    }
+    getIncompatibleSymbolResolutions() {
+        const incompatibleResolutions = new Array();
+        // check all resolutions and check if there are resolutions that are not compatible across scopes
+        for (const [symbol, resolutionDetails] of this.resolutionsMap.entries()) {
+            if (resolutionDetails.size < 2) {
+                // there is only one resolution... no worries
+                continue;
+            }
+            const resolutionsList = [...resolutionDetails];
+            const prime = resolutionsList[0];
+            let incompatibleScopes = new Set();
+            let addedPrime = false;
+            for (let i = 1; i < resolutionsList.length; i++) {
+                let providedSymbolType = prime.providedSymbol.type;
+                const symbolInThisScope = resolutionsList[i].providedSymbol;
+                //get more general type
+                if (providedSymbolType.isEqual(symbolInThisScope.type)) {
+                    //type in this scope is the same as one we're already checking
+                }
+                else if (providedSymbolType.isTypeCompatible(symbolInThisScope.type)) {
+                    //type in this scope is compatible with one we're storing. use most generic
+                    providedSymbolType = symbolInThisScope.type;
+                }
+                else if (symbolInThisScope.type.isTypeCompatible(providedSymbolType)) {
+                    // type we're storing is more generic that the type in this scope
+                }
+                else {
+                    // type in this scope is not compatible with other types for this symbol
+                    if (!addedPrime) {
+                        incompatibleScopes.add(prime.scope);
+                        addedPrime = true;
+                    }
+                    incompatibleScopes.add(resolutionsList[i].scope);
+                }
+            }
+            if (incompatibleScopes.size > 1) {
+                incompatibleResolutions.push({
+                    symbol: symbol,
+                    incompatibleScopes: incompatibleScopes
+                });
+            }
+        }
+        return incompatibleResolutions;
+    }
+    getCannotFindDiagnostic(scope, unresolvedSymbol, typeChainResult) {
+        var _a, _b, _c, _d;
+        const parentDescriptor = this.getParentTypeDescriptor((_a = this.getProvidedTree(scope)) === null || _a === void 0 ? void 0 : _a.providedTree, typeChainResult);
+        const symbolType = (_b = typeChainResult.astNode) === null || _b === void 0 ? void 0 : _b.getType({ flags: unresolvedSymbol.flags });
+        if ((0, reflection_1.isReferenceType)(symbolType)) {
+            const circularReferenceInfo = symbolType.getCircularReferenceInfo();
+            if (circularReferenceInfo.isCircularReference) {
+                let diagnosticDetail = util_1.util.getCircularReferenceDiagnosticDetail(circularReferenceInfo, typeChainResult.fullNameOfItem);
+                return DiagnosticMessages_1.DiagnosticMessages.circularReferenceDetected(diagnosticDetail);
+            }
+        }
+        if ((0, reflection_1.isCallExpression)((_c = typeChainResult.astNode) === null || _c === void 0 ? void 0 : _c.parent) && ((_d = typeChainResult.astNode) === null || _d === void 0 ? void 0 : _d.parent.callee) === typeChainResult.astNode) {
+            return DiagnosticMessages_1.DiagnosticMessages.cannotFindFunction(typeChainResult.itemName, typeChainResult.fullNameOfItem, typeChainResult.itemParentTypeName, parentDescriptor);
+        }
+        return DiagnosticMessages_1.DiagnosticMessages.cannotFindName(typeChainResult.itemName, typeChainResult.fullNameOfItem, typeChainResult.itemParentTypeName, parentDescriptor);
+    }
+    getParentTypeDescriptor(provided, typeChainResult) {
+        if (typeChainResult.itemParentTypeKind === BscTypeKind_1.BscTypeKind.NamespaceType || (provided === null || provided === void 0 ? void 0 : provided.getNamespace(typeChainResult.itemParentTypeName))) {
+            return 'namespace';
+        }
+        return 'type';
+    }
+}
+exports.CrossScopeValidator = CrossScopeValidator;
+//# sourceMappingURL=CrossScopeValidator.js.map