brighterscript 1.0.0-alpha.23 → 1.0.0-alpha.25

package/dist/Scope.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Scope = void 0;
-const vscode_languageserver_1 = require("vscode-languageserver");
+const path = require("path");
 const chalk_1 = require("chalk");
 const DiagnosticMessages_1 = require("./DiagnosticMessages");
+const interfaces_1 = require("./interfaces");
 const ClassValidator_1 = require("./validators/ClassValidator");
 const Parser_1 = require("./parser/Parser");
 const util_1 = require("./util");
@@ -13,10 +14,18 @@ const vscode_uri_1 = require("vscode-uri");
 const Logger_1 = require("./Logger");
 const reflection_1 = require("./astUtils/reflection");
 const SymbolTable_1 = require("./SymbolTable");
-const BscType_1 = require("./types/BscType");
-const DynamicType_1 = require("./types/DynamicType");
-const ObjectType_1 = require("./types/ObjectType");
-const UninitializedType_1 = require("./types/UninitializedType");
+const NamespaceType_1 = require("./types/NamespaceType");
+const ReferenceType_1 = require("./types/ReferenceType");
+const UnionType_1 = require("./types/UnionType");
+const AssociativeArrayType_1 = require("./types/AssociativeArrayType");
+const AstNode_1 = require("./parser/AstNode");
+const visitors_1 = require("./astUtils/visitors");
+/**
+ * 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;
 /**
  * A class to keep track of all declarations within a given scope (like source scope, component scope)
  */
@@ -30,6 +39,11 @@ class Scope {
          * The list of diagnostics found specifically for this scope. Individual file diagnostics are stored on the files themselves.
          */
         this.diagnostics = [];
+        /**
+         * A list of functions that will be called whenever `unlinkSymbolTable` is called
+         */
+        this.linkSymbolTableDisposables = [];
+        this.symbolsAddedDuringLinking = [];
         this.isValidated = false;
         //used for improved logging performance
         this._debugLogComponentName = `Scope '${chalk_1.default.redBright(this.name)}'`;
@@ -43,8 +57,52 @@ 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());
     }
