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

package/dist/Scope.js

@@ -1,18 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Scope = void 0;
-const vscode_languageserver_1 = require("vscode-languageserver");
+/* eslint-disable @typescript-eslint/dot-notation */
+const path = require("path");
 const chalk_1 = require("chalk");
-const DiagnosticMessages_1 = require("./DiagnosticMessages");
-const ClassValidator_1 = require("./validators/ClassValidator");
-const parser_1 = require("./parser");
+const Parser_1 = require("./parser/Parser");
 const util_1 = require("./util");
-const globalCallables_1 = require("./globalCallables");
 const Cache_1 = require("./Cache");
-const vscode_uri_1 = require("vscode-uri");
-const Logger_1 = require("./Logger");
 const reflection_1 = require("./astUtils/reflection");
+const visitors_1 = require("./astUtils/visitors");
 const SymbolTable_1 = require("./SymbolTable");
+const ReferenceType_1 = require("./types/ReferenceType");
+const UnionType_1 = require("./types/UnionType");
+const AssociativeArrayType_1 = require("./types/AssociativeArrayType");
+const perf_hooks_1 = require("perf_hooks");
+const logging_1 = require("./logging");
+const UninitializedType_1 = require("./types/UninitializedType");
+const ScopeNamespaceLookup_1 = require("./ScopeNamespaceLookup");
+/**
+ * Assign some few factories to the SymbolTable to prevent cyclical imports. This file seems like the most intuitive place to do the linking
+ * since Scope will be used by pretty much everything
+ */
+SymbolTable_1.SymbolTable.referenceTypeFactory = ReferenceType_1.referenceTypeFactory;
+SymbolTable_1.SymbolTable.unionTypeFactory = UnionType_1.unionTypeFactory;
+SymbolTable_1.SymbolTable.uninitializedTypeFactory = UninitializedType_1.uninitializedTypeFactory;
 /**
  * A class to keep track of all declarations within a given scope (like source scope, component scope)
  */
