brighterscript 1.0.0-alpha.2 → 1.0.0-alpha.22

package/dist/Scope.js

@@ -5,7 +5,7 @@ const vscode_languageserver_1 = require("vscode-languageserver");
 const chalk_1 = require("chalk");
 const DiagnosticMessages_1 = require("./DiagnosticMessages");
 const ClassValidator_1 = require("./validators/ClassValidator");
-const parser_1 = require("./parser");
+const Parser_1 = require("./parser/Parser");
 const util_1 = require("./util");
 const globalCallables_1 = require("./globalCallables");
 const Cache_1 = require("./Cache");
@@ -13,6 +13,10 @@ 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");
 /**
  * A class to keep track of all declarations within a given scope (like source scope, component scope)
  */
@@ -50,6 +54,41 @@ class Scope {
         var _a;
         return (_a = this.getClassFileLink(className, containingNamespace)) === null || _a === void 0 ? void 0 : _a.item;
     }
+    /**
+     * Get the interface with the specified name.
+     * @param ifaceName - The interface name, including the namespace of the interface if possible
+     * @param containingNamespace - The namespace used to resolve relative interface names. (i.e. the namespace around the current statement trying to find a interface)
+     */
+    getInterface(ifaceName, containingNamespace) {
+        var _a;
+        return (_a = this.getInterfaceFileLink(ifaceName, containingNamespace)) === null || _a === void 0 ? void 0 : _a.item;
+    }
+    /**
+     * Get 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
+     * @param containingNamespace - The namespace used to resolve relative enum names. (i.e. the namespace around the current statement trying to find an enum)
+     */
+    getEnum(enumName, containingNamespace) {
+        var _a;
+        return (_a = this.getEnumFileLink(enumName, containingNamespace)) === null || _a === void 0 ? void 0 : _a.item;
+    }
     /**
      * Get a class and its containing file by the class name
      * @param className - The class name, including the namespace of the class if possible
@@ -66,13 +105,125 @@ 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)
+   */
+    getInterfaceFileLink(ifaceName, containingNamespace) {
+        const lowerName = ifaceName === null || ifaceName === void 0 ? void 0 : ifaceName.toLowerCase();
+        const ifaceMap = this.getInterfaceMap();
+        let iface = ifaceMap.get(util_1.util.getFullyQualifiedClassName(lowerName, containingNamespace === null || containingNamespace === void 0 ? void 0 : containingNamespace.toLowerCase()));
+        //if we couldn't find the iface by its full namespaced name, look for a global class with that name
+        if (!iface) {
+            iface = ifaceMap.get(lowerName);
+        }
+        return iface;
+    }
+    /**
+     * Get an Enum and its containing file by the Enum name
+     * @param enumName - The Enum name, including the namespace of the enum if possible
+     * @param containingNamespace - The namespace used to resolve relative enum names. (i.e. the namespace around the current statement trying to find a enum)
+     */
+    getEnumFileLink(enumName, containingNamespace) {
+        const lowerName = enumName === null || enumName === void 0 ? void 0 : enumName.toLowerCase();
+        const enumMap = this.getEnumMap();
+        let enumeration = enumMap.get(util_1.util.getFullyQualifiedClassName(lowerName, containingNamespace === null || containingNamespace === void 0 ? void 0 : containingNamespace.toLowerCase()));
+        //if we couldn't find the enum by its full namespaced name, look for a global enum with that name
+        if (!enumeration) {
+            enumeration = enumMap.get(lowerName);
+        }
+        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
+     */
+    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;
+                }
+            }
+        }
+    }
+    /**
+     * Gets the parent interface of the given interface
+     * @param iface - The interface to get the parent of, if possible
+     */
+    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;
+                }
+            }
+        }
+    }
+    /**
+    * 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);
+        }
+        else if ((0, reflection_1.isClassStatement)(stmt)) {
+            return this.getParentClass(stmt);
+        }
+    }
+    /**
     * Tests if a class exists with the specified name
     * @param className - the all-lower-case namespace-included class name
-    * @param namespaceName - teh current namespace name
+    * @param namespaceName - the current namespace name
     */
     hasClass(className, namespaceName) {
         return !!this.getClass(className, namespaceName);
     }
