brighterscript 0.66.0-alpha.9 → 0.67.1

package/dist/Scope.js

@@ -2,28 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Scope = void 0;
 const path = require("path");
+const vscode_languageserver_1 = require("vscode-languageserver");
 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");
 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 SymbolTable_1 = require("./SymbolTable");
-const NamespaceType_1 = require("./types/NamespaceType");
-const ReferenceType_1 = require("./types/ReferenceType");
-const UnionType_1 = require("./types/UnionType");
-const AssociativeArrayType_1 = require("./types/AssociativeArrayType");
-/**
- * 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;
+const logging_1 = require("./logging");
 /**
  * A class to keep track of all declarations within a given scope (like source scope, component scope)
  */
@@ -37,11 +27,6 @@ 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)}'`;
@@ -55,20 +40,6 @@ 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());
     }
     /**
@@ -168,7 +139,7 @@ class Scope {
         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('.');
+        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
@@ -179,7 +150,6 @@ class Scope {
             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;
         }
-        return enumeration;
     }
     /**
      * Get a constant and its containing file by the constant name
@@ -244,12 +214,13 @@ 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 className = cls.getName(Parser_1.ParseMode.BrighterScript);
+                        const lowerClassName = (_a = cls.getName(Parser_1.ParseMode.BrighterScript)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
                         //only track classes with a defined name (i.e. exclude nameless malformed classes)
-                        if (className) {
-                            map.set(className.toLowerCase(), { item: cls, file: file });
+                        if (lowerClassName) {
+                            map.set(lowerClassName, { item: cls, file: file });
                         }
                     }
                 }
@@ -265,12 +236,13 @@ class Scope {
         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 ifaceName = iface.getName(Parser_1.ParseMode.BrighterScript);
+                        const lowerIfaceName = (_a = iface.getName(Parser_1.ParseMode.BrighterScript)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
                         //only track classes with a defined name (i.e. exclude nameless malformed classes)
-                        if (ifaceName) {
-                            map.set(ifaceName.toLowerCase(), { item: iface, file: file });
+                        if (lowerIfaceName) {
+                            map.set(lowerIfaceName, { item: iface, file: file });
                         }
                     }
                 }
@@ -287,9 +259,10 @@ class Scope {
             const map = new Map();
             this.enumerateBrsFiles((file) => {
                 for (let enumStmt of file.parser.references.enumStatements) {
+                    const lowerEnumName = enumStmt.fullName.toLowerCase();
                     //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 });
+                    if (lowerEnumName) {
+                        map.set(lowerEnumName, { item: enumStmt, file: file });
                     }
                 }
             });
@@ -305,9 +278,10 @@ class Scope {
             const map = new Map();
             this.enumerateBrsFiles((file) => {
                 for (let stmt of file.parser.references.constStatements) {
+                    const lowerEnumName = stmt.fullName.toLowerCase();
                     //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 });
+                    if (lowerEnumName) {
+                        map.set(lowerEnumName, { item: stmt, file: file });
                     }
                 }
             });
@@ -372,14 +346,14 @@ class Scope {
     }
     /**
      * Get the file from this scope with the given path.
-     * @param filePath can be a srcPath or destPath
+     * @param filePath can be a srcPath or pkgPath
      * @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(filePath, normalizePath = true) {
         if (typeof filePath !== 'string') {
             return undefined;
         }
-        const key = path.isAbsolute(filePath) ? 'srcPath' : 'destPath';
+        const key = path.isAbsolute(filePath) ? 'srcPath' : 'pkgPath';
         let map = this.cache.getOrAdd('fileMaps-srcPath', () => {
             const result = new Map();
             for (const file of this.getAllFiles()) {
@@ -420,26 +394,26 @@ class Scope {
                     }
                 }
             }
-            this.logDebug('getAllFiles', () => result.map(x => x.destPath));
+            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.
+     * 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
-        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) => {
+        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);
         });
-        return diagnostics;
+        //filter out diangostics that match any of the comment flags
+        return filteredDiagnostics;
     }
     addDiagnostics(diagnostics) {
         this.diagnostics.push(...diagnostics);
@@ -497,7 +471,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) || ((0, reflection_1.isBrsFile)(file) && !file.hasTypedef)) {
+            if ((0, reflection_1.isXmlFile)(file) || !file.hasTypedef) {
                 callback(file);
             }
         }
@@ -508,16 +482,14 @@ class Scope {
      */
     getOwnCallables() {
         let result = [];
-        this.logDebug('getOwnCallables() files: ', () => this.getOwnFiles().map(x => x.destPath));
+        this.logDebug('getOwnCallables() files: ', () => this.getOwnFiles().map(x => x.pkgPath));
         //get callables from own files
         this.enumerateOwnFiles((file) => {
-            if ((0, reflection_1.isBrsFile)(file)) {
-                for (let callable of file.callables) {
-                    result.push({
-                        callable: callable,
-                        scope: this
-                    });
-                }
+            for (let callable of file.callables) {
+                result.push({
+                    callable: callable,
+                    scope: this
+                });
             }
         });
         return result;
@@ -525,27 +497,64 @@ class Scope {
     /**
      * Builds a tree of namespace objects
      */
-    buildNamespaceLookup(options = { okToCache: true }) {
+    buildNamespaceLookup() {
         let namespaceLookup = new Map();
-        options.okToCache = true;
         this.enumerateBrsFiles((file) => {
-            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);
+            for (let namespaceStatement of file.parser.references.namespaceStatements) {
+                //TODO should we handle non-brighterscript?
+                let name = namespaceStatement.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: namespaceStatement.nameExpression.range,
+                            lastPartName: part,
+                            namespaces: new Map(),
+                            classStatements: {},
+                            functionStatements: {},
+                            enumStatements: new Map(),
+                            constStatements: new Map(),
+                            statements: [],
+                            symbolTable: new SymbolTable_1.SymbolTable(`Namespace Aggregate: '${loopName}'`, () => this.symbolTable)
+                        });
+                    }
                 }
-                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);
+                let ns = namespaceLookup.get(name.toLowerCase());
+                ns.statements.push(...namespaceStatement.body.statements);
+                for (let statement of namespaceStatement.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);
+                    }
+                    else if ((0, reflection_1.isConstStatement)(statement) && statement.fullName) {
+                        ns.constStatements.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(namespaceStatement.body.getSymbolTable());
+            }
+            //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);
                 }
             }
         });