+    /**
+     * 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 the class with the specified name.
      * @param className - The class name, including the namespace of the class if possible
@@ -63,23 +121,6 @@ class Scope {
         var _a;
         return (_a = this.getInterfaceFileLink(ifaceName, containingNamespace)) === null || _a === void 0 ? void 0 : _a.item;
     }
-    /**
-     * Get either the class or interface, etc. with a given name
-     * @param name - The name, including the namespace of the interface if possible
-     * @param containingNamespace - The namespace used to resolve relative names. (i.e. the namespace around the current statement trying to find the interface or class)
-     */
-    getNamedTypeStatement(name, containingNamespace) {
-        var _a;
-        return (_a = this.getNamedTypeFileLink(name, containingNamespace)) === null || _a === void 0 ? void 0 : _a.item;
-    }
-    /**
-     * A cache of a map of tokens -> TokenSymbolLookups, which are the result of getSymbolTypeFromToken()
-     * Sometimes the lookup of symbols may take a while if there are lazyTypes or multiple tokens in a chain
-     * By caching the result of this lookup, subsequent lookups of the same tokens are quicker
-     */
-    get symbolCache() {
-        return this.cache.getOrAdd('symbolCache', () => new Map());
-    }
     /**
      * Get the enum with the specified name.
      * @param enumName - The enum name, including the namespace if possible
@@ -105,10 +146,10 @@ class Scope {
         return cls;
     }
     /**
-   * 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)
-   */
+     * 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) {
         const lowerName = ifaceName === null || ifaceName === void 0 ? void 0 : ifaceName.toLowerCase();
         const ifaceMap = this.getInterfaceMap();
@@ -135,68 +176,68 @@ class Scope {
         return enumeration;
     }
     /**
-   * Get a Named Type (e.g. Class, Interface, Enum) and its containing file by the name
-   * @param name - The name of the type, including the namespace of the class/interface/enum, etc. if possible
-   * @param containingNamespace - The namespace used to resolve relative names. (i.e. the namespace around the current statement trying to find a class)
-   */
-    getNamedTypeFileLink(name, containingNamespace) {
-        return this.getInheritableFileLink(name, containingNamespace) || this.getEnumFileLink(name, containingNamespace);
-    }
-    /**
-     * Get a InheritableStatement and its containing file by the name of the interface or class
-     * @param name - The name of the interface or class, including the namespace of the class if possible
-     * @param containingNamespace - The namespace used to resolve relative names. (i.e. the namespace around the current statement trying to find a class)
-     */
-    getInheritableFileLink(name, containingNamespace) {
-        return this.getClassFileLink(name, containingNamespace) || this.getInterfaceFileLink(name, containingNamespace);
-    }
-    /**
-     * Gets the parent class of the given class
-     * @param klass - The class to get the parent of, if possible
+     * 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)
      */
-    getParentClass(klass) {
-        if (klass === null || klass === void 0 ? void 0 : klass.hasParent()) {
-            const lowerParentClassNames = klass.getPossibleFullParentNames().map(name => name.toLowerCase());
-            for (const lowerParentClassName of lowerParentClassNames) {
-                const foundParent = this.getClassMap().get(lowerParentClassName);
-                if (foundParent) {
-                    return foundParent.item;
-                }
-            }
+    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('.');
+        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;
         }
     }
     /**
-     * Gets the parent interface of the given interface
-     * @param iface - The interface to get the parent of, if possible
+     * 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)
      */
-    getParentInterface(iface) {
-        if (iface === null || iface === void 0 ? void 0 : iface.hasParent()) {
-            const lowerParentClassNames = iface.getPossibleFullParentNames().map(name => name.toLowerCase());
-            for (const lowerParentClassName of lowerParentClassNames) {
-                const foundParent = this.getInterfaceMap().get(lowerParentClassName);
-                if (foundParent) {
-                    return foundParent.item;
-                }
-            }
+    getConstFileLink(constName, containingNamespace) {
+        const lowerName = constName === null || constName === void 0 ? void 0 : constName.toLowerCase();
+        const constMap = this.getConstMap();
+        let result = constMap.get(util_1.util.getFullyQualifiedClassName(lowerName, containingNamespace === null || containingNamespace === void 0 ? void 0 : containingNamespace.toLowerCase()));
+        //if we couldn't find the constant by its full namespaced name, look for a global constant with that name
+        if (!result) {
+            result = constMap.get(lowerName);
         }
+        return result;
     }
-    /**
-    * Gets the parent of an Interface or Class
-    * @param stmt - The class or interface to get the parent of, if possible
-    */
-    getParentStatement(stmt) {
-        if ((0, reflection_1.isInterfaceStatement)(stmt)) {
-            return this.getParentInterface(stmt);
+    getAllFileLinks(name, containingNamespace) {
+        var _a, _b, _c, _d, _e, _f;
+        let links = [];
+        links.push((_a = this.getClassFileLink(name)) !== null && _a !== void 0 ? _a : this.getClassFileLink(name, containingNamespace), (_b = this.getInterfaceFileLink(name)) !== null && _b !== void 0 ? _b : this.getInterfaceFileLink(name, containingNamespace), (_c = this.getConstFileLink(name)) !== null && _c !== void 0 ? _c : this.getConstFileLink(name, containingNamespace), (_d = this.getEnumFileLink(name)) !== null && _d !== void 0 ? _d : this.getEnumFileLink(name, containingNamespace));
+        const nameSpaces = this.getNamespacesWithRoot(name, containingNamespace);
+        if ((nameSpaces === null || nameSpaces === void 0 ? void 0 : nameSpaces.length) > 0) {
+            const nsContainersWithStatement = (_e = nameSpaces.filter(nsContainer => { var _a; return ((_a = nsContainer === null || nsContainer === void 0 ? void 0 : nsContainer.namespaceStatements) === null || _a === void 0 ? void 0 : _a.length) > 0; })) === null || _e === void 0 ? void 0 : _e[0];
+            if (nsContainersWithStatement) {
+                links.push({ item: (_f = nsContainersWithStatement === null || nsContainersWithStatement === void 0 ? void 0 : nsContainersWithStatement.namespaceStatements) === null || _f === void 0 ? void 0 : _f[0], file: nsContainersWithStatement === null || nsContainersWithStatement === void 0 ? void 0 : nsContainersWithStatement.file });
+            }
         }
-        else if ((0, reflection_1.isClassStatement)(stmt)) {
-            return this.getParentClass(stmt);
+        const fullNameLower = (containingNamespace ? `${containingNamespace}.${name}` : name).toLowerCase();
+        const callable = this.getCallableByName(name);
+        if (callable) {
+            if (!callable.hasNamespace || 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 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
-    */
+    /**
+     * 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();
@@ -209,36 +250,28 @@ class Scope {
         });
     }
     /**
-    * Tests if a class exists with the specified name
-    * @param className - the all-lower-case namespace-included class name
-    * @param namespaceName - the current namespace name
-    */
+     * 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
-    */
+     * 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);
-    }
-    /**
-     * Tests if a class OR an interface, etc. exists with the specified name
-     * @param name - the all-lower-case namespace-included class or interface name
+     * 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
      */
-    hasNamedType(name, namespaceName) {
-        return !!this.getNamedTypeStatement(name, namespaceName);
+    hasEnum(enumName, namespaceName) {
+        return !!this.getEnum(enumName, namespaceName);
     }
     /**
      * A dictionary of all classes in this scope. This includes namespaced classes always with their full name.
@@ -248,13 +281,12 @@ class Scope {
         return this.cache.getOrAdd('classMap', () => {
             const map = new Map();
             this.enumerateBrsFiles((file) => {
-                var _a;
                 if ((0, 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();
+                    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 });
                         }
                     }
                 }
@@ -262,29 +294,20 @@ class Scope {
             return map;
         });
     }
-    getAncestorTypeListByContext(thisType, context) {
-        var _a;
-        const funcExpr = (_a = context === null || context === void 0 ? void 0 : context.file) === null || _a === void 0 ? void 0 : _a.getFunctionExpressionAtPosition(context === null || context === void 0 ? void 0 : context.position);
-        if ((0, reflection_1.isCustomType)(thisType) || (0, reflection_1.isInterfaceType)(thisType)) {
-            return this.getAncestorTypeList(thisType.name, funcExpr);
-        }
-        return [];
-    }
     /**
-    * A dictionary of all Interfaces in this scope. This includes namespaced Interfaces always with their full name.
-    * The key is stored in lower case
-    */
+     * 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) => {
-                var _a;
                 if ((0, reflection_1.isBrsFile)(file)) {
-                    for (let iface of file.parser.references.interfaceStatements) {
-                        const lowerIfaceName = (_a = iface.getName(Parser_1.ParseMode.BrighterScript)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+                    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 (lowerIfaceName) {
-                            map.set(lowerIfaceName, { item: iface, file: file });
+                        if (ifaceName) {
+                            map.set(ifaceName.toLowerCase(), { item: iface, file: file });
                         }
                     }
                 }
@@ -292,21 +315,6 @@ class Scope {
             return map;
         });
     }
-    getAncestorTypeList(className, functionExpression) {
-        var _a, _b;
-        const lowerNamespaceName = (_a = functionExpression.namespaceName) === null || _a === void 0 ? void 0 : _a.getName().toLowerCase();
-        const ancestors = [];
-        let currentClassOrIFace = (_b = this.getInheritableFileLink(className, lowerNamespaceName)) === null || _b === void 0 ? void 0 : _b.item;
-        if (currentClassOrIFace) {
-            ancestors.push(currentClassOrIFace === null || currentClassOrIFace === void 0 ? void 0 : currentClassOrIFace.getThisBscType());
-        }
-        while (currentClassOrIFace === null || currentClassOrIFace === void 0 ? void 0 : currentClassOrIFace.hasParent()) {
-            currentClassOrIFace = this.getParentStatement(currentClassOrIFace);
-            ancestors.push(currentClassOrIFace === null || currentClassOrIFace === void 0 ? void 0 : currentClassOrIFace.getThisBscType());
-        }
-        // TODO TYPES: this should probably be cached
-        return ancestors;
-    }
     /**
      * A dictionary of all enums in this scope. This includes namespaced enums always with their full name.
      * The key is stored in lower case
@@ -315,11 +323,28 @@ class Scope {
         return this.cache.getOrAdd('enumMap', () => {
             const map = new Map();
             this.enumerateBrsFiles((file) => {
-                for (let enumStmt of file.parser.references.enumStatements) {
-                    const lowerEnumName = enumStmt.fullName.toLowerCase();
+                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 (lowerEnumName) {
-                        map.set(lowerEnumName, { item: enumStmt, file: file });
+                    if (stmt.fullName) {
+                        map.set(stmt.fullName.toLowerCase(), { item: stmt, file: file });
                     }
                 }
             });
@@ -344,7 +369,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;
@@ -360,7 +385,7 @@ class Scope {
      */
     getParentScope() {
         let scope;
-        //use the global scope if we didn't find a scope and this is not the global scope
+        //use the global scope if we didn't find a sope and this is not the global scope
         if (this.program.globalScope !== this) {
             scope = this.program.globalScope;
         }
@@ -383,20 +408,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 = (0, 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.
@@ -423,32 +451,32 @@ class Scope {
                     }
                 }
                 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));
+            this.logDebug('getAllFiles', () => result.map(x => x.destPath));
             return result;
         });
     }
     /**
-     * Get the list of errors for this scope. It's calculated on the fly, so
-     * call this sparingly.
+     * Get the list of errors for this scope. It's calculated on the fly, so call this sparingly.
      */
     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) => {
+        const diagnostics = [
+            //diagnostics raised on this scope
+            ...this.diagnostics,
+            //get diagnostics from all files
+            ...this.getOwnFiles().map(x => { var _a; return (_a = x.diagnostics) !== null && _a !== void 0 ? _a : []; }).flat()
+        ]
+            //exclude diagnostics that match any of the comment flags
+            .filter((x) => {
             return !util_1.util.diagnosticIsSuppressed(x);
         });
-        //filter out diangostics that match any of the comment flags
-        return filteredDiagnostics;
+        return diagnostics;
     }
     addDiagnostics(diagnostics) {
         this.diagnostics.push(...diagnostics);
@@ -469,27 +497,23 @@ 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) {
-        var _a;
-        let lowerName = name.toLowerCase();
-        let callables = this.getAllCallables();
-        for (let callable of callables) {
-            const callableName = callable.callable.getName(Parser_1.ParseMode.BrighterScript);
-            // Split by `.` and check the last term to consider namespaces.
-            if (callableName.toLowerCase() === lowerName || ((_a = callableName.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === lowerName) {
-                return callable.callable;
-            }
-        }
+        return this.getCallableMap().get(name.toLowerCase());
     }
-    /**
-     * Get the global callable with the specified name.
-     * If there are overridden callables with the same name, the closest callable to this scope is returned
-     * @param name
-     */
-    getGlobalCallableByName(name) {
-        return globalCallables_1.globalCallableMap.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;
+        });
     }
     /**
      * Iterate over Brs files not shadowed by typedefs
@@ -510,7 +534,7 @@ class Scope {
         const files = this.getOwnFiles();
         for (const file of files) {
             //either XML components or files without a typedef
-            if ((0, reflection_1.isXmlFile)(file) || !file.hasTypedef) {
+            if ((0, reflection_1.isXmlFile)(file) || ((0, reflection_1.isBrsFile)(file) && !file.hasTypedef)) {
                 callback(file);
             }
         }
@@ -521,14 +545,16 @@ class Scope {
      */
     getOwnCallables() {
         let result = [];
-        this.logDebug('getOwnCallables() files: ', () => this.getOwnFiles().map(x => x.pkgPath));
+        this.logDebug('getOwnCallables() files: ', () => this.getOwnFiles().map(x => x.destPath));
         //get callables from own files
         this.enumerateOwnFiles((file) => {
-            for (let callable of file.callables) {
-                result.push({
-                    callable: callable,
-                    scope: this
-                });
+            if ((0, reflection_1.isBrsFile)(file)) {
+                for (let callable of file.callables) {
+                    result.push({
+                        callable: callable,
+                        scope: this
+                    });
+                }
             }
         });
         return result;
@@ -536,60 +562,27 @@ class Scope {
     /**
      * Builds a tree of namespace objects
      */
-    buildNamespaceLookup() {
+    buildNamespaceLookup(options = { okToCache: true }) {
         let namespaceLookup = new Map();
+        options.okToCache = true;
         this.enumerateBrsFiles((file) => {
-            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();
-                    if (!namespaceLookup.has(lowerLoopName)) {
-                        namespaceLookup.set(lowerLoopName, {
-                            file: file,
-                            fullName: loopName,
-                            nameRange: namespace.nameExpression.range,
-                            lastPartName: part,
-                            namespaces: new Map(),
-                            classStatements: {},
-                            functionStatements: {},
-                            enumStatements: new Map(),
-                            statements: [],
-                            symbolTable: new SymbolTable_1.SymbolTable(this.symbolTable)
-                        });
-                    }
+            options.okToCache = options.okToCache && file.isValidated;
+            const fileNamespaceLookup = file.getNamespaceLookupObject();
+            for (const [lowerNamespaceName, nsContainer] of fileNamespaceLookup) {
+                if (!namespaceLookup.has(lowerNamespaceName)) {
+                    const clonedNsContainer = Object.assign(Object.assign({}, nsContainer), { namespaceStatements: [...nsContainer.namespaceStatements], symbolTable: new SymbolTable_1.SymbolTable(`Namespace Aggregate: '${nsContainer.fullName}'`) });
+                    clonedNsContainer.symbolTable.mergeSymbolTable(nsContainer.symbolTable);
+                    namespaceLookup.set(lowerNamespaceName, clonedNsContainer);
                 }
-                let ns = namespaceLookup.get(name.toLowerCase());
-                ns.statements.push(...namespace.body.statements);
-                for (let statement of namespace.body.statements) {
-                    if ((0, reflection_1.isClassStatement)(statement) && statement.name) {
-                        ns.classStatements[statement.name.text.toLowerCase()] = statement;
-                    }
-                    else if ((0, reflection_1.isFunctionStatement)(statement) && statement.name) {
-                        ns.functionStatements[statement.name.text.toLowerCase()] = statement;
-                    }
-                    else if ((0, reflection_1.isEnumStatement)(statement) && statement.fullName) {
-                        ns.enumStatements.set(statement.fullName.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 [, ns] of namespaceLookup) {
-                let parts = ns.fullName.split('.');
-                if (parts.length > 1) {
-                    //remove the last part
-                    parts.pop();
-                    let parentName = parts.join('.');
-                    const parent = namespaceLookup.get(parentName.toLowerCase());
-                    parent.namespaces.set(ns.lastPartName.toLowerCase(), ns);
+                else {
+                    const existingContainer = namespaceLookup.get(lowerNamespaceName);
+                    existingContainer.classStatements = new Map([...existingContainer.classStatements, ...nsContainer.classStatements]);
+                    existingContainer.constStatements = new Map([...existingContainer.constStatements, ...nsContainer.constStatements]);
+                    existingContainer.enumStatements = new Map([...existingContainer.enumStatements, ...nsContainer.enumStatements]);
+                    existingContainer.functionStatements = new Map([...existingContainer.functionStatements, ...nsContainer.functionStatements]);
+                    existingContainer.namespaces = new Map([...existingContainer.namespaces, ...nsContainer.namespaces]);
+                    existingContainer.namespaceStatements.push(...nsContainer.namespaceStatements);
+                    existingContainer.symbolTable.mergeSymbolTable(nsContainer.symbolTable);
                 }
             }
         });
@@ -598,43 +591,69 @@ class Scope {
     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() {
+    validate(validationOptions = { force: false }) {
+        //if this scope is already validated, no need to revalidate
+        if (this.isValidated === true && !validationOptions.force) {
+            this.logDebug('validate(): already validated');
+            return;
+        }
         this.program.logger.time(Logger_1.LogLevel.debug, [this._debugLogComponentName, 'validate()'], () => {
             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
-            this.linkSymbolTable();
+            this.clearScopeLevelDiagnostics();
             let callables = this.getAllCallables();
             //sort the callables by filepath and then method name, so the errors will be consistent
+            // eslint-disable-next-line prefer-arrow-callback
             callables = callables.sort((a, b) => {
-                return (
+                const pathA = a.callable.file.srcPath;
+                const pathB = b.callable.file.srcPath;
                 //sort by path
-                a.callable.file.srcPath.localeCompare(b.callable.file.srcPath) ||
-                    //then sort by method name
-                    a.callable.name.localeCompare(b.callable.name));
+                if (pathA < pathB) {
+                    return -1;
+                }
+                else if (pathA > pathB) {
+                    return 1;
+                }
+                //sort by function name
+                const funcA = b.callable.name;
+                const funcB = b.callable.name;
+                if (funcA < funcB) {
+                    return -1;
+                }
+                else if (funcA > funcB) {
+                    return 1;
+                }
+                return 0;
             });
             //get a list of all callables, indexed by their lower case names
             let callableContainerMap = util_1.util.getCallableContainersByLowerName(callables);
-            this.program.plugins.emit('onScopeValidate', {
+            //Since statements from files are shared across multiple scopes, we need to link those statements to the current scope
+            this.linkSymbolTable();
+            const scopeValidateEvent = {
                 program: this.program,
-                scope: this
-            });
+                scope: this,
+                changedFiles: validationOptions === null || validationOptions === void 0 ? void 0 : validationOptions.changedFiles,
+                changedSymbols: validationOptions === null || validationOptions === void 0 ? void 0 : validationOptions.changedSymbols
+            };
+            this.program.plugins.emit('beforeScopeValidate', scopeValidateEvent);
+            this.program.plugins.emit('onScopeValidate', scopeValidateEvent);
             this._validate(callableContainerMap);
-            // unlink the symbol table so it can't be accessed from the wrong scope
+            this.program.plugins.emit('afterScopeValidate', scopeValidateEvent);
+            //unlink all symbol tables from this scope (so they don't accidentally stick around)
             this.unlinkSymbolTable();
+            this.isValidated = true;
         });
     }
     _validate(callableContainerMap) {
@@ -642,17 +661,26 @@ class Scope {
         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) => {
-            //enforce a series of checks on the bodies of class methods
-            this.validateClasses(file);
             this.diagnosticDetectShadowedLocalVars(file, callableContainerMap);
             this.diagnosticDetectFunctionCollisions(file);
             this.detectVariableNamespaceCollisions(file);
-            this.diagnosticDetectInvalidFunctionExpressionTypes(file);
-            this.diagnosticDetectInvalidFunctionCalls(file, callableContainerMap);
+            this.detectNameCollisions(file);
         });
     }
+    clearAstSegmentDiagnostics(astSegment) {
+        this.diagnostics = this.diagnostics.filter(diag => !(diag.origin === interfaces_1.DiagnosticOrigin.ASTSegment && diag.astSegment === astSegment));
+    }
+    clearAstSegmentDiagnosticsByFile(file) {
+        const lowerSrcPath = file.srcPath.toLowerCase();
+        this.diagnostics = this.diagnostics.filter(diag => !(diag.origin === interfaces_1.DiagnosticOrigin.ASTSegment && diag.file.srcPath.toLowerCase() === lowerSrcPath));
+    }
+    clearScopeLevelDiagnostics() {
+        this.diagnostics = this.diagnostics.filter(diag => diag.origin !== interfaces_1.DiagnosticOrigin.Scope);
+    }
     /**
      * Mark this scope as invalid, which means its `validate()` function needs to be called again before use.
      */
@@ -660,120 +688,131 @@ 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();
-        this.symbolCache.clear();
     }
     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);
-            this._symbolTable.addSymbol('m', null, new ObjectType_1.ObjectType('object', this.memberTable));
+        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(), SymbolTable_1.SymbolTypeFlag.runtime);
             for (let file of this.getOwnFiles()) {
                 if ((0, reflection_1.isBrsFile)(file)) {
-                    this._symbolTable.mergeSymbolTable((_b = file.parser) === null || _b === void 0 ? void 0 : _b.symbolTable);
+                    result.mergeSymbolTable((_a = file.parser) === null || _a === void 0 ? void 0 : _a.symbolTable);
                 }
             }
-        }
-        return this._symbolTable;
-    }
-    get memberTable() {
-        var _a;
-        if (!this._memberTable) {
-            this._memberTable = new SymbolTable_1.SymbolTable((_a = this.getParentScope()) === null || _a === void 0 ? void 0 : _a.memberTable);
-            if (!this.getParentScope()) {
-                this._memberTable.addSymbol('global', null, new ObjectType_1.ObjectType());
-            }
-        }
-        return this._memberTable;
-    }
-    clearSymbolTable() {
-        this._symbolTable = null;
-        this._memberTable = 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
-    */
+     * 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, _b, _c;
+        var _a;
+        SymbolTable_1.SymbolTable.cacheVerifier.generateToken();
         for (const file of this.getAllFiles()) {
             if ((0, reflection_1.isBrsFile)(file)) {
-                file.parser.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.get(namespaceNameLower).symbolTable;
-                    namespace.symbolTable.setParent(namespaceSymbolTable);
+                this.linkSymbolTableDisposables.push(file.parser.symbolTable.pushParentProvider(() => this.symbolTable));
+            }
+        }
+        //Add namespace aggregates to namespace member tables
+        const namespaceTypesKnown = new Map();
+        // eslint-disable-next-line no-bitwise
+        let getTypeOptions = { flags: SymbolTable_1.SymbolTypeFlag.runtime | SymbolTable_1.SymbolTypeFlag.typetime };
+        for (const [nsName, nsContainer] of this.namespaceLookup) {
+            let currentNSType = null;
+            let parentNSType = null;
+            const existingNsStmt = (_a = nsContainer.namespaceStatements) === null || _a === void 0 ? void 0 : _a[0];
+            if (!nsContainer.isTopLevel) {
+                parentNSType = namespaceTypesKnown.get(nsContainer.parentNameLower);
+                if (!parentNSType) {
+                    // we don't know about the parent namespace... uh, oh!
+                    break;
                 }
-                //TODO TYPES: build symbol tables for dotted set assignments using actual values
-                // Currently this is prone to call-stack issues.
-                // eg. m.key = "value"
-                for (const dotSetStmt of file.parser.references.dottedSetStatements) {
-                    if ((0, reflection_1.isVariableExpression)(dotSetStmt.obj)) {
-                        if (dotSetStmt.obj.getName(Parser_1.ParseMode.BrighterScript).toLowerCase() === 'm') {
-                            this.memberTable.addSymbol(dotSetStmt.name.text, dotSetStmt.range, new DynamicType_1.DynamicType());
-                            // TODO TYPES: get actual types: getBscTypeFromExpression(dotSetStmt.value, file.parser.references.getContainingFunctionExpression(dotSetStmt.name)));
-                        }
+                currentNSType = parentNSType.getMemberType(nsContainer.fullNameLower, getTypeOptions);
+            }
+            else {
+                currentNSType = this.symbolTable.getSymbolType(nsContainer.fullNameLower, getTypeOptions);
+            }
+            if (!(0, reflection_1.isNamespaceType)(currentNSType)) {
+                if (!currentNSType || (0, reflection_1.isReferenceType)(currentNSType)) {
+                    currentNSType = existingNsStmt
+                        ? existingNsStmt.getType(getTypeOptions)
+                        : new NamespaceType_1.NamespaceType(nsName);
+                    if (parentNSType) {
+                        // adding as a member of existing NS
+                        parentNSType.addMember(nsContainer.lastPartName, { definingNode: existingNsStmt }, currentNSType, getTypeOptions.flags);
+                        this.symbolsAddedDuringLinking.push({ symbolTable: parentNSType.getMemberTable(), name: nsContainer.lastPartName, flags: getTypeOptions.flags });
                     }
                     else {
-                        // TODO TYPES: What other types of expressions could these be?
+                        this.symbolTable.addSymbol(nsContainer.lastPartName, { definingNode: existingNsStmt }, currentNSType, getTypeOptions.flags);
+                        this.symbolsAddedDuringLinking.push({ symbolTable: this.symbolTable, name: nsContainer.lastPartName, flags: getTypeOptions.flags });
                     }
                 }
+                else {
+                    break;
+                }
             }
-        }
-        // also link classes
-        const classMap = this.getClassMap();
-        for (const pair of classMap) {
-            const classStmt = (_a = pair[1]) === null || _a === void 0 ? void 0 : _a.item;
-            classStmt === null || classStmt === void 0 ? void 0 : classStmt.buildSymbolTable(this.getParentClass(classStmt));
-        }
-        // also link interfaces
-        const ifaceMap = this.getInterfaceMap();
-        for (const pair of ifaceMap) {
-            const ifaceStmt = (_b = pair[1]) === null || _b === void 0 ? void 0 : _b.item;
-            ifaceStmt === null || ifaceStmt === void 0 ? void 0 : ifaceStmt.buildSymbolTable(this.getParentInterface(ifaceStmt));
-        }
-        //also link enums
-        const enumMap = this.getEnumMap();
-        for (const pair of enumMap) {
-            const enumStmt = (_c = pair[1]) === null || _c === void 0 ? void 0 : _c.item;
-            enumStmt === null || enumStmt === void 0 ? void 0 : enumStmt.buildSymbolTable();
+            else {
+                // Existing known namespace
+            }
+            if (!namespaceTypesKnown.has(nsName)) {
+                namespaceTypesKnown.set(nsName, currentNSType);
+            }
+            for (let nsStmt of nsContainer.namespaceStatements) {
+                this.linkSymbolTableDisposables.push(nsStmt === null || nsStmt === void 0 ? void 0 : nsStmt.getSymbolTable().addSibling(nsContainer.symbolTable));
+            }
+            this.linkSymbolTableDisposables.push(currentNSType.memberTable.addSibling(nsContainer.symbolTable));
         }
     }
     unlinkSymbolTable() {
-        var _a;
-        for (let file of this.getOwnFiles()) {
-            if ((0, 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);
-                }
-            }
+        for (const symbolToRemove of this.symbolsAddedDuringLinking) {
+            this.symbolTable.removeSymbol(symbolToRemove.name);
         }
+        this.symbolsAddedDuringLinking = [];
+        for (const dispose of this.linkSymbolTableDisposables) {
+            dispose();
+        }
+        this.linkSymbolTableDisposables = [];
     }
     detectVariableNamespaceCollisions(file) {
+        var _a, _b;
         //find all function parameters
-        for (let func of file.parser.references.functionExpressions) {
+        for (let func of file['_cachedLookups'].functionExpressions) {
             for (let param of func.parameters) {
                 let lowerParamName = param.name.text.toLowerCase();
-                let namespace = this.namespaceLookup.get(lowerParamName);
+                let namespace = this.getNamespace(lowerParamName, (_a = param.findAncestor(reflection_1.isNamespaceStatement)) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript).toLowerCase());
                 //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: [{
+                    this.diagnostics.push(Object.assign(Object.assign({ origin: interfaces_1.DiagnosticOrigin.Scope, 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)
+                                location: util_1.util.createLocation(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
                             }] }));
                 }
             }
         }
-        for (let assignment of file.parser.references.assignmentStatements) {
+        for (let assignment of file['_cachedLookups'].assignmentStatements) {
             let lowerAssignmentName = assignment.name.text.toLowerCase();
-            let namespace = this.namespaceLookup.get(lowerAssignmentName);
+            let namespace = this.getNamespace(lowerAssignmentName, (_b = assignment.findAncestor(reflection_1.isNamespaceStatement)) === null || _b === void 0 ? void 0 : _b.getName(Parser_1.ParseMode.BrighterScript).toLowerCase());
             //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: [{
+                this.diagnostics.push(Object.assign(Object.assign({ origin: interfaces_1.DiagnosticOrigin.Scope, 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)
+                            location: util_1.util.createLocation(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
                         }] }));
             }
         }
@@ -788,132 +827,84 @@ class Scope {
             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 }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.scopeFunctionShadowedByBuiltInFunction()), { range: func.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
                 }
                 //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 }));
+                const klassLink = this.getClassFileLink(lowerFuncName);
+                if (klassLink) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionCannotHaveSameNameAsClass(funcName)), { range: func.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope, relatedInformation: [{
+                                location: util_1.util.createLocation(vscode_uri_1.URI.file(klassLink.file.srcPath).toString(), klassLink.item.name.range),
+                                message: 'Original class declared here'
+                            }] }));
                 }
             }
         }
     }