+    /**
+    * Tests if an interface exists with the specified name
+    * @param ifaceName - the all-lower-case namespace-included interface name
+    * @param namespaceName - the current namespace name
+    */
+    hasInterface(ifaceName, namespaceName) {
+        return !!this.getInterface(ifaceName, namespaceName);
+    }
+    /**
+    * Tests if an enum exists with the specified name
+    * @param enumName - the all-lower-case namespace-included enum name
+    * @param namespaceName - the current namespace name
+    */
+    hasEnum(enumName, namespaceName) {
+        return !!this.getEnum(enumName, namespaceName);
+    }
+    /**
+     * 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
+     * @param namespaceName - the current namespace name
+     */
+    hasNamedType(name, namespaceName) {
+        return !!this.getNamedTypeStatement(name, namespaceName);
+    }
     /**
      * A dictionary of all classes in this scope. This includes namespaced classes always with their full name.
      * The key is stored in lower case
@@ -82,9 +233,9 @@ class Scope {
             const map = new Map();
             this.enumerateBrsFiles((file) => {
                 var _a;
-                if (reflection_1.isBrsFile(file)) {
+                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();
+                        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 (lowerClassName) {
                             map.set(lowerClassName, { item: cls, file: file });
@@ -95,6 +246,70 @@ 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
+    */
+    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();
+                        //only track classes with a defined name (i.e. exclude nameless malformed classes)
+                        if (lowerIfaceName) {
+                            map.set(lowerIfaceName, { item: iface, file: file });
+                        }
+                    }
+                }
+            });
+            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
+     */
+    getEnumMap() {
+        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();
+                    //only track enums with a defined name (i.e. exclude nameless malformed enums)
+                    if (lowerEnumName) {
+                        map.set(lowerEnumName, { item: enumStmt, file: file });
+                    }
+                }
+            });
+            return map;
+        });
+    }
     onDependenciesChanged(event) {
         this.logDebug('invalidated because dependency graph said [', event.sourceKey, '] changed');
         this.invalidate();
@@ -129,7 +344,7 @@ class Scope {
      */
     getParentScope() {
         let scope;
-        //use the global scope if we didn't find a sope and this is not the global scope
+        //use the global scope if we didn't find a scope and this is not the global scope
         if (this.program.globalScope !== this) {
             scope = this.program.globalScope;
         }
@@ -158,7 +373,7 @@ class Scope {
      */
     getFile(srcPath, normalizePath = true) {
         if (normalizePath) {
-            srcPath = util_1.standardizePath `${srcPath}`;
+            srcPath = (0, util_1.standardizePath) `${srcPath}`;
         }
         let files = this.getAllFiles();
         for (let file of files) {
@@ -241,14 +456,25 @@ class Scope {
      * @param name
      */
     getCallableByName(name) {
+        var _a;
         let lowerName = name.toLowerCase();
         let callables = this.getAllCallables();
         for (let callable of callables) {
-            if (callable.callable.getName(parser_1.ParseMode.BrighterScript).toLowerCase() === lowerName) {
+            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;
             }
         }
     }
+    /**
+     * 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());
+    }
     /**
      * Iterate over Brs files not shadowed by typedefs
      */
@@ -256,7 +482,7 @@ class Scope {
         const files = this.getAllFiles();
         for (const file of files) {
             //only brs files without a typedef
-            if (reflection_1.isBrsFile(file) && !file.hasTypedef) {
+            if ((0, reflection_1.isBrsFile)(file) && !file.hasTypedef) {
                 callback(file);
             }
         }
@@ -268,7 +494,7 @@ class Scope {
         const files = this.getOwnFiles();
         for (const file of files) {
             //either XML components or files without a typedef
-            if (reflection_1.isXmlFile(file) || !file.hasTypedef) {
+            if ((0, reflection_1.isXmlFile)(file) || !file.hasTypedef) {
                 callback(file);
             }
         }
@@ -295,12 +521,11 @@ class Scope {
      * Builds a tree of namespace objects
      */
     buildNamespaceLookup() {
-        let namespaceLookup = {};
+        let namespaceLookup = new Map();
         this.enumerateBrsFiles((file) => {
-            var _a;
             for (let namespace of file.parser.references.namespaceStatements) {
                 //TODO should we handle non-brighterscript?
-                let name = namespace.nameExpression.getName(parser_1.ParseMode.BrighterScript);
+                let name = namespace.nameExpression.getName(Parser_1.ParseMode.BrighterScript);
                 let nameParts = name.split('.');
                 let loopName = null;
                 //ensure each namespace section is represented in the results
@@ -308,41 +533,47 @@ class Scope {
                 for (let part of nameParts) {
                     loopName = loopName === null ? part : `${loopName}.${part}`;
                     let lowerLoopName = loopName.toLowerCase();
-                    namespaceLookup[lowerLoopName] = (_a = namespaceLookup[lowerLoopName]) !== null && _a !== void 0 ? _a : {
-                        file: file,
-                        fullName: loopName,
-                        nameRange: namespace.nameExpression.range,
-                        lastPartName: part,
-                        namespaces: {},
-                        classStatements: {},
-                        functionStatements: {},
-                        statements: [],
-                        symbolTable: new SymbolTable_1.SymbolTable(this.symbolTable)
-                    };
-                }
-                let ns = namespaceLookup[name.toLowerCase()];
+                    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)
+                        });
+                    }
+                }
+                let ns = namespaceLookup.get(name.toLowerCase());
                 ns.statements.push(...namespace.body.statements);
                 for (let statement of namespace.body.statements) {
-                    if (reflection_1.isClassStatement(statement)) {
+                    if ((0, reflection_1.isClassStatement)(statement) && statement.name) {
                         ns.classStatements[statement.name.text.toLowerCase()] = statement;
                     }
-                    else if (reflection_1.isFunctionStatement(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 key in namespaceLookup) {
-                let ns = namespaceLookup[key];
+            for (let [, ns] of namespaceLookup) {
                 let parts = ns.fullName.split('.');
                 if (parts.length > 1) {
                     //remove the last part
                     parts.pop();
                     let parentName = parts.join('.');
-                    namespaceLookup[parentName.toLowerCase()].namespaces[ns.lastPartName.toLowerCase()] = ns;
+                    const parent = namespaceLookup.get(parentName.toLowerCase());
+                    parent.namespaces.set(ns.lastPartName.toLowerCase(), ns);
                 }
             }
         });
@@ -381,6 +612,10 @@ class Scope {
             });
             //get a list of all callables, indexed by their lower case names
             let callableContainerMap = util_1.util.getCallableContainersByLowerName(callables);
+            this.program.plugins.emit('onScopeValidate', {
+                program: this.program,
+                scope: this
+            });
             this._validate(callableContainerMap);
             // unlink the symbol table so it can't be accessed from the wrong scope
             this.unlinkSymbolTable();
@@ -391,17 +626,15 @@ 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) => {
-            this.diagnosticDetectCallsToUnknownFunctions(file, callableContainerMap);
-            this.diagnosticDetectFunctionCallsWithWrongParamCount(file, callableContainerMap);
+            //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);
+            this.diagnosticDetectInvalidFunctionCalls(file, callableContainerMap);
         });
     }
     /**
@@ -412,21 +645,34 @@ class Scope {
         //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));
             for (let file of this.getOwnFiles()) {
-                if (reflection_1.isBrsFile(file)) {
+                if ((0, reflection_1.isBrsFile)(file)) {
                     this._symbolTable.mergeSymbolTable((_b = file.parser) === null || _b === void 0 ? void 0 : _b.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;
     }
     /**
     * Builds the current symbol table for the scope, by merging the tables for all the files in this scope.
@@ -434,22 +680,54 @@ class Scope {
     * This will only rebuilt if the symbol table has not been built before
     */
     linkSymbolTable() {
-        var _a;
-        for (const file of this.getOwnFiles()) {
-            if (reflection_1.isBrsFile(file)) {
-                (_a = file.parser) === null || _a === void 0 ? void 0 : _a.symbolTable.setParent(this.symbolTable);
+        var _a, _b, _c;
+        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[namespaceNameLower].symbolTable;
+                    const namespaceNameLower = namespace.nameExpression.getName(Parser_1.ParseMode.BrighterScript).toLowerCase();
+                    const namespaceSymbolTable = this.namespaceLookup.get(namespaceNameLower).symbolTable;
                     namespace.symbolTable.setParent(namespaceSymbolTable);
                 }
+                //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)));
+                        }
+                    }
+                    else {
+                        // TODO TYPES: What other types of expressions could these be?
+                    }
+                }
             }
         }
+        // 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();
+        }
     }
     unlinkSymbolTable() {
         var _a;
         for (let file of this.getOwnFiles()) {
-            if (reflection_1.isBrsFile(file)) {
+            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);
@@ -462,7 +740,7 @@ class Scope {
         for (let func of file.parser.references.functionExpressions) {
             for (let param of func.parameters) {
                 let lowerParamName = param.name.text.toLowerCase();
-                let namespace = this.namespaceLookup[lowerParamName];
+                let namespace = this.namespaceLookup.get(lowerParamName);
                 //see if the param matches any starting namespace part
                 if (namespace) {
                     this.diagnostics.push(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.parameterMayNotHaveSameNameAsNamespace(param.name.text)), { range: param.name.range, relatedInformation: [{
@@ -474,7 +752,7 @@ class Scope {
         }
         for (let assignment of file.parser.references.assignmentStatements) {
             let lowerAssignmentName = assignment.name.text.toLowerCase();
-            let namespace = this.namespaceLookup[lowerAssignmentName];
+            let namespace = this.namespaceLookup.get(lowerAssignmentName);
             //see if the param matches any starting namespace part
             if (namespace) {
                 this.diagnostics.push(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.variableMayNotHaveSameNameAsNamespace(assignment.name.text)), { range: assignment.name.range, relatedInformation: [{
@@ -489,7 +767,7 @@ class Scope {
      */
     diagnosticDetectFunctionCollisions(file) {
         for (let func of file.callables) {
-            const funcName = func.getName(parser_1.ParseMode.BrighterScript);
+            const funcName = func.getName(Parser_1.ParseMode.BrighterScript);
             const lowerFuncName = funcName === null || funcName === void 0 ? void 0 : funcName.toLowerCase();
             if (lowerFuncName) {
                 //find function declarations with the same name as a stdlib function
@@ -507,48 +785,115 @@ class Scope {
     * Find function parameters and function return types that are neither built-in types or known Class references
     */
     diagnosticDetectInvalidFunctionExpressionTypes(file) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         for (let func of file.parser.references.functionExpressions) {
-            if (reflection_1.isCustomType(func.returnType) && func.returnTypeToken) {
+            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.name;
-                const currentNamespaceName = (_a = func.namespaceName) === null || _a === void 0 ? void 0 : _a.getName(parser_1.ParseMode.BrighterScript);
-                if (!this.hasClass(returnTypeName, currentNamespaceName)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidFunctionReturnType(returnTypeName)), { range: func.returnTypeToken.range, file: file }));
+                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) {
-                if (reflection_1.isCustomType(param.type) && param.typeToken) {
-                    const paramTypeName = param.type.name;
-                    const currentNamespaceName = (_b = func.namespaceName) === null || _b === void 0 ? void 0 : _b.getName(parser_1.ParseMode.BrighterScript);
-                    if (!this.hasClass(paramTypeName, currentNamespaceName)) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(param.name.text, paramTypeName)), { range: param.typeToken.range, file: file }));
+                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 }));
                     }
                 }
             }
         }
     }
-    diagnosticDetectInvalidFunctionCalls(file) {
-        for (let expCall of file.functionCalls) {
-            const funcType = expCall.functionExpression.symbolTable.getSymbolType(expCall.name);
-            if (!reflection_1.isFunctionType(funcType)) {
-                // can not find function. Handled in a different validation function
-                continue;
-            }
-            if (funcType.params.length !== expCall.args.length) {
-                // Argument count mismatch. Handled in a different validation function
-                continue;
-            }
-            for (let index = 0; index < funcType.params.length; index++) {
-                const param = funcType.params[index];
-                const arg = expCall.args[index];
-                const argType = arg.type;
-                if (!argType.isAssignableTo(param.type)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.argumentTypeMismatch(arg.type.toTypeString(), param.type.toTypeString())), { range: arg.range, file: file }));
+    /**
+    * 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
+                }
+                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 }));
                 }
             }
         }
     }
+    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) => {
@@ -560,44 +905,11 @@ class Scope {
         });
         return result;
     }
-    validateClasses() {
+    validateClasses(file) {
         let validator = new ClassValidator_1.BsClassValidator();
-        validator.validate(this);
+        validator.validate(this, file);
         this.diagnostics.push(...validator.diagnostics);
     }
-    /**
-     * Detect calls to functions with the incorrect number of parameters
-     * @param file
-     * @param callableContainersByLowerName
-     */
-    diagnosticDetectFunctionCallsWithWrongParamCount(file, callableContainersByLowerName) {
-        //validate all function calls
-        for (let expCall of file.functionCalls) {
-            let callableContainersWithThisName = callableContainersByLowerName.get(expCall.name.toLowerCase());
-            //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 === false) {
-                        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 (vars declared within a function expression) that have the same name as scope calls
      * @param file
@@ -607,10 +919,10 @@ class Scope {
         const classMap = this.getClassMap();
         for (let func of file.parser.references.functionExpressions) {
             //every var declaration in this function expression
-            for (let symbol of func.symbolTable.ownSymbols) {
+            for (let symbol of func.symbolTable.getOwnSymbols()) {
                 const symbolNameLower = symbol.name.toLowerCase();
                 //if the var is a function
-                if (reflection_1.isFunctionType(symbol.type)) {
+                if ((0, reflection_1.isTypedFunctionType)(symbol.type)) {
                     //local var function with same name as stdlib function
                     if (
                     //has same name as stdlib
@@ -635,44 +947,9 @@ class Scope {
                         //has the same name as an in-scope class
                     }
                     else if (classMap.has(symbolNameLower)) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarSameNameAsClass(classMap.get(symbolNameLower).item.getName(parser_1.ParseMode.BrighterScript))), { range: symbol.range, file: file }));
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Detect calls to functions that are not defined in this scope
-     * @param file
-     * @param callablesByLowerName
-     */
-    diagnosticDetectCallsToUnknownFunctions(file, callablesByLowerName) {
-        var _a;
-        //validate all expression calls
-        for (let expCall of file.functionCalls) {
-            if (reflection_1.isBrsFile(file)) {
-                const lowerName = expCall.name.toLowerCase();
-                //for now, skip validation on any method named "super" within `.bs` contexts.
-                //TODO revise this logic so we know if this function call resides within a class constructor function
-                if (file.extension === '.bs' && lowerName === 'super') {
-                    continue;
-                }
-                //find a local variable with this name
-                const localSymbol = (_a = file.getFunctionExpressionAtPosition(expCall.nameRange.start)) === null || _a === void 0 ? void 0 : _a.symbolTable.getSymbol(lowerName);
-                //if we don't already have a variable with this name.
-                if (!localSymbol) {
-                    const callablesWithThisName = util_1.util.getCallableContainersFromContainerMapByFunctionCall(callablesByLowerName, expCall);
-                    //use the first item from callablesByLowerName, because if there are more, that's a separate error
-                    let knownCallable = callablesWithThisName ? callablesWithThisName[0] : undefined;
-                    //detect calls to unknown functions
-                    if (!knownCallable) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.callToUnknownFunction(expCall.name, this.name)), { range: expCall.nameRange, file: file }));
+                        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 {
-                    //if we found a variable with the same name as the function, assume the call is "known".
-                    //If the variable is a different type, some other check should add a diagnostic for that.
-                }
             }
         }
     }
@@ -732,10 +1009,10 @@ class Scope {
     getOwnScriptImports() {
         let result = [];
         this.enumerateOwnFiles((file) => {
-            if (reflection_1.isBrsFile(file)) {
+            if ((0, reflection_1.isBrsFile)(file)) {
                 result.push(...file.ownScriptImports);
             }
-            else if (reflection_1.isXmlFile(file)) {
+            else if ((0, reflection_1.isXmlFile)(file)) {
                 result.push(...file.scriptTagImports);
             }
         });
@@ -800,7 +1077,7 @@ class Scope {
     getCallablesAsCompletions(parseMode) {
         let completions = [];
         let callables = this.getAllCallables();
-        if (parseMode === parser_1.ParseMode.BrighterScript) {
+        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);
         }
@@ -811,7 +1088,7 @@ class Scope {
     }
     createCompletionFromCallable(callableContainer) {
         return {
-            label: callableContainer.callable.getName(parser_1.ParseMode.BrighterScript),
+            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
@@ -819,7 +1096,7 @@ class Scope {
     }
     createCompletionFromFunctionStatement(statement) {
         return {
-            label: statement.getName(parser_1.ParseMode.BrighterScript),
+            label: statement.getName(Parser_1.ParseMode.BrighterScript),
             kind: vscode_languageserver_1.CompletionItemKind.Function
         };
     }
@@ -844,7 +1121,7 @@ class Scope {
         let results = new Map();
         let filesSearched = new Set();
         for (const file of this.getAllFiles()) {
-            if (reflection_1.isXmlFile(file) || filesSearched.has(file)) {
+            if ((0, reflection_1.isXmlFile)(file) || filesSearched.has(file)) {
                 continue;
             }
             filesSearched.add(file);
@@ -853,7 +1130,7 @@ class Scope {
                     if (!results.has(s.name.text) && s.name.text.toLowerCase() !== 'new') {
                         results.set(s.name.text, {
                             label: s.name.text,
-                            kind: reflection_1.isClassMethodStatement(s) ? vscode_languageserver_1.CompletionItemKind.Method : vscode_languageserver_1.CompletionItemKind.Field
+                            kind: (0, reflection_1.isMethodStatement)(s) ? vscode_languageserver_1.CompletionItemKind.Method : vscode_languageserver_1.CompletionItemKind.Field
                         });
                     }
                 }
@@ -864,7 +1141,7 @@ class Scope {
     /**
      * @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 namespac as the call site.
+     *                            This is used to help resolve non-namespaced class names that reside in the same namespace as the call site.
      */
     getClassHierarchy(className, callsiteNamespace) {
         var _a, _b;
@@ -872,7 +1149,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(Parser_1.ParseMode.BrighterScript)) === null || _b === void 0 ? void 0 : _b.toLowerCase(), callsiteNamespace);
         }
         return items;
     }