@@ -22,10 +33,16 @@ class Scope {
         this.program = program;
         this._dependencyGraphKey = _dependencyGraphKey;
         this.cache = new Cache_1.Cache();
+        this.useFileCachesForFileLinkLookups = false;
+        this.validationMetrics = {
+            linkTime: 0,
+            validationTime: 0
+        };
         /**
-         * The list of diagnostics found specifically for this scope. Individual file diagnostics are stored on the files themselves.
+         * A list of functions that will be called whenever `unlinkSymbolTable` is called
          */
-        this.diagnostics = [];
+        this.linkSymbolTableDisposables = [];
+        this.symbolsAddedDuringLinking = [];
         this.isValidated = false;
         //used for improved logging performance
         this._debugLogComponentName = `Scope '${chalk_1.default.redBright(this.name)}'`;
@@ -39,8 +56,80 @@ class Scope {
      * "namea", "namea.nameb", "namea.nameb.namec"
      */
     get namespaceLookup() {
+        let allFilesValidated = true;
+        for (const file of this.getAllFiles()) {
+            if ((0, reflection_1.isBrsFile)(file) && !file.hasTypedef) {
+                allFilesValidated = allFilesValidated && file.isValidated;
+                if (!allFilesValidated) {
+                    break;
+                }
+            }
+        }
+        if (!allFilesValidated) {
+            // This is not fit to cache
+            // Since the files have not been validated, all namespace info might not have been available
+            return this.buildNamespaceLookup();
+        }
         return this.cache.getOrAdd('namespaceLookup', () => this.buildNamespaceLookup());
     }
+    /**
+     * A dictionary of namespaces, indexed by the lower case full name of each namespace.
+     * If a namespace is declared as "NameA.NameB.NameC", there will be 3 entries in this dictionary,
+     * "namea", "namea.nameb", "namea.nameb.namec"
+     */
+    get namespaceNameSet() {
+        return this.cache.getOrAdd('namespaceNameSet', () => {
+            const lowerNamespaceNames = new Set();
+            this.enumerateBrsFiles((file) => {
+                const fileNamespaceLookup = file.getNamespaceLookupObject();
+                for (const [lowerNamespaceName, _] of fileNamespaceLookup) {
+                    lowerNamespaceNames.add(lowerNamespaceName);
+                }
+            });
+            return lowerNamespaceNames;
+        });
+    }
+    /**
+     * Get a NamespaceContainer by its name, looking for a fully qualified version first, then global version next if not found
+     */
+    getNamespace(name, containingNamespace) {
+        const nameLower = name === null || name === void 0 ? void 0 : name.toLowerCase();
+        const lookup = this.namespaceLookup;
+        let ns;
+        if (containingNamespace) {
+            ns = lookup.get(`${containingNamespace === null || containingNamespace === void 0 ? void 0 : containingNamespace.toLowerCase()}.${nameLower}`);
+        }
+        //if we couldn't find the namespace by its full namespaced name, look for a global version
+        if (!ns) {
+            ns = lookup.get(nameLower);
+        }
+        return ns;
+    }
+    /**
+     * Get a NamespaceContainer by its name, looking for a fully qualified version first, then global version next if not found
+     */
+    getNamespacesWithRoot(rootName, containingNamespace) {
+        const nameLower = rootName === null || rootName === void 0 ? void 0 : rootName.toLowerCase();
+        const lookup = this.namespaceLookup;
+        const lookupKeys = [...lookup.keys()];
+        let lookupName = nameLower;
+        if (containingNamespace) {
+            lookupName = `${containingNamespace === null || containingNamespace === void 0 ? void 0 : containingNamespace.toLowerCase()}.${nameLower}`;
+        }
+        const nsList = lookupKeys.filter(key => key === lookupName).map(key => lookup.get(key));
+        return nsList;
+    }
+    /**
+     * Get a NamespaceContainer by its name, looking for a fully qualified version first, then global version next if not found
+     */
+    getFirstNamespaceWithRoot(rootName, containingNamespace) {
+        const nameLower = rootName === null || rootName === void 0 ? void 0 : rootName.toLowerCase();
+        let lookupName = nameLower;
+        if (containingNamespace) {
+            lookupName = `${containingNamespace === null || containingNamespace === void 0 ? void 0 : containingNamespace.toLowerCase()}.${nameLower}`;
+        }
+        return this.namespaceLookup.get(lookupName);
+    }
     /**
      * Get the class with the specified name.
      * @param className - The class name, including the namespace of the class if possible
@@ -50,29 +139,236 @@ class Scope {
         var _a;
         return (_a = this.getClassFileLink(className, containingNamespace)) === null || _a === void 0 ? void 0 : _a.item;
     }
+    /**
+     * Get the interface with the specified name.
+     * @param ifaceName - The interface name, including the namespace of the interface if possible
+     * @param containingNamespace - The namespace used to resolve relative interface names. (i.e. the namespace around the current statement trying to find a interface)
+     */
+    getInterface(ifaceName, containingNamespace) {
+        var _a;
+        return (_a = this.getInterfaceFileLink(ifaceName, containingNamespace)) === null || _a === void 0 ? void 0 : _a.item;
+    }
+    /**
+     * Get the enum with the specified name.
+     * @param enumName - The enum name, including the namespace if possible
+     * @param containingNamespace - The namespace used to resolve relative enum names. (i.e. the namespace around the current statement trying to find an enum)
+     */
+    getEnum(enumName, containingNamespace) {
+        var _a;
+        return (_a = this.getEnumFileLink(enumName, containingNamespace)) === null || _a === void 0 ? void 0 : _a.item;
+    }
+    getFileLinkFromFileMap(cachedMapName, itemName, containingNamespace) {
+        var _a;
+        let result;
+        const fullNameLower = (_a = util_1.util.getFullyQualifiedClassName(itemName, containingNamespace)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        const itemNameLower = itemName === null || itemName === void 0 ? void 0 : itemName.toLowerCase();
+        if (fullNameLower) {
+            this.enumerateBrsFilesWithBreak((file) => {
+                let stmt = file['_cachedLookups'][cachedMapName].get(fullNameLower);
+                if (stmt) {
+                    result = { item: stmt, file: file };
+                }
+                return !!stmt;
+            });
+        }
+        if (!result && itemNameLower && fullNameLower !== itemNameLower) {
+            this.enumerateBrsFilesWithBreak((file) => {
+                let stmt = file['_cachedLookups'][cachedMapName].get(itemNameLower);
+                if (stmt) {
+                    result = { item: stmt, file: file };
+                }
+                return !!stmt;
+            });
+        }
+        return result;
+    }
+    getTypeStatement(typeName, containingNamespace) {
+        var _a;
+        return (_a = this.getTypeStatementFileLink(typeName, containingNamespace)) === null || _a === void 0 ? void 0 : _a.item;
+    }
     /**
      * Get a class and its containing file by the class name
      * @param className - The class name, including the namespace of the class if possible
      * @param containingNamespace - The namespace used to resolve relative class names. (i.e. the namespace around the current statement trying to find a class)
      */
     getClassFileLink(className, containingNamespace) {
-        const lowerClassName = className === null || className === void 0 ? void 0 : className.toLowerCase();
+        var _a;
+        if (this.useFileCachesForFileLinkLookups) {
+            return this.getFileLinkFromFileMap('classStatementMap', className, containingNamespace);
+        }
+        const lowerName = className === null || className === void 0 ? void 0 : className.toLowerCase();
+        const fullNameLower = (_a = util_1.util.getFullyQualifiedClassName(lowerName, containingNamespace)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
         const classMap = this.getClassMap();
-        let cls = classMap.get(util_1.util.getFullyQualifiedClassName(lowerClassName, containingNamespace === null || containingNamespace === void 0 ? void 0 : containingNamespace.toLowerCase()));
+        let cls = classMap.get(fullNameLower);
         //if we couldn't find the class by its full namespaced name, look for a global class with that name
-        if (!cls) {
-            cls = classMap.get(lowerClassName);
+        if (!cls && lowerName && lowerName !== fullNameLower) {
+            cls = classMap.get(lowerName);
         }
         return cls;
     }
     /**
-    * Tests if a class exists with the specified name
-    * @param className - the all-lower-case namespace-included class name
-    * @param containingNamespace - The namespace used to resolve relative class names. (i.e. the namespace around the current statement trying to find a class)
-    */
+     * Get an interface and its containing file by the interface name
+     * @param ifaceName - The interface name, including the namespace of the interface if possible
+     * @param containingNamespace - The namespace used to resolve relative interface names. (i.e. the namespace around the current statement trying to find a interface)
+     */
+    getInterfaceFileLink(ifaceName, containingNamespace) {
+        var _a;
+        if (this.useFileCachesForFileLinkLookups) {
+            return this.getFileLinkFromFileMap('interfaceStatementMap', ifaceName, containingNamespace);
+        }
+        const lowerName = ifaceName === null || ifaceName === void 0 ? void 0 : ifaceName.toLowerCase();
+        const fullNameLower = (_a = util_1.util.getFullyQualifiedClassName(lowerName, containingNamespace)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        const ifaceMap = this.getInterfaceMap();
+        let iface = ifaceMap.get(fullNameLower);
+        //if we couldn't find the iface by its full namespaced name, look for a global class with that name
+        if (!iface && lowerName && lowerName !== fullNameLower) {
+            iface = ifaceMap.get(lowerName);
+        }
+        return iface;
+    }
+    /**
+     * Get an Enum and its containing file by the Enum name
+     * @param enumName - The Enum name, including the namespace of the enum if possible
+     * @param containingNamespace - The namespace used to resolve relative enum names. (i.e. the namespace around the current statement trying to find a enum)
+     */
+    getEnumFileLink(enumName, containingNamespace) {
+        var _a;
+        if (this.useFileCachesForFileLinkLookups) {
+            return this.getFileLinkFromFileMap('enumStatementMap', enumName, containingNamespace);
+        }
+        const lowerName = enumName === null || enumName === void 0 ? void 0 : enumName.toLowerCase();
+        const fullNameLower = (_a = util_1.util.getFullyQualifiedClassName(lowerName, containingNamespace)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        const enumMap = this.getEnumMap();
+        let enumeration = enumMap.get(fullNameLower);
+        //if we couldn't find the enum by its full namespaced name, look for a global enum with that name
+        if (!enumeration && lowerName && lowerName !== fullNameLower) {
+            enumeration = enumMap.get(lowerName);
+        }
+        return enumeration;
+    }
+    /**
+     * Get an Enum and its containing file by the Enum name
+     * @param enumMemberName - The Enum name, including the namespace of the enum if possible
+     * @param containingNamespace - The namespace used to resolve relative enum names. (i.e. the namespace around the current statement trying to find a enum)
+     */
+    getEnumMemberFileLink(enumMemberName, containingNamespace) {
+        var _a, _b;
+        let lowerNameParts = (_a = enumMemberName === null || enumMemberName === void 0 ? void 0 : enumMemberName.toLowerCase()) === null || _a === void 0 ? void 0 : _a.split('.');
+        let memberName = (_b = lowerNameParts === null || lowerNameParts === void 0 ? void 0 : lowerNameParts.splice(lowerNameParts.length - 1, 1)) === null || _b === void 0 ? void 0 : _b[0];
+        let lowerName = lowerNameParts === null || lowerNameParts === void 0 ? void 0 : lowerNameParts.join('.').toLowerCase();
+        const enumMap = this.getEnumMap();
+        let enumeration = enumMap.get(util_1.util.getFullyQualifiedClassName(lowerName, containingNamespace === null || containingNamespace === void 0 ? void 0 : containingNamespace.toLowerCase()));
+        //if we couldn't find the enum by its full namespaced name, look for a global enum with that name
+        if (!enumeration) {
+            enumeration = enumMap.get(lowerName);
+        }
+        if (enumeration) {
+            let member = enumeration.item.findChild((child) => { var _a; return (0, reflection_1.isEnumMemberStatement)(child) && ((_a = child.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === memberName; });
+            return member ? { item: member, file: enumeration.file } : undefined;
+        }
+    }
+    /**
+     * Get a constant and its containing file by the constant name
+     * @param constName - The constant name, including the namespace of the constant if possible
+     * @param containingNamespace - The namespace used to resolve relative constant names. (i.e. the namespace around the current statement trying to find a constant)
+     */
+    getConstFileLink(constName, containingNamespace) {
+        var _a;
+        if (this.useFileCachesForFileLinkLookups) {
+            return this.getFileLinkFromFileMap('constStatementMap', constName, containingNamespace);
+        }
+        const lowerName = constName === null || constName === void 0 ? void 0 : constName.toLowerCase();
+        const fullNameLower = (_a = util_1.util.getFullyQualifiedClassName(lowerName, containingNamespace)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        const constMap = this.getConstMap();
+        let result = constMap.get(fullNameLower);
+        //if we couldn't find the constant by its full namespaced name, look for a global constant with that name
+        if (!result && lowerName !== fullNameLower) {
+            result = constMap.get(lowerName);
+        }
+        return result;
+    }
+    getAllFileLinks(name, containingNamespace, includeNamespaces = false, includeNameShadowsOutsideNamespace = false) {
+        var _a;
+        let links = [];
+        links.push(this.getClassFileLink(name, containingNamespace), this.getInterfaceFileLink(name, containingNamespace), this.getConstFileLink(name, containingNamespace), this.getEnumFileLink(name, containingNamespace));
+        if (includeNameShadowsOutsideNamespace && containingNamespace) {
+            links.push(this.getClassFileLink(name), this.getInterfaceFileLink(name), this.getConstFileLink(name), this.getEnumFileLink(name));
+        }
+        if (includeNamespaces) {
+            const nameSpaceContainer = this.getFirstNamespaceWithRoot(name, containingNamespace);
+            if (nameSpaceContainer) {
+                links.push({ item: (_a = nameSpaceContainer.namespaceStatements) === null || _a === void 0 ? void 0 : _a[0], file: nameSpaceContainer === null || nameSpaceContainer === void 0 ? void 0 : nameSpaceContainer.file });
+            }
+        }
+        const fullNameLower = (containingNamespace ? `${containingNamespace}.${name}` : name).toLowerCase();
+        const callable = this.getCallableByName(name);
+        if (callable) {
+            if ((!callable.hasNamespace && includeNameShadowsOutsideNamespace) || callable.getName(Parser_1.ParseMode.BrighterScript).toLowerCase() === fullNameLower) {
+                // this callable has no namespace, or has same namespace
+                links.push({ item: callable.functionStatement, file: callable.file });
+            }
+        }
+        // remove empty links
+        return links.filter(link => link);
+    }
+    /**
+     * Get an TypeStatement and its containing file by the type name
+     * @param typeName - The TypeStatement name, including the namespace of the type if possible
+     * @param containingNamespace - The namespace used to resolve relative type names. (i.e. the namespace around the current statement trying to find a type)
+     */
+    getTypeStatementFileLink(typeName, containingNamespace) {
+        const lowerName = typeName === null || typeName === void 0 ? void 0 : typeName.toLowerCase();
+        const typeStatementMap = this.getTypeStatementMap();
+        let typeStatement = typeStatementMap.get(util_1.util.getFullyQualifiedClassName(lowerName, containingNamespace === null || containingNamespace === void 0 ? void 0 : containingNamespace.toLowerCase()));
+        //if we couldn't find the enum by its full namespaced name, look for a global enum with that name
+        if (!typeStatement) {
+            typeStatement = typeStatementMap.get(lowerName);
+        }
+        return typeStatement;
+    }
+    /**
+     * Get a map of all enums by their member name.
+     * The keys are lower-case fully-qualified paths to the enum and its member. For example:
+     * namespace.enum.value
+     */
+    getEnumMemberMap() {
+        return this.cache.getOrAdd('enumMemberMap', () => {
+            const result = new Map();
+            for (const [key, eenum] of this.getEnumMap()) {
+                for (const member of eenum.item.getMembers()) {
+                    result.set(`${key}.${member.name.toLowerCase()}`, member);
+                }
+            }
+            return result;
+        });
+    }
+    /**
+     * Tests if a class exists with the specified name
+     * @param className - the all-lower-case namespace-included class name
+     * @param namespaceName - The namespace used to resolve relative class names. (i.e. the namespace around the current statement trying to find a class)
+     */
     hasClass(className, namespaceName) {
         return !!this.getClass(className, namespaceName);
     }
+    /**
+     * Tests if an interface exists with the specified name
+     * @param ifaceName - the all-lower-case namespace-included interface name
+     * @param namespaceName - the current namespace name
+     */
+    hasInterface(ifaceName, namespaceName) {
+        return !!this.getInterface(ifaceName, namespaceName);
+    }
+    /**
+     * Tests if an enum exists with the specified name
+     * @param enumName - the all-lower-case namespace-included enum name
+     * @param namespaceName - the current namespace name
+     */
+    hasEnum(enumName, namespaceName) {
+        return !!this.getEnum(enumName, namespaceName);
+    }
+    hasTypeStatementType(typeName, namespaceName) {
+        return !!this.getTypeStatement(typeName, namespaceName);
+    }
     /**
      * A dictionary of all classes in this scope. This includes namespaced classes always with their full name.
      * The key is stored in lower case
@@ -81,13 +377,12 @@ class Scope {
         return this.cache.getOrAdd('classMap', () => {
             const map = new Map();
             this.enumerateBrsFiles((file) => {
-                var _a;
-                if (reflection_1.isBrsFile(file)) {
-                    for (let cls of file.parser.references.classStatements) {
-                        const lowerClassName = (_a = cls.getName(parser_1.ParseMode.BrighterScript)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+                if ((0, reflection_1.isBrsFile)(file)) {
+                    for (let cls of file['_cachedLookups'].classStatements) {
+                        const className = cls.getName(Parser_1.ParseMode.BrighterScript);
                         //only track classes with a defined name (i.e. exclude nameless malformed classes)
-                        if (lowerClassName) {
-                            map.set(lowerClassName, { item: cls, file: file });
+                        if (className) {
+                            map.set(className.toLowerCase(), { item: cls, file: file });
                         }
                     }
                 }
@@ -95,6 +390,86 @@ class Scope {
             return map;
         });
     }
+    /**
+     * A dictionary of all Interfaces in this scope. This includes namespaced Interfaces always with their full name.
+     * The key is stored in lower case
+     */
+    getInterfaceMap() {
+        return this.cache.getOrAdd('interfaceMap', () => {
+            const map = new Map();
+            this.enumerateBrsFiles((file) => {
+                if ((0, reflection_1.isBrsFile)(file)) {
+                    for (let iface of file['_cachedLookups'].interfaceStatements) {
+                        const ifaceName = iface.getName(Parser_1.ParseMode.BrighterScript);
+                        //only track classes with a defined name (i.e. exclude nameless malformed classes)
+                        if (ifaceName) {
+                            map.set(ifaceName.toLowerCase(), { item: iface, file: file });
+                        }
+                    }
+                }
+            });
+            return map;
+        });
+    }
+    /**
+     * A dictionary of all enums in this scope. This includes namespaced enums always with their full name.
+     * The key is stored in lower case
+     */
+    getEnumMap() {
+        return this.cache.getOrAdd('enumMap', () => {
+            const map = new Map();
+            this.enumerateBrsFiles((file) => {
+                for (let enumStmt of file['_cachedLookups'].enumStatements) {
+                    //only track enums with a defined name (i.e. exclude nameless malformed enums)
+                    if (enumStmt.fullName) {
+                        map.set(enumStmt.fullName.toLowerCase(), { item: enumStmt, file: file });
+                    }
+                }
+            });
+            return map;
+        });
+    }
+    /**
+     * A dictionary of all constants in this scope. This includes namespaced constants always with their full name.
+     * The key is stored in lower case
+     */
+    getConstMap() {
+        return this.cache.getOrAdd('constMap', () => {
+            const map = new Map();
+            this.enumerateBrsFiles((file) => {
+                for (let stmt of file['_cachedLookups'].constStatements) {
+                    //only track enums with a defined name (i.e. exclude nameless malformed enums)
+                    if (stmt.fullName) {
+                        map.set(stmt.fullName.toLowerCase(), { item: stmt, file: file });
+                    }
+                }
+            });
+            return map;
+        });
+    }
+    /**
+     * A dictionary of all TypeStatements in this scope. This includes namespaced types always with their full name.
+     * The key is stored in lower case
+     */
+    getTypeStatementMap() {
+        return this.cache.getOrAdd('typeStatementMap', () => {
+            const map = new Map();
+            this.enumerateBrsFiles((file) => {
+                file.ast.walk((node) => {
+                    var _a, _b;
+                    if ((0, reflection_1.isTypeStatement)(node)) {
+                        const namespaceName = (_a = node.findAncestor(reflection_1.isNamespaceStatement)) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript);
+                        const typeName = (_b = node.tokens.name) === null || _b === void 0 ? void 0 : _b.text;
+                        if (typeName) {
+                            const fullName = (namespaceName ? `${namespaceName}.${typeName}` : typeName).toLowerCase();
+                            map.set(fullName, { item: node, file: file });
+                        }
+                    }
+                }, { walkMode: visitors_1.WalkMode.visitAllRecursive });
+            });
+            return map;
+        });
+    }
     onDependenciesChanged(event) {
         this.logDebug('invalidated because dependency graph said [', event.sourceKey, '] changed');
         this.invalidate();
@@ -104,6 +479,8 @@ class Scope {
      */
     dispose() {
         var _a;
+        this.unlinkSymbolTable();
+        this.cache.clear();
         (_a = this.unsubscribeFromDependencyGraph) === null || _a === void 0 ? void 0 : _a.call(this);
     }
     /**
@@ -113,7 +490,7 @@ class Scope {
     isKnownNamespace(namespaceName) {
         let namespaceNameLower = namespaceName.toLowerCase();
         this.enumerateBrsFiles((file) => {
-            for (let namespace of file.parser.references.namespaceStatements) {
+            for (let namespace of file['_cachedLookups'].namespaceStatements) {
                 let loopNamespaceNameLower = namespace.name.toLowerCase();
                 if (loopNamespaceNameLower === namespaceNameLower || loopNamespaceNameLower.startsWith(namespaceNameLower + '.')) {
                     return true;
@@ -152,20 +529,23 @@ class Scope {
         this.invalidate();
     }
     /**
-     * Get the file with the specified pkgPath
-     * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `pkg:/`)
+     * Get the file from this scope with the given path.
+     * @param filePath can be a srcPath or destPath
      * @param normalizePath should this function repair and standardize the path? Passing false should have a performance boost if you can guarantee your path is already sanitized
      */
-    getFile(srcPath, normalizePath = true) {
-        if (normalizePath) {
-            srcPath = util_1.standardizePath `${srcPath}`;
+    getFile(filePath, normalizePath = true) {
+        if (typeof filePath !== 'string') {
+            return undefined;
         }
-        let files = this.getAllFiles();
-        for (let file of files) {
-            if (file.srcPath === srcPath) {
-                return file;
+        const key = path.isAbsolute(filePath) ? 'srcPath' : 'destPath';
+        let map = this.cache.getOrAdd('fileMaps-srcPath', () => {
+            const result = new Map();
+            for (const file of this.getAllFiles()) {
+                result.set(file[key].toLowerCase(), file);
             }
-        }
+            return result;
+        });
+        return map.get((normalizePath ? util_1.util.standardizePath(filePath) : filePath).toLowerCase());
     }
     /**
      * Get the list of files referenced by this scope that are actually loaded in the program.
@@ -186,41 +566,50 @@ class Scope {
             for (let dependency of dependencies) {
                 //load components by their name
                 if (dependency.startsWith('component:')) {
-                    let comp = this.program.getComponent(dependency.replace(/$component:/, ''));
+                    let comp = this.program.getComponent(dependency.replace(/^component:/, ''));
                     if (comp) {
                         result.push(comp.file);
                     }
                 }
                 else {
-                    let file = this.program.getFile(dependency, false);
+                    let file = this.program.getFile(dependency);
                     if (file) {
                         result.push(file);
                     }
                 }
             }
-            this.logDebug('getAllFiles', () => result.map(x => x.pkgPath));
             return result;
         });
     }
     /**
-     * Get the list of errors for this scope. It's calculated on the fly, so
-     * call this sparingly.
+     * Gets a list of all files in this scope, but not imported files, and not from ancestor scopes
      */
-    getDiagnostics() {
-        let diagnosticLists = [this.diagnostics];
-        //add diagnostics from every referenced file
-        this.enumerateOwnFiles((file) => {
-            diagnosticLists.push(file.getDiagnostics());
-        });
-        let allDiagnostics = Array.prototype.concat.apply([], diagnosticLists);
-        let filteredDiagnostics = allDiagnostics.filter((x) => {
-            return !util_1.util.diagnosticIsSuppressed(x);
+    getImmediateFiles() {
+        return this.cache.getOrAdd('getImmediateFiles', () => {
+            let result = [];
+            if ((0, reflection_1.isXmlScope)(this)) {
+                result.push(this.xmlFile);
+            }
+            let dependencies = this.dependencyGraph.getImmediateDependencies(this.dependencyGraphKey);
+            for (let dependency of dependencies) {
+                //load components by their name
+                if (dependency.startsWith('component:')) {
+                    let comp = this.program.getComponent(dependency.replace(/^component:/, ''));
+                    if (comp) {
+                        result.push(...comp.scope.getImmediateFiles());
+                        result.push(comp.file);
+                    }
+                }
+                else {
+                    let file = this.program.getFile(dependency);
+                    if (file) {
+                        result.push(file);
+                    }
+                }
+            }
+            this.logDebug('getImmediateFiles', () => result.map(x => x.destPath));
+            return result;
         });
-        //filter out diangostics that match any of the comment flags
-        return filteredDiagnostics;
-    }
-    addDiagnostics(diagnostics) {
-        this.diagnostics.push(...diagnostics);
     }
     /**
      * Get the list of callables available in this scope (either declared in this scope or in a parent scope)
@@ -238,16 +627,30 @@ class Scope {
     /**
      * Get the callable with the specified name.
      * If there are overridden callables with the same name, the closest callable to this scope is returned
-     * @param name
      */
     getCallableByName(name) {
-        let lowerName = name.toLowerCase();
-        let callables = this.getAllCallables();
-        for (let callable of callables) {
-            if (callable.callable.getName(parser_1.ParseMode.BrighterScript).toLowerCase() === lowerName) {
-                return callable.callable;
+        return this.getCallableMap().get(name.toLowerCase());
+    }
+    getCallableMap() {
+        return this.cache.getOrAdd('callableMap', () => {
+            var _a, _b;
+            const result = new Map();
+            for (let callable of this.getAllCallables()) {
+                const callableName = (_a = callable.callable.getName(Parser_1.ParseMode.BrighterScript)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+                result.set(callableName, callable.callable);
+                result.set(
+                // Split by `.` and check the last term to consider namespaces.
+                (_b = callableName.split('.').pop()) === null || _b === void 0 ? void 0 : _b.toLowerCase(), callable.callable);
             }
-        }
+            return result;
+        });
+    }
+    getCallableContainerMap() {
+        return this.cache.getOrAdd('callableContainerMap', () => {
+            let callables = this.getAllCallables();
+            //get a list of all callables, indexed by their lower case names
+            return util_1.util.getCallableContainersByLowerName(callables);
+        });
     }
     /**
      * Iterate over Brs files not shadowed by typedefs
@@ -256,11 +659,25 @@ class Scope {
         const files = this.getAllFiles();
         for (const file of files) {
             //only brs files without a typedef
-            if (reflection_1.isBrsFile(file) && !file.hasTypedef) {
+            if ((0, reflection_1.isBrsFile)(file) && !file.hasTypedef) {
                 callback(file);
             }
         }
     }
+    /**
+     * Iterate over Brs files not shadowed by typedefs
+     */
+    enumerateBrsFilesWithBreak(callback) {
+        const files = this.getAllFiles();
+        for (const file of files) {
+            //only brs files without a typedef
+            if ((0, reflection_1.isBrsFile)(file) && !file.hasTypedef) {
+                if (callback(file)) {
+                    break;
+                }
+            }
+        }
+    }
     /**
      * Call a function for each file directly included in this scope (excluding files found only in parent scopes).
      */
@@ -268,7 +685,7 @@ class Scope {
         const files = this.getOwnFiles();
         for (const file of files) {
             //either XML components or files without a typedef
-            if (reflection_1.isXmlFile(file) || !file.hasTypedef) {
+            if ((0, reflection_1.isXmlFile)(file) || ((0, reflection_1.isBrsFile)(file) && !file.hasTypedef)) {
                 callback(file);
             }
         }
@@ -279,130 +696,104 @@ class Scope {
      */
     getOwnCallables() {
         let result = [];
-        this.logDebug('getOwnCallables() files: ', () => this.getOwnFiles().map(x => x.pkgPath));
         //get callables from own files
         this.enumerateOwnFiles((file) => {
-            for (let callable of file.callables) {
-                result.push({
-                    callable: callable,
-                    scope: this
-                });
+            var _a;
+            if ((0, reflection_1.isBrsFile)(file)) {
+                for (let callable of (_a = file === null || file === void 0 ? void 0 : file.callables) !== null && _a !== void 0 ? _a : []) {
+                    result.push({
+                        callable: callable,
+                        scope: this
+                    });
+                }
             }
         });
         return result;
     }
     /**
-     * Builds a tree of namespace objects
+     * Build the namespace lookup for this scope.
+     *
+     * The lookup is now backed by `ScopeNamespaceLookup`, which queries the
+     * Program-level `getNamespaceContributors` map lazily on each
+     * `.get(name)` call. Per-file contributions are pre-built by
+     * `BrsFile.getNamespaceContributions` and shared across every scope that
+     * pulls in the file, so single-contribution containers reuse the file's
+     * pre-built statement collections and symbolTable instead of allocating
+     * per-scope copies.
+     *
+     * The return type is `Map<string, NamespaceContainer>` for backward
+     * compatibility with plugins that consume the public API.
      */
     buildNamespaceLookup() {
-        let namespaceLookup = {};
-        this.enumerateBrsFiles((file) => {
-            var _a;
-            for (let namespace of file.parser.references.namespaceStatements) {
-                //TODO should we handle non-brighterscript?
-                let name = namespace.nameExpression.getName(parser_1.ParseMode.BrighterScript);
-                let nameParts = name.split('.');
-                let loopName = null;
-                //ensure each namespace section is represented in the results
-                //(so if the namespace name is A.B.C, this will make an entry for "A", an entry for "A.B", and an entry for "A.B.C"
-                for (let part of nameParts) {
-                    loopName = loopName === null ? part : `${loopName}.${part}`;
-                    let lowerLoopName = loopName.toLowerCase();
-                    namespaceLookup[lowerLoopName] = (_a = namespaceLookup[lowerLoopName]) !== null && _a !== void 0 ? _a : {
-                        file: file,
-                        fullName: loopName,
-                        nameRange: namespace.nameExpression.range,
-                        lastPartName: part,
-                        namespaces: {},
-                        classStatements: {},
-                        functionStatements: {},
-                        statements: [],
-                        symbolTable: new SymbolTable_1.SymbolTable(this.symbolTable)
-                    };
-                }
-                let ns = namespaceLookup[name.toLowerCase()];
-                ns.statements.push(...namespace.body.statements);
-                for (let statement of namespace.body.statements) {
-                    if (reflection_1.isClassStatement(statement) && statement.name) {
-                        ns.classStatements[statement.name.text.toLowerCase()] = statement;
-                    }
-                    else if (reflection_1.isFunctionStatement(statement) && statement.name) {
-                        ns.functionStatements[statement.name.text.toLowerCase()] = statement;
-                    }
-                }
-                // Merges all the symbol tables of the namespace statements into the new symbol table created above.
-                // Set those symbol tables to have this new merged table as a parent
-                ns.symbolTable.mergeSymbolTable(namespace.symbolTable);
-            }
-            //associate child namespaces with their parents
-            for (let key in namespaceLookup) {
-                let ns = namespaceLookup[key];
-                let parts = ns.fullName.split('.');
-                if (parts.length > 1) {
-                    //remove the last part
-                    parts.pop();
-                    let parentName = parts.join('.');
-                    namespaceLookup[parentName.toLowerCase()].namespaces[ns.lastPartName.toLowerCase()] = ns;
-                }
-            }
-        });
-        return namespaceLookup;
+        return new ScopeNamespaceLookup_1.ScopeNamespaceLookup(this);
     }
     getAllNamespaceStatements() {
         let result = [];
         this.enumerateBrsFiles((file) => {
-            result.push(...file.parser.references.namespaceStatements);
+            result.push(...file['_cachedLookups'].namespaceStatements);
         });
         return result;
     }
     logDebug(...args) {
         this.program.logger.debug(this._debugLogComponentName, ...args);
     }
-    validate() {
-        this.program.logger.time(Logger_1.LogLevel.debug, [this._debugLogComponentName, 'validate()'], () => {
+    shouldValidate(validationOptions = { force: false }) {
+        var _a;
+        //if this scope is already validated, no need to revalidate
+        if (this.isValidated === true && !validationOptions.force) {
+            this.logDebug('validate(): already validated');
+            return false;
+        }
+        if (!validationOptions.initialValidation && ((_a = validationOptions.filesToBeValidatedInScopeContext) === null || _a === void 0 ? void 0 : _a.size) === 0) {
+            // There was no need to validate this scope.
+            this.isValidated = true;
+            return false;
+        }
+        return true;
+    }
+    validate(validationOptions = { force: false }) {
+        var _a;
+        this.validationMetrics = {
+            linkTime: 0,
+            validationTime: 0
+        };
+        //if this scope is already validated, no need to revalidate
+        if (!this.shouldValidate(validationOptions)) {
+            this.logDebug('validate(): already validated');
+            // There was no need to validate this scope.
+            this.isValidated = true;
+            return false;
+        }
+        this.useFileCachesForFileLinkLookups = !validationOptions.initialValidation;
+        this.program.logger.time(logging_1.LogLevel.debug, [this._debugLogComponentName, 'validate()'], () => {
+            var _a;
             let parentScope = this.getParentScope();
             //validate our parent before we validate ourself
-            if ((parentScope === null || parentScope === void 0 ? void 0 : parentScope.isValidated) === false) {
+            if (parentScope && parentScope.isValidated === false) {
                 this.logDebug('validate(): validating parent first');
-                parentScope.validate();
+                parentScope.validate(validationOptions);
             }
-            //clear the scope's errors list (we will populate them from this method)
-            this.diagnostics = [];
-            // link the symbol table
+            //Since statements from files are shared across multiple scopes, we need to link those statements to the current scope
+            let t0 = perf_hooks_1.performance.now();
             this.linkSymbolTable();
-            let callables = this.getAllCallables();
-            //sort the callables by filepath and then method name, so the errors will be consistent
-            callables = callables.sort((a, b) => {
-                return (
-                //sort by path
-                a.callable.file.srcPath.localeCompare(b.callable.file.srcPath) ||
-                    //then sort by method name
-                    a.callable.name.localeCompare(b.callable.name));
-            });
-            //get a list of all callables, indexed by their lower case names
-            let callableContainerMap = util_1.util.getCallableContainersByLowerName(callables);
-            this._validate(callableContainerMap);
-            // unlink the symbol table so it can't be accessed from the wrong scope
+            this.validationMetrics.linkTime = perf_hooks_1.performance.now() - t0;
+            const scopeValidateEvent = {
+                program: this.program,
+                scope: this,
+                changedFiles: (_a = validationOptions === null || validationOptions === void 0 ? void 0 : validationOptions.changedFiles) !== null && _a !== void 0 ? _a : [],
+                changedSymbols: validationOptions === null || validationOptions === void 0 ? void 0 : validationOptions.changedSymbols
+            };
+            t0 = perf_hooks_1.performance.now();
+            this.program.plugins.emit('validateScope', scopeValidateEvent);
+            this.validationMetrics.validationTime = perf_hooks_1.performance.now() - t0;
+            //unlink all symbol tables from this scope (so they don't accidentally stick around)
             this.unlinkSymbolTable();
+            this.isValidated = true;
         });
-    }
-    _validate(callableContainerMap) {
-        //find all duplicate function declarations
-        this.diagnosticFindDuplicateFunctionDeclarations(callableContainerMap);
-        //detect missing and incorrect-case script imports
-        this.diagnosticValidateScriptImportPaths();
-        //enforce a series of checks on the bodies of class methods
-        this.validateClasses();
-        //do many per-file checks
-        this.enumerateBrsFiles((file) => {
-            this.diagnosticDetectCallsToUnknownFunctions(file, callableContainerMap);
-            this.diagnosticDetectFunctionCallsWithWrongParamCount(file, callableContainerMap);
-            this.diagnosticDetectShadowedLocalVars(file, callableContainerMap);
-            this.diagnosticDetectFunctionCollisions(file);
-            this.detectVariableNamespaceCollisions(file);
-            this.diagnosticDetectInvalidFunctionExpressionTypes(file);
-            this.diagnosticDetectInvalidFunctionCalls(file);
-        });
+        for (let file of this.getAllFiles()) {
+            (_a = validationOptions.filesToBeValidatedInScopeContext) === null || _a === void 0 ? void 0 : _a.delete(file);
+        }
+        return true;
     }
     /**
      * Mark this scope as invalid, which means its `validate()` function needs to be called again before use.
@@ -411,318 +802,77 @@ class Scope {
         this.isValidated = false;
         //clear out various lookups (they'll get regenerated on demand the next time they're requested)
         this.cache.clear();
-        this.clearSymbolTable();
     }
     get symbolTable() {
-        var _a, _b;
-        if (!this._symbolTable) {
-            this._symbolTable = new SymbolTable_1.SymbolTable((_a = this.getParentScope()) === null || _a === void 0 ? void 0 : _a.symbolTable);
+        return this.cache.getOrAdd('symbolTable', () => {
+            var _a;
+            const result = new SymbolTable_1.SymbolTable(`Scope: '${this.name}'`, () => { var _a; return (_a = this.getParentScope()) === null || _a === void 0 ? void 0 : _a.symbolTable; });
+            result.addSymbol('m', undefined, new AssociativeArrayType_1.AssociativeArrayType(), 1 /* SymbolTypeFlag.runtime */);
             for (let file of this.getOwnFiles()) {
-                if (reflection_1.isBrsFile(file)) {
-                    this._symbolTable.mergeSymbolTable((_b = file.parser) === null || _b === void 0 ? void 0 : _b.symbolTable);
+                if ((0, reflection_1.isBrsFile)(file)) {
+                    result.mergeSymbolTable((_a = file.parser) === null || _a === void 0 ? void 0 : _a.symbolTable);
                 }
             }
-        }
-        return this._symbolTable;
-    }
-    clearSymbolTable() {
-        this._symbolTable = null;
+            return result;
+        });
     }
-    /**
-    * Builds the current symbol table for the scope, by merging the tables for all the files in this scope.
-    * Also links all file symbols tables to this new table
-    * This will only rebuilt if the symbol table has not been built before
-    */
+    get allNamespaceTypeTable() {
+        return this._allNamespaceTypeTable;
+    }
+    /**
+     * Builds the current symbol table for the scope, by merging the tables for all the files in this scope.
+     * Also links all file symbols tables to this new table
+     * This will only rebuilt if the symbol table has not been built before
+     *
+     *  Tree of symbol tables:
+     *  ```
+     *  Global Scope Symbol Table
+     *      -  Source Scope Symbol Table :: Aggregate Namespaces Symbol Table (Siblings)
+     *          - File 1 Symbol Table
+     *          - File 2 Symbol Table
+     *      -  Component A Scope Symbol Table :: Aggregate Namespaces Symbol Table (Siblings)
+     *          - File 1 Symbol Table
+     *          - File 2 Symbol Table
+     *      -  Component B Scope Symbol Table :: Aggregate Namespaces Symbol Table (Siblings)
+     *          - File 1 Symbol Table
+     *          - File 2 Symbol Table
+     * ```
+     */
     linkSymbolTable() {
         var _a;
-        for (const file of this.getOwnFiles()) {
-            if (reflection_1.isBrsFile(file)) {
-                (_a = file.parser) === null || _a === void 0 ? void 0 : _a.symbolTable.setParent(this.symbolTable);
-                for (const namespace of file.parser.references.namespaceStatements) {
-                    const namespaceNameLower = namespace.nameExpression.getName(parser_1.ParseMode.BrighterScript).toLowerCase();
-                    const namespaceSymbolTable = this.namespaceLookup[namespaceNameLower].symbolTable;
-                    namespace.symbolTable.setParent(namespaceSymbolTable);
-                }
-            }
-        }
-    }
-    unlinkSymbolTable() {
-        var _a;
-        for (let file of this.getOwnFiles()) {
-            if (reflection_1.isBrsFile(file)) {
-                (_a = file.parser) === null || _a === void 0 ? void 0 : _a.symbolTable.setParent(null);
-                for (const namespace of file.parser.references.namespaceStatements) {
-                    namespace.symbolTable.setParent(null);
-                }
-            }
-        }
-    }
-    detectVariableNamespaceCollisions(file) {
-        //find all function parameters
-        for (let func of file.parser.references.functionExpressions) {
-            for (let param of func.parameters) {
-                let lowerParamName = param.name.text.toLowerCase();
-                let namespace = this.namespaceLookup[lowerParamName];
-                //see if the param matches any starting namespace part
-                if (namespace) {
-                    this.diagnostics.push(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.parameterMayNotHaveSameNameAsNamespace(param.name.text)), { range: param.name.range, relatedInformation: [{
-                                message: 'Namespace declared here',
-                                location: vscode_languageserver_1.Location.create(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
-                            }] }));
-                }
-            }
-        }
-        for (let assignment of file.parser.references.assignmentStatements) {
-            let lowerAssignmentName = assignment.name.text.toLowerCase();
-            let namespace = this.namespaceLookup[lowerAssignmentName];
-            //see if the param matches any starting namespace part
-            if (namespace) {
-                this.diagnostics.push(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.variableMayNotHaveSameNameAsNamespace(assignment.name.text)), { range: assignment.name.range, relatedInformation: [{
-                            message: 'Namespace declared here',
-                            location: vscode_languageserver_1.Location.create(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
-                        }] }));
-            }
-        }
-    }
-    /**
-     * Find various function collisions
-     */
-    diagnosticDetectFunctionCollisions(file) {
-        for (let func of file.callables) {
-            const funcName = func.getName(parser_1.ParseMode.BrighterScript);
-            const lowerFuncName = funcName === null || funcName === void 0 ? void 0 : funcName.toLowerCase();
-            if (lowerFuncName) {
-                //find function declarations with the same name as a stdlib function
-                if (globalCallables_1.globalCallableMap.has(lowerFuncName)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.scopeFunctionShadowedByBuiltInFunction()), { range: func.nameRange, file: file }));
-                }
-                //find any functions that have the same name as a class
-                if (this.hasClass(lowerFuncName)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionCannotHaveSameNameAsClass(funcName)), { range: func.nameRange, file: file }));
-                }
-            }
-        }
-    }
-    /**
-    * Find function parameters and function return types that are neither built-in types or known Class references
-    */
-    diagnosticDetectInvalidFunctionExpressionTypes(file) {
-        var _a, _b;
-        for (let func of file.parser.references.functionExpressions) {
-            if (reflection_1.isCustomType(func.returnType) && func.returnTypeToken) {
-                // check if this custom type is in our class map
-                const returnTypeName = func.returnType.name;
-                const currentNamespaceName = (_a = func.namespaceName) === null || _a === void 0 ? void 0 : _a.getName(parser_1.ParseMode.BrighterScript);
-                if (!this.hasClass(returnTypeName, currentNamespaceName)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidFunctionReturnType(returnTypeName)), { range: func.returnTypeToken.range, file: file }));
-                }
-            }
-            for (let param of func.parameters) {
-                if (reflection_1.isCustomType(param.type) && param.typeToken) {
-                    const paramTypeName = param.type.name;
-                    const currentNamespaceName = (_b = func.namespaceName) === null || _b === void 0 ? void 0 : _b.getName(parser_1.ParseMode.BrighterScript);
-                    if (!this.hasClass(paramTypeName, currentNamespaceName)) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(param.name.text, paramTypeName)), { range: param.typeToken.range, file: file }));
+        SymbolTable_1.SymbolTable.cacheVerifier.generateToken();
+        this._allNamespaceTypeTable = new SymbolTable_1.SymbolTable(`Scope NamespaceTypes ${this.name}`);
+        for (const file of this.getAllFiles()) {
+            if ((0, reflection_1.isBrsFile)(file)) {
+                this.linkSymbolTableDisposables.push(file.parser.symbolTable.pushParentProvider(() => this.symbolTable));
+                //link each NamespaceStatement's SymbolTable with the aggregate NamespaceLookup SymbolTable.
+                //Leaf containers always have symbolTable populated, so the lookup below is safe; the null
+                //guard tolerates edge cases like a namespace that failed to register.
+                for (const namespace of file['_cachedLookups'].namespaceStatements) {
+                    const namespaceNameLower = namespace.getName(Parser_1.ParseMode.BrighterScript).toLowerCase();
+                    const aggregate = (_a = this.namespaceLookup.get(namespaceNameLower)) === null || _a === void 0 ? void 0 : _a.symbolTable;
+                    if (aggregate) {
+                        this.linkSymbolTableDisposables.push(namespace.getSymbolTable().addSibling(aggregate));
                     }
                 }
             }
         }
-    }
-    diagnosticDetectInvalidFunctionCalls(file) {
-        for (let expCall of file.functionCalls) {
-            const funcType = expCall.functionExpression.symbolTable.getSymbolType(expCall.name);
-            if (!reflection_1.isFunctionType(funcType)) {
-                // can not find function. Handled in a different validation function
-                continue;
-            }
-            if (funcType.params.length !== expCall.args.length) {
-                // Argument count mismatch. Handled in a different validation function
-                continue;
-            }
-            for (let index = 0; index < funcType.params.length; index++) {
-                const param = funcType.params[index];
-                const arg = expCall.args[index];
-                const argType = arg.type;
-                if (!argType.isAssignableTo(param.type)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.argumentTypeMismatch(arg.type.toTypeString(), param.type.toTypeString())), { range: arg.range, file: file }));
-                }
-            }
-        }
-    }
-    getNewExpressions() {
-        let result = [];
         this.enumerateBrsFiles((file) => {
-            let expressions = file.parser.references.newExpressions;
-            for (let expression of expressions) {
-                expression.file = file;
-                result.push(expression);
-            }
+            const namespaceTypes = file.getNamespaceSymbolTable();
+            this.linkSymbolTableDisposables.push(...this._allNamespaceTypeTable.mergeNamespaceSymbolTables(namespaceTypes));
         });
-        return result;
-    }
-    validateClasses() {
-        let validator = new ClassValidator_1.BsClassValidator();
-        validator.validate(this);
-        this.diagnostics.push(...validator.diagnostics);
-    }
-    /**
-     * Detect calls to functions with the incorrect number of parameters
-     * @param file
-     * @param callableContainersByLowerName
-     */
-    diagnosticDetectFunctionCallsWithWrongParamCount(file, callableContainersByLowerName) {
-        //validate all function calls
-        for (let expCall of file.functionCalls) {
-            let callableContainersWithThisName = callableContainersByLowerName.get(expCall.name.toLowerCase());
-            if (callableContainersWithThisName && callableContainersWithThisName.length > 0) {
-                // There are some global functions with the same name, but different return types and param counts - see "Val()"
-                let paramCount = { min: parser_1.CallExpression.MaximumArguments, max: 0 };
-                for (const callableContainer of callableContainersWithThisName) {
-                    let specificParamCount = util_1.util.getMinMaxParamCount(callableContainer.callable.params);
-                    if (specificParamCount.max > paramCount.max) {
-                        paramCount.max = specificParamCount.max;
-                    }
-                    if (specificParamCount.min < paramCount.min) {
-                        paramCount.min = specificParamCount.min;
-                    }
-                }
-                let expCallArgCount = expCall.args.length;
-                if (expCall.args.length > paramCount.max || expCall.args.length < paramCount.min) {
-                    let minMaxParamsText = paramCount.min === paramCount.max ? paramCount.max : `${paramCount.min}-${paramCount.max}`;
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchArgumentCount(minMaxParamsText, expCallArgCount)), { range: expCall.nameRange, 
-                        //TODO detect end of expression call
-                        file: file }));
-                }
-            }
-        }
+        this.linkSymbolTableDisposables.push(this.symbolTable.addSibling(this._allNamespaceTypeTable));
     }
-    /**
-     * Detect local variables (vars declared within a function expression) that have the same name as scope calls
-     * @param file
-     * @param callableContainerMap
-     */
-    diagnosticDetectShadowedLocalVars(file, callableContainerMap) {
-        const classMap = this.getClassMap();
-        for (let func of file.parser.references.functionExpressions) {
-            //every var declaration in this function expression
-            for (let symbol of func.symbolTable.ownSymbols) {
-                const symbolNameLower = symbol.name.toLowerCase();
-                //if the var is a function
-                if (reflection_1.isFunctionType(symbol.type)) {
-                    //local var function with same name as stdlib function
-                    if (
-                    //has same name as stdlib
-                    globalCallables_1.globalCallableMap.has(symbolNameLower)) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('stdlib')), { range: symbol.range, file: file }));
-                        //this check needs to come after the stdlib one, because the stdlib functions are included
-                        //in the scope function list
-                    }
-                    else if (
-                    //has same name as scope function
-                    callableContainerMap.has(symbolNameLower)) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('scope')), { range: symbol.range, file: file }));
-                    }
-                    //var is not a function
-                }
-                else if (
-                //is NOT a callable from stdlib (because non-function local vars can have same name as stdlib names)
-                !globalCallables_1.globalCallableMap.has(symbolNameLower)) {
-                    //is same name as a callable
-                    if (callableContainerMap.has(symbolNameLower)) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarShadowedByScopedFunction()), { range: symbol.range, file: file }));
-                        //has the same name as an in-scope class
-                    }
-                    else if (classMap.has(symbolNameLower)) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarSameNameAsClass(classMap.get(symbolNameLower).item.getName(parser_1.ParseMode.BrighterScript))), { range: symbol.range, file: file }));
-                    }
-                }
-            }
+    unlinkSymbolTable() {
+        for (const symbolToRemove of this.symbolsAddedDuringLinking) {
+            this.symbolTable.removeSymbol(symbolToRemove.name);
         }
-    }
-    /**
-     * Detect calls to functions that are not defined in this scope
-     * @param file
-     * @param callablesByLowerName
-     */
-    diagnosticDetectCallsToUnknownFunctions(file, callablesByLowerName) {
-        var _a;
-        //validate all expression calls
-        for (let expCall of file.functionCalls) {
-            if (reflection_1.isBrsFile(file)) {
-                const lowerName = expCall.name.toLowerCase();
-                //for now, skip validation on any method named "super" within `.bs` contexts.
-                //TODO revise this logic so we know if this function call resides within a class constructor function
-                if (file.extension === '.bs' && lowerName === 'super') {
-                    continue;
-                }
-                //find a local variable with this name
-                const localSymbol = (_a = file.getFunctionExpressionAtPosition(expCall.nameRange.start)) === null || _a === void 0 ? void 0 : _a.symbolTable.getSymbol(lowerName);
-                //if we don't already have a variable with this name.
-                if (!localSymbol) {
-                    const callablesWithThisName = util_1.util.getCallableContainersFromContainerMapByFunctionCall(callablesByLowerName, expCall);
-                    //use the first item from callablesByLowerName, because if there are more, that's a separate error
-                    let knownCallable = callablesWithThisName ? callablesWithThisName[0] : undefined;
-                    //detect calls to unknown functions
-                    if (!knownCallable) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.callToUnknownFunction(expCall.name, this.name)), { range: expCall.nameRange, file: file }));
-                    }
-                }
-                else {
-                    //if we found a variable with the same name as the function, assume the call is "known".
-                    //If the variable is a different type, some other check should add a diagnostic for that.
-                }
-            }
-        }
-    }
-    /**
-     * Create diagnostics for any duplicate function declarations
-     * @param callablesByLowerName
-     */
-    diagnosticFindDuplicateFunctionDeclarations(callableContainersByLowerName) {
-        //for each list of callables with the same name
-        for (let [lowerName, callableContainers] of callableContainersByLowerName) {
-            let globalCallables = [];
-            let nonGlobalCallables = [];
-            let ownCallables = [];
-            let ancestorNonGlobalCallables = [];
-            for (let container of callableContainers) {
-                if (container.scope === this.program.globalScope) {
-                    globalCallables.push(container);
-                }
-                else {
-                    nonGlobalCallables.push(container);
-                    if (container.scope === this) {
-                        ownCallables.push(container);
-                    }
-                    else {
-                        ancestorNonGlobalCallables.push(container);
-                    }
-                }
-            }
-            //add info diagnostics about child shadowing parent functions
-            if (ownCallables.length > 0 && ancestorNonGlobalCallables.length > 0) {
-                for (let container of ownCallables) {
-                    //skip the init function (because every component will have one of those){
-                    if (lowerName !== 'init') {
-                        let shadowedCallable = ancestorNonGlobalCallables[ancestorNonGlobalCallables.length - 1];
-                        if (!!shadowedCallable && shadowedCallable.callable.file === container.callable.file) {
-                            //same file: skip redundant imports
-                            continue;
-                        }
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.overridesAncestorFunction(container.callable.name, container.scope.name, shadowedCallable.callable.file.pkgPath, 
-                        //grab the last item in the list, which should be the closest ancestor's version
-                        shadowedCallable.scope.name)), { range: container.callable.nameRange, file: container.callable.file }));
-                    }
-                }
-            }
-            //add error diagnostics about duplicate functions in the same scope
-            if (ownCallables.length > 1) {
-                for (let callableContainer of ownCallables) {
-                    let callable = callableContainer.callable;
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.duplicateFunctionImplementation(callable.name, callableContainer.scope.name)), { range: util_1.util.createRange(callable.nameRange.start.line, callable.nameRange.start.character, callable.nameRange.start.line, callable.nameRange.end.character), file: callable.file }));
-                }
-            }
+        this.symbolsAddedDuringLinking = [];
+        for (const dispose of this.linkSymbolTableDisposables) {
+            dispose();
         }