-    /**
-    * Find function parameters and function return types that are neither built-in types or known Class references
-    */
-    diagnosticDetectInvalidFunctionExpressionTypes(file) {
-        var _a, _b, _c, _d;
-        for (let func of file.parser.references.functionExpressions) {
-            const returnType = (0, BscType_1.getTypeFromContext)(func.getReturnType(), { file: file, scope: this, position: (_a = func.range) === null || _a === void 0 ? void 0 : _a.start });
-            if (!returnType && func.returnType) {
-                // check if this custom type is in our class map
-                const returnTypeName = func.returnType.getText();
-                const currentNamespaceName = (_b = func.namespaceName) === null || _b === void 0 ? void 0 : _b.getName(Parser_1.ParseMode.BrighterScript);
-                if (!this.hasClass(returnTypeName, currentNamespaceName) && !this.hasInterface(returnTypeName) && !this.hasEnum(returnTypeName)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidFunctionReturnType(returnTypeName)), { range: func.returnType.range, file: file }));
-                }
-            }
-            for (let param of func.parameters) {
-                const typeContext = { file: file, scope: this, position: (_c = param.range) === null || _c === void 0 ? void 0 : _c.start };
-                let paramType = (0, BscType_1.getTypeFromContext)(param.getType(), typeContext);
-                while ((0, reflection_1.isArrayType)(paramType)) {
-                    paramType = (0, BscType_1.getTypeFromContext)(paramType.getDefaultType(typeContext), typeContext);
-                }
-                if (!paramType && param.type) {
-                    const paramTypeName = param.type.getText();
-                    const currentNamespaceName = (_d = func.namespaceName) === null || _d === void 0 ? void 0 : _d.getName(Parser_1.ParseMode.BrighterScript);
-                    if (!this.hasClass(paramTypeName, currentNamespaceName) && !this.hasInterface(paramTypeName) && !this.hasEnum(paramTypeName)) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(param.name.text, paramTypeName)), { range: param.type.range, file: file }));
-                    }
-                }
+    detectNameCollisions(file) {
+        file.ast.walk((0, visitors_1.createVisitor)({
+            NamespaceStatement: (nsStmt) => {
+                var _a;
+                this.validateNameCollision(file, nsStmt, (_a = nsStmt.getNameParts()) === null || _a === void 0 ? void 0 : _a[0]);
+            },
+            ClassStatement: (classStmt) => {
+                this.validateNameCollision(file, classStmt, classStmt.name);
+            },
+            InterfaceStatement: (ifaceStmt) => {
+                this.validateNameCollision(file, ifaceStmt, ifaceStmt.tokens.name);
+            },
+            ConstStatement: (constStmt) => {
+                this.validateNameCollision(file, constStmt, constStmt.tokens.name);
+            },
+            EnumStatement: (enumStmt) => {
+                this.validateNameCollision(file, enumStmt, enumStmt.tokens.name);
             }
-        }
+        }), {
+            walkMode: visitors_1.WalkMode.visitStatements
+        });
     }