@@ -561,21 +570,21 @@ class Scope {
     logDebug(...args) {
         this.program.logger.debug(this._debugLogComponentName, ...args);
     }
-    validate(validationOptions = { force: false }) {
+    validate(force = false) {
         //if this scope is already validated, no need to revalidate
-        if (this.isValidated === true && !validationOptions.force) {
+        if (this.isValidated === true && !force) {
             this.logDebug('validate(): already validated');
             return;
         }
-        this.program.logger.time(Logger_1.LogLevel.debug, [this._debugLogComponentName, 'validate()'], () => {
+        this.program.logger.time(logging_1.LogLevel.debug, [this._debugLogComponentName, 'validate()'], () => {
             let parentScope = this.getParentScope();
             //validate our parent before we validate ourself
             if (parentScope && parentScope.isValidated === false) {
                 this.logDebug('validate(): validating parent first');
-                parentScope.validate(validationOptions);
+                parentScope.validate(force);
             }
             //clear the scope's errors list (we will populate them from this method)
-            this.clearScopeLevelDiagnostics();
+            this.diagnostics = [];
             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
@@ -602,18 +611,16 @@ class Scope {
             });
             //get a list of all callables, indexed by their lower case names
             let callableContainerMap = util_1.util.getCallableContainersByLowerName(callables);
+            let files = this.getOwnFiles();
             //Since statements from files are shared across multiple scopes, we need to link those statements to the current scope
             this.linkSymbolTable();
-            const scopeValidateEvent = {
+            this.program.plugins.emit('beforeScopeValidate', this, files, callableContainerMap);
+            this.program.plugins.emit('onScopeValidate', {
                 program: this.program,
-                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);
+                scope: this
+            });
             this._validate(callableContainerMap);
-            this.program.plugins.emit('afterScopeValidate', scopeValidateEvent);
+            this.program.plugins.emit('afterScopeValidate', this, files, callableContainerMap);
             //unlink all symbol tables from this scope (so they don't accidentally stick around)
             this.unlinkSymbolTable();
             this.isValidated = true;
@@ -628,21 +635,13 @@ class Scope {
         this.validateClasses();
         //do many per-file checks
         this.enumerateBrsFiles((file) => {
+            this.diagnosticDetectFunctionCallsWithWrongParamCount(file, callableContainerMap);
             this.diagnosticDetectShadowedLocalVars(file, callableContainerMap);
             this.diagnosticDetectFunctionCollisions(file);
             this.detectVariableNamespaceCollisions(file);
+            this.diagnosticDetectInvalidFunctionExpressionTypes(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.
      */
@@ -655,7 +654,6 @@ class Scope {
         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)) {
                     result.mergeSymbolTable((_a = file.parser) === null || _a === void 0 ? void 0 : _a.symbolTable);
@@ -668,88 +666,30 @@ class Scope {
      * 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;
-        SymbolTable_1.SymbolTable.cacheVerifier.generateToken();
         for (const file of this.getAllFiles()) {
             if ((0, reflection_1.isBrsFile)(file)) {
-                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;
-                }
-                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 {
-                        this.symbolTable.addSymbol(nsContainer.lastPartName, { definingNode: existingNsStmt }, currentNSType, getTypeOptions.flags);
-                        this.symbolsAddedDuringLinking.push({ symbolTable: this.symbolTable, name: nsContainer.lastPartName, flags: getTypeOptions.flags });
-                    }
+                file.parser.symbolTable.pushParentProvider(() => this.symbolTable);
+                //link each NamespaceStatement's SymbolTable with the aggregate NamespaceLookup SymbolTable
+                for (const namespace of file.parser.references.namespaceStatements) {
+                    const namespaceNameLower = namespace.getName(Parser_1.ParseMode.BrighterScript).toLowerCase();
+                    namespace.getSymbolTable().addSibling(this.namespaceLookup.get(namespaceNameLower).symbolTable);
                 }
-                else {
-                    break;
-                }
-            }
-            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() {
-        for (const symbolToRemove of this.symbolsAddedDuringLinking) {
-            this.symbolTable.removeSymbol(symbolToRemove.name);
-        }
-        this.symbolsAddedDuringLinking = [];
-        for (const dispose of this.linkSymbolTableDisposables) {
-            dispose();
+        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.popParentProvider();
+                for (const namespace of file.parser.references.namespaceStatements) {
+                    const namespaceNameLower = namespace.getName(Parser_1.ParseMode.BrighterScript).toLowerCase();
+                    namespace.getSymbolTable().removeSibling(this.namespaceLookup.get(namespaceNameLower).symbolTable);
+                }
+            }
         }
-        this.linkSymbolTableDisposables = [];
     }
     detectVariableNamespaceCollisions(file) {
         var _a, _b;
@@ -760,7 +700,7 @@ class Scope {
                 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({ origin: interfaces_1.DiagnosticOrigin.Scope, file: file }, DiagnosticMessages_1.DiagnosticMessages.parameterMayNotHaveSameNameAsNamespace(param.name.text)), { range: param.name.range, relatedInformation: [{
+                    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: util_1.util.createLocation(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
                             }] }));
@@ -772,7 +712,7 @@ class Scope {
             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({ origin: interfaces_1.DiagnosticOrigin.Scope, file: file }, DiagnosticMessages_1.DiagnosticMessages.variableMayNotHaveSameNameAsNamespace(assignment.name.text)), { range: assignment.name.range, relatedInformation: [{
+                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: util_1.util.createLocation(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
                         }] }));
@@ -789,11 +729,40 @@ 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, origin: interfaces_1.DiagnosticOrigin.Scope }));
+                    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, origin: interfaces_1.DiagnosticOrigin.Scope }));
+                    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 ((0, 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.findAncestor(reflection_1.isNamespaceStatement)) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript);
+                // check for built in types
+                const isBuiltInType = util_1.util.isBuiltInType(returnTypeName);
+                if (!isBuiltInType && !this.hasClass(returnTypeName, currentNamespaceName) && !this.hasInterface(returnTypeName) && !this.hasEnum(returnTypeName)) {
+                    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 ((0, reflection_1.isCustomType)(param.type) && param.typeToken) {
+                    const paramTypeName = param.type.name;
+                    const currentNamespaceName = (_b = func.findAncestor(reflection_1.isNamespaceStatement)) === null || _b === void 0 ? void 0 : _b.getName(Parser_1.ParseMode.BrighterScript);
+                    // check for built in types
+                    const isBuiltInType = util_1.util.isBuiltInType(paramTypeName);
+                    if (!isBuiltInType && !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.typeToken.range, file: file }));
+                    }
                 }
             }
         }
@@ -810,11 +779,40 @@ class Scope {
         return result;
     }
     validateClasses() {
-        let validator = new ClassValidator_1.BsClassValidator();
-        validator.validate(this);
-        this.diagnostics.push(...validator.diagnostics.map(diag => {
-            return Object.assign(Object.assign({}, diag), { origin: interfaces_1.DiagnosticOrigin.Scope });
-        }));
+        let validator = new ClassValidator_1.BsClassValidator(this);
+        validator.validate();
+        this.diagnostics.push(...validator.diagnostics);
+    }
+    /**
+     * Detect calls to functions with the incorrect number of parameters
+     */
+    diagnosticDetectFunctionCallsWithWrongParamCount(file, callableContainersByLowerName) {
+        //validate all function calls
+        for (let expCall of file.functionCalls) {
+            let callableContainersWithThisName = callableContainersByLowerName.get(expCall.name.toLowerCase());
+            //use the first item from callablesByLowerName, because if there are more, that's a separate error
+            let knownCallableContainer = callableContainersWithThisName ? callableContainersWithThisName[0] : undefined;
+            if (knownCallableContainer) {
+                //get min/max parameter count for callable
+                let minParams = 0;
+                let maxParams = 0;
+                for (let param of knownCallableContainer.callable.params) {
+                    maxParams++;
+                    //optional parameters must come last, so we can assume that minParams won't increase once we hit
+                    //the first isOptional
+                    if (param.isOptional !== true) {
+                        minParams++;
+                    }
+                }
+                let expCallArgCount = expCall.args.length;
+                if (expCall.args.length > maxParams || expCall.args.length < minParams) {
+                    let minMaxParamsText = minParams === maxParams ? maxParams : `${minParams}-${maxParams}`;
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchArgumentCount(minMaxParamsText, expCallArgCount)), { range: expCall.nameRange, 
+                        //TODO detect end of expression call
+                        file: file }));
+                }
+            }
+        }
     }
     /**
      * Detect local variables (function scope) that have the same name as scope calls
@@ -823,34 +821,39 @@ class Scope {
         var _a;
         const classMap = this.getClassMap();
         //loop through every function scope
-        for (let funcScope of file.functionScopes) {
+        for (let scope of file.functionScopes) {
             //every var declaration in this function scope
-            for (let varDeclaration of funcScope.variableDeclarations) {
+            for (let varDeclaration of scope.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)) {
+                //if the var is a function
+                if ((0, reflection_1.isFunctionType)(varDeclaration.type)) {
                     //local var function with same name as stdlib function
-                    if (varIsFunction()) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('stdlib')), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
+                    if (
+                    //has same name as stdlib
+                    globalCallables_1.globalCallableMap.has(lowerVarName)) {
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('stdlib')), { range: varDeclaration.nameRange, 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(lowerVarName)) {
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('scope')), { range: varDeclaration.nameRange, file: file }));
+                    }
+                    //var is not a function
                 }
-                else if (callableContainerMap.has(lowerVarName)) {
+                else if (
+                //is NOT a callable from stdlib (because non-function local vars can have same name as stdlib names)
+                !globalCallables_1.globalCallableMap.has(lowerVarName)) {
                     //is same name as a callable
-                    if (varIsFunction()) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('scope')), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
+                    if (callableContainerMap.has(lowerVarName)) {
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarShadowedByScopedFunction()), { range: varDeclaration.nameRange, file: file }));
+                        //has the same name as an in-scope class
                     }
-                    else {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarShadowedByScopedFunction()), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
+                    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 }));
                     }
-                    //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 }));
                 }
             }
         }
@@ -889,9 +892,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.destPath, 
+                        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, origin: interfaces_1.DiagnosticOrigin.Scope }));
+                        shadowedCallable.scope.name)), { range: container.callable.nameRange, file: container.callable.file }));
                     }
                 }
             }
@@ -899,7 +902,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, origin: interfaces_1.DiagnosticOrigin.Scope }));
+                    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 }));
                 }
             }
         }
@@ -926,11 +929,11 @@ class Scope {
         let scriptImports = this.getOwnScriptImports();
         //verify every script import
         for (let scriptImport of scriptImports) {
-            let referencedFile = this.getFileByRelativePath(scriptImport.destPath);
+            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.destPath === this.program.bslibPkgPath) {
+                if (scriptImport.pkgPath === `source${path.sep}bslib.brs`) {
                     continue;
                 }
                 let dInfo;
@@ -940,11 +943,11 @@ class Scope {
                 else {
                     dInfo = DiagnosticMessages_1.DiagnosticMessages.referencedFileDoesNotExist();
                 }
-                this.diagnostics.push(Object.assign(Object.assign({}, dInfo), { range: scriptImport.filePathRange, file: scriptImport.sourceFile, origin: interfaces_1.DiagnosticOrigin.Scope }));
+                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.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 }));
+            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 }));
             }
         }
     }
@@ -957,7 +960,7 @@ class Scope {
         }
         let files = this.getAllFiles();
         for (let file of files) {
-            if (file.destPath.toLowerCase() === relativePath.toLowerCase()) {
+            if (file.pkgPath.toLowerCase() === relativePath.toLowerCase()) {
                 return file;
             }
         }
@@ -970,13 +973,74 @@ class Scope {
         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
+     * @deprecated use `DefinitionProvider.process()`
      */
     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 ((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).
@@ -988,7 +1052,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()) === 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(Parser_1.ParseMode.BrighterScript)) === null || _b === void 0 ? void 0 : _b.toLowerCase(), callsiteNamespace);
         }
         return items;
     }