+        this.linkSymbolTableDisposables = [];
+        this.cache.delete('namespaceLookup');
     }
     /**
      * Get the list of all script imports for this scope
@@ -730,47 +880,17 @@ class Scope {
     getOwnScriptImports() {
         let result = [];
         this.enumerateOwnFiles((file) => {
-            if (reflection_1.isBrsFile(file)) {
+            if ((0, reflection_1.isBrsFile)(file)) {
                 result.push(...file.ownScriptImports);
             }
-            else if (reflection_1.isXmlFile(file)) {
+            else if ((0, reflection_1.isXmlFile)(file)) {
                 result.push(...file.scriptTagImports);
             }
         });
         return result;
     }
-    /**
-     * Verify that all of the scripts imported by each file in this scope actually exist
-     */
-    diagnosticValidateScriptImportPaths() {
-        let scriptImports = this.getOwnScriptImports();
-        //verify every script import
-        for (let scriptImport of scriptImports) {
-            let referencedFile = this.getFileByRelativePath(scriptImport.pkgPath);
-            //if we can't find the file
-            if (!referencedFile) {
-                //skip the default bslib file, it will exist at transpile time but should not show up in the program during validation cycle
-                if (scriptImport.pkgPath === `pkg:/source/bslib.brs`) {
-                    continue;
-                }
-                let dInfo;
-                if (scriptImport.text.trim().length === 0) {
-                    dInfo = DiagnosticMessages_1.DiagnosticMessages.scriptSrcCannotBeEmpty();
-                }
-                else {
-                    dInfo = DiagnosticMessages_1.DiagnosticMessages.referencedFileDoesNotExist();
-                }
-                this.diagnostics.push(Object.assign(Object.assign({}, dInfo), { range: scriptImport.filePathRange, file: scriptImport.sourceFile }));
-                //if the character casing of the script import path does not match that of the actual path
-            }
-            else if (scriptImport.pkgPath !== referencedFile.pkgPath) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.scriptImportCaseMismatch(referencedFile.pkgPath)), { range: scriptImport.filePathRange, file: scriptImport.sourceFile }));
-            }
-        }
-    }
     /**
      * Find the file with the specified relative path
-     * @param relativePath
      */
     getFileByRelativePath(relativePath) {
         if (!relativePath) {
@@ -778,87 +898,19 @@ class Scope {
         }
         let files = this.getAllFiles();
         for (let file of files) {
-            if (file.pkgPath.toLowerCase() === relativePath.toLowerCase()) {
+            if (file.destPath.toLowerCase() === relativePath.toLowerCase()) {
                 return file;
             }
         }
     }
     /**
      * Determine if this file is included in this scope (excluding parent scopes)
-     * @param file
      */
     hasFile(file) {
         let files = this.getOwnFiles();
         let hasFile = files.includes(file);
         return hasFile;
     }
-    /**
-     * Get all callables as completionItems
-     */
-    getCallablesAsCompletions(parseMode) {
-        let completions = [];
-        let callables = this.getAllCallables();
-        if (parseMode === parser_1.ParseMode.BrighterScript) {
-            //throw out the namespaced callables (they will be handled by another method)
-            callables = callables.filter(x => x.callable.hasNamespace === false);
-        }
-        for (let callableContainer of callables) {
-            completions.push(this.createCompletionFromCallable(callableContainer));
-        }
-        return completions;
-    }
-    createCompletionFromCallable(callableContainer) {
-        return {
-            label: callableContainer.callable.getName(parser_1.ParseMode.BrighterScript),
-            kind: vscode_languageserver_1.CompletionItemKind.Function,
-            detail: callableContainer.callable.shortDescription,
-            documentation: callableContainer.callable.documentation ? { kind: 'markdown', value: callableContainer.callable.documentation } : undefined
-        };
-    }
-    createCompletionFromFunctionStatement(statement) {
-        return {
-            label: statement.getName(parser_1.ParseMode.BrighterScript),
-            kind: vscode_languageserver_1.CompletionItemKind.Function
-        };
-    }
-    /**
-     * Get the definition (where was this thing first defined) of the symbol under the position
-     */
-    getDefinition(file, position) {
-        // Overridden in XMLScope. Brs files use implementation in BrsFile
-        return [];
-    }
-    /**
-     * Scan all files for property names, and return them as completions
-     */
-    getPropertyNameCompletions() {
-        let results = [];
-        this.enumerateBrsFiles((file) => {
-            results.push(...file.propertyNameCompletions);
-        });
-        return results;
-    }
-    getAllClassMemberCompletions() {
-        let results = new Map();
-        let filesSearched = new Set();
-        for (const file of this.getAllFiles()) {
-            if (reflection_1.isXmlFile(file) || filesSearched.has(file)) {
-                continue;
-            }
-            filesSearched.add(file);
-            for (let cs of file.parser.references.classStatements) {
-                for (let s of [...cs.methods, ...cs.fields]) {
-                    if (!results.has(s.name.text) && s.name.text.toLowerCase() !== 'new') {
-                        results.set(s.name.text, {
-                            label: s.name.text,
-                            kind: reflection_1.isClassMethodStatement(s) ? vscode_languageserver_1.CompletionItemKind.Method : vscode_languageserver_1.CompletionItemKind.Field
-                        });
-                    }
-                }
-            }
-        }
-        return results;
-    }
     /**
      * @param className - The name of the class (including namespace if possible)
      * @param callsiteNamespace - the name of the namespace where the call site resides (this is NOT the known namespace of the class).
@@ -870,7 +922,7 @@ class Scope {
         let link = this.getClassFileLink(className, callsiteNamespace);
         while (link) {
             items.push(link);
-            link = this.getClassFileLink((_b = (_a = link.item.parentClassName) === null || _a === void 0 ? void 0 : _a.getName(parser_1.ParseMode.BrighterScript)) === null || _b === void 0 ? void 0 : _b.toLowerCase(), callsiteNamespace);
+            link = this.getClassFileLink((_b = (_a = link.item.parentClassName) === null || _a === void 0 ? void 0 : _a.getName()) === null || _b === void 0 ? void 0 : _b.toLowerCase(), callsiteNamespace);
         }
         return items;
     }