-    /**
-    * Find functions with either the wrong type of parameters, or the wrong number of parameters
-    */
-    diagnosticDetectInvalidFunctionCalls(file, callableContainersByLowerName) {
-        var _a, _b, _c, _d;
-        if ((0, reflection_1.isBrsFile)(file)) {
-            for (let expCall of file.functionCalls) {
-                const symbolTypeInfo = file.getSymbolTypeFromToken(expCall.name, expCall.functionExpression, this);
-                let funcType = symbolTypeInfo.type;
-                if (!(0, reflection_1.isTypedFunctionType)(funcType) && !(0, reflection_1.isDynamicType)(funcType)) {
-                    // We don't know if this is a function. Try seeing if it is a global
-                    const callableContainer = util_1.util.getCallableContainerByFunctionCall(callableContainersByLowerName, expCall);
-                    if (callableContainer) {
-                        // We found a global callable with correct number of params - use that
-                        funcType = (_a = callableContainer.callable) === null || _a === void 0 ? void 0 : _a.type;
-                    }
-                    else {
-                        const allowedParamCount = util_1.util.getMinMaxParamCountByFunctionCall(callableContainersByLowerName, expCall);
-                        if (allowedParamCount) {
-                            // We found a global callable, but it needs a different number of args
-                            this.addMismatchParamCountDiagnostic(allowedParamCount, expCall, file);
-                            continue;
-                        }
-                    }
-                }
-                if ((0, reflection_1.isFunctionType)(funcType)) {
-                    // This is a generic function, and it is callable
-                }
-                else if ((0, reflection_1.isTypedFunctionType)(funcType)) {
-                    // Check for Argument count mismatch.
-                    //get min/max parameter count for callable
-                    let paramCount = util_1.util.getMinMaxParamCount(funcType.params);
-                    if (expCall.args.length > paramCount.max || expCall.args.length < paramCount.min) {
-                        this.addMismatchParamCountDiagnostic(paramCount, expCall, file);
-                    }
-                    // Check for Argument type mismatch.
-                    const paramTypeContext = { file: file, scope: this, position: (_b = expCall.functionExpression.range) === null || _b === void 0 ? void 0 : _b.start };
-                    const argTypeContext = { file: file, scope: this, position: (_c = expCall.range) === null || _c === void 0 ? void 0 : _c.start };
-                    for (let index = 0; index < funcType.params.length; index++) {
-                        const param = funcType.params[index];
-                        const arg = expCall.args[index];
-                        if (!arg) {
-                            // not enough args
-                            break;
-                        }
-                        let argType = (_d = arg.type) !== null && _d !== void 0 ? _d : new UninitializedType_1.UninitializedType();
-                        const paramType = (0, BscType_1.getTypeFromContext)(param.type, paramTypeContext);
-                        if (!paramType) {
-                            // other error - can not determine what type this parameter should be
-                            continue;
-                        }
-                        argType = (0, BscType_1.getTypeFromContext)(argType, argTypeContext);
-                        let assignable = argType === null || argType === void 0 ? void 0 : argType.isAssignableTo(paramType, argTypeContext);
-                        if (!assignable) {
-                            // TODO TYPES: perhaps this should be a strict mode setting?
-                            assignable = argType === null || argType === void 0 ? void 0 : argType.isConvertibleTo(paramType, argTypeContext);
-                        }
-                        if (!assignable) {
-                            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.argumentTypeMismatch(argType === null || argType === void 0 ? void 0 : argType.toString(argTypeContext), paramType.toString(paramTypeContext))), { range: arg === null || arg === void 0 ? void 0 : arg.range, file: file }));
-                        }
-                    }
-                }
-                else if ((0, reflection_1.isInvalidType)(symbolTypeInfo.type)) {
-                    // TODO TYPES: standard member functions like integer.ToStr() are not detectable yet.
-                }
-                else if ((0, reflection_1.isDynamicType)(symbolTypeInfo.type)) {
-                    // maybe this is a function? who knows
+    validateNameCollision(file, node, nameIdentifier) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        const name = nameIdentifier === null || nameIdentifier === void 0 ? void 0 : nameIdentifier.text;
+        if (!name || !node) {
+            return;
+        }
+        const nameRange = nameIdentifier.range;
+        const containingNamespace = (_a = node.findAncestor(reflection_1.isNamespaceStatement)) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript);
+        const links = this.getAllFileLinks(name, containingNamespace);
+        for (let link of links) {
+            if (!link || link.item === node) {
+                // refers to same node
+                continue;
+            }
+            if ((0, reflection_1.isNamespaceStatement)(link.item) && (0, reflection_1.isNamespaceStatement)(node)) {
+                // namespace can be declared multiple times
+                continue;
+            }
+            const thisNodeKindName = util_1.util.getAstNodeFriendlyName(node);
+            const thatNodeKindName = link.file.srcPath === 'global' ? 'Global Function' : (_b = util_1.util.getAstNodeFriendlyName(link.item)) !== null && _b !== void 0 ? _b : '';
+            let thatNameRange = (_f = (_e = (_d = (_c = link.item) === null || _c === void 0 ? void 0 : _c.tokens) === null || _d === void 0 ? void 0 : _d.name) === null || _e === void 0 ? void 0 : _e.range) !== null && _f !== void 0 ? _f : (_g = link.item) === null || _g === void 0 ? void 0 : _g.range;
+            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+            switch ((_h = link.item) === null || _h === void 0 ? void 0 : _h.kind) {
+                case AstNode_1.AstNodeKind.ClassStatement: {
+                    thatNameRange = (_j = link.item.name) === null || _j === void 0 ? void 0 : _j.range;
+                    break;
                 }
-                else {
-                    const functionNameText = symbolTypeInfo.expandedTokenText;
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.callToUnknownFunction(functionNameText, this.name)), { range: expCall.nameRange, 
-                        //TODO detect end of expression call
-                        file: file }));
+                case AstNode_1.AstNodeKind.NamespaceStatement: {
+                    thatNameRange = (_l = (_k = link.item.getNameParts()) === null || _k === void 0 ? void 0 : _k[0]) === null || _l === void 0 ? void 0 : _l.range;
+                    break;
                 }
             }
+            const relatedInformation = thatNameRange ? [{
+                    message: `${thatNodeKindName} declared here`,
+                    location: util_1.util.createLocation(vscode_uri_1.URI.file((_m = link.file) === null || _m === void 0 ? void 0 : _m.srcPath).toString(), thatNameRange)
+                }] : undefined;
+            this.diagnostics.push(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.nameCollision(thisNodeKindName, thatNodeKindName, name)), { origin: interfaces_1.DiagnosticOrigin.Scope, range: nameRange, relatedInformation: relatedInformation }));
         }
     }
-    addMismatchParamCountDiagnostic(paramCount, expCall, file) {
-        const minMaxParamsText = paramCount.min === paramCount.max ? paramCount.max : `${paramCount.min}-${paramCount.max}`;
-        const expCallArgCount = expCall.args.length;
-        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchArgumentCount(minMaxParamsText, expCallArgCount)), { range: expCall.nameRange, file: file }));
-    }
     getNewExpressions() {
         let result = [];
         this.enumerateBrsFiles((file) => {
-            let expressions = file.parser.references.newExpressions;
+            let expressions = file['_cachedLookups'].newExpressions;
             for (let expression of expressions) {
                 expression.file = file;
                 result.push(expression);
@@ -921,57 +912,54 @@ class Scope {
         });
         return result;
     }
-    validateClasses(file) {
-        let validator = new ClassValidator_1.BsClassValidator();
-        validator.validate(this, file);
-        this.diagnostics.push(...validator.diagnostics);
+    validateClasses() {
+        let validator = new ClassValidator_1.BsClassValidator(this);
+        validator.validate();
+        this.diagnostics.push(...validator.diagnostics.map(diag => {
+            return Object.assign(Object.assign({}, diag), { origin: interfaces_1.DiagnosticOrigin.Scope });
+        }));
     }
     /**
-     * Detect local variables (vars declared within a function expression) that have the same name as scope calls
-     * @param file
-     * @param callableContainerMap
+     * Detect local variables (function scope) that have the same name as scope calls
      */
     diagnosticDetectShadowedLocalVars(file, callableContainerMap) {
+        var _a;
         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.getOwnSymbols()) {
-                const symbolNameLower = symbol.name.toLowerCase();
-                //if the var is a function
-                if ((0, reflection_1.isTypedFunctionType)(symbol.type)) {
+        //loop through every function scope
+        for (let funcScope of file.functionScopes) {
+            //every var declaration in this function scope
+            for (let varDeclaration of funcScope.variableDeclarations) {
+                const varName = varDeclaration.name;
+                const lowerVarName = varName.toLowerCase();
+                const varIsFunction = () => {
+                    return (0, reflection_1.isCallableType)(varDeclaration.getType());
+                };
+                if (
+                //has same name as stdlib
+                globalCallables_1.globalCallableMap.has(lowerVarName)) {
                     //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 }));
+                    if (varIsFunction()) {
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('stdlib')), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
                     }
-                    //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)) {
+                else if (callableContainerMap.has(lowerVarName)) {
                     //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
+                    if (varIsFunction()) {
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('scope')), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
                     }
-                    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 }));
+                    else {
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarShadowedByScopedFunction()), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
                     }
+                    //has the same name as an in-scope class
+                }
+                else if (classMap.has(lowerVarName)) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarSameNameAsClass((_a = classMap.get(lowerVarName)) === null || _a === void 0 ? void 0 : _a.item.getName(Parser_1.ParseMode.BrighterScript))), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
                 }
             }
         }
     }
     /**
      * Create diagnostics for any duplicate function declarations
-     * @param callablesByLowerName
      */
     diagnosticFindDuplicateFunctionDeclarations(callableContainersByLowerName) {
         //for each list of callables with the same name
@@ -1004,9 +992,9 @@ class Scope {
                             //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, 
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.overridesAncestorFunction(container.callable.name, container.scope.name, shadowedCallable.callable.file.destPath, 
                         //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 }));
+                        shadowedCallable.scope.name)), { range: container.callable.nameRange, file: container.callable.file, origin: interfaces_1.DiagnosticOrigin.Scope }));
                     }
                 }
             }
@@ -1014,7 +1002,7 @@ class 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.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, origin: interfaces_1.DiagnosticOrigin.Scope }));
                 }
             }
         }
@@ -1041,11 +1029,11 @@ class Scope {
         let scriptImports = this.getOwnScriptImports();
         //verify every script import
         for (let scriptImport of scriptImports) {
-            let referencedFile = this.getFileByRelativePath(scriptImport.pkgPath);
+            let referencedFile = this.getFileByRelativePath(scriptImport.destPath);
             //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`) {
+                if (scriptImport.destPath === this.program.bslibPkgPath) {
                     continue;
                 }
                 let dInfo;
@@ -1055,17 +1043,16 @@ class Scope {
                 else {
                     dInfo = DiagnosticMessages_1.DiagnosticMessages.referencedFileDoesNotExist();
                 }
-                this.diagnostics.push(Object.assign(Object.assign({}, dInfo), { range: scriptImport.filePathRange, file: scriptImport.sourceFile }));
+                this.diagnostics.push(Object.assign(Object.assign({}, dInfo), { range: scriptImport.filePathRange, file: scriptImport.sourceFile, origin: interfaces_1.DiagnosticOrigin.Scope }));
                 //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 }));
+            else if (scriptImport.destPath !== referencedFile.destPath) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.scriptImportCaseMismatch(referencedFile.destPath)), { range: scriptImport.filePathRange, file: scriptImport.sourceFile, origin: interfaces_1.DiagnosticOrigin.Scope }));
             }
         }
     }
     /**
      * Find the file with the specified relative path
-     * @param relativePath
      */
     getFileByRelativePath(relativePath) {
         if (!relativePath) {
@@ -1073,49 +1060,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
      */
@@ -1123,41 +1080,10 @@ class Scope {
         // 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 ((0, 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: (0, reflection_1.isMethodStatement)(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).
-     *                            This is used to help resolve non-namespaced class names that reside in the same namespace as the call site.
+     *                            This is used to help resolve non-namespaced class names that reside in the same namespac as the call site.
      */
     getClassHierarchy(className, callsiteNamespace) {
         var _a, _b;
@@ -1165,7 +1091,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;
     }