brighterscript 0.41.2 → 1.0.0-alpha.12

package/dist/Scope.js

@@ -1,7 +1,6 @@
 "use strict";
 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");
@@ -13,6 +12,11 @@ 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 UninitializedType_1 = require("./types/UninitializedType");
+const ObjectType_1 = require("./types/ObjectType");
+const BscType_1 = require("./types/BscType");
+const DynamicType_1 = require("./types/DynamicType");
 /**
  * A class to keep track of all declarations within a given scope (like source scope, component scope)
  */
@@ -50,6 +54,14 @@ class Scope {
         var _a;
         return (_a = this.getClassFileLink(className, 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 a class and its containing file by the class name
      * @param className - The class name, including the namespace of the class if possible
@@ -66,9 +78,24 @@ class Scope {
         return cls;
     }
     /**
+   * 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.hasParentClass()) {
+            const lowerParentClassNames = klass.getPossibleFullParentNames().map(name => name.toLowerCase());
+            for (const lowerParentClassName of lowerParentClassNames) {
+                const foundParent = this.getClassMap().get(lowerParentClassName);
+                if (foundParent) {
+                    return foundParent.item;
+                }
+            }
+        }
+    }
+    /**
     * Tests if a class exists with the specified name
     * @param className - the all-lower-case namespace-included class name
-    * @param containingNamespace - The namespace used to resolve relative class names. (i.e. the namespace around the current statement trying to find a class)
+    * @param namespaceName - the current namespace name
     */
     hasClass(className, namespaceName) {
         return !!this.getClass(className, namespaceName);
@@ -95,6 +122,20 @@ class Scope {
             return map;
         });
     }
+    getAncestorTypeList(className, namespaceName) {
+        var _a;
+        const ancestors = [];
+        let currentClass = (_a = this.getClassFileLink(className, namespaceName)) === null || _a === void 0 ? void 0 : _a.item;
+        if (currentClass) {
+            ancestors.push(currentClass === null || currentClass === void 0 ? void 0 : currentClass.getCustomType());
+        }
+        while (currentClass === null || currentClass === void 0 ? void 0 : currentClass.hasParentClass()) {
+            currentClass = this.getParentClass(currentClass);
+            ancestors.push(currentClass === null || currentClass === void 0 ? void 0 : currentClass.getCustomType());
+        }
+        // TODO TYPES: this should probably be cached
+        return ancestors;
+    }
     onDependenciesChanged(event) {
         this.logDebug('invalidated because dependency graph said [', event.sourceKey, '] changed');
         this.invalidate();
@@ -129,7 +170,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;
         }
@@ -153,12 +194,16 @@ class Scope {
     }
     /**
      * Get the file with the specified pkgPath
+     * @param filePath can be a srcPath, a pkgPath, or a destPath (same as pkgPath but without `pkg:/`)
+     * @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(pathAbsolute) {
-        pathAbsolute = (0, util_1.standardizePath) `${pathAbsolute}`;
+    getFile(srcPath, normalizePath = true) {
+        if (normalizePath) {
+            srcPath = (0, util_1.standardizePath) `${srcPath}`;
+        }
         let files = this.getAllFiles();
         for (let file of files) {
-            if (file.pathAbsolute === pathAbsolute) {
+            if (file.srcPath === srcPath) {
                 return file;
             }
         }
@@ -188,7 +233,7 @@ class Scope {
                     }
                 }
                 else {
-                    let file = this.program.getFileByPkgPath(dependency);
+                    let file = this.program.getFile(dependency, false);
                     if (file) {
                         result.push(file);
                     }
@@ -312,7 +357,8 @@ class Scope {
                         namespaces: {},
                         classStatements: {},
                         functionStatements: {},
-                        statements: []
+                        statements: [],
+                        symbolTable: new SymbolTable_1.SymbolTable(this.symbolTable)
                     };
                 }
                 let ns = namespaceLookup[name.toLowerCase()];
@@ -325,6 +371,9 @@ class Scope {
                         ns.functionStatements[statement.name.text.toLowerCase()] = statement;
                     }
                 }
+                // Merges all the symbol tables of the namespace statements into the new symbol table created above.
+                // Set those symbol tables to have this new merged table as a parent
+                ns.symbolTable.mergeSymbolTable(namespace.symbolTable);
             }
             //associate child namespaces with their parents
             for (let key in namespaceLookup) {
@@ -350,37 +399,32 @@ class Scope {
     logDebug(...args) {
         this.program.logger.debug(this._debugLogComponentName, ...args);
     }
-    validate(force = false) {
-        //if this scope is already validated, no need to revalidate
-        if (this.isValidated === true && !force) {
-            this.logDebug('validate(): already validated');
-            return;
-        }
+    validate() {
         this.program.logger.time(Logger_1.LogLevel.debug, [this._debugLogComponentName, 'validate()'], () => {
             let parentScope = this.getParentScope();
             //validate our parent before we validate ourself
-            if (parentScope && parentScope.isValidated === false) {
+            if ((parentScope === null || parentScope === void 0 ? void 0 : parentScope.isValidated) === false) {
                 this.logDebug('validate(): validating parent first');
-                parentScope.validate(force);
+                parentScope.validate();
             }
             //clear the scope's errors list (we will populate them from this method)
             this.diagnostics = [];
+            // link the symbol table
+            this.linkSymbolTable();
             let callables = this.getAllCallables();
             //sort the callables by filepath and then method name, so the errors will be consistent
             callables = callables.sort((a, b) => {
                 return (
                 //sort by path
-                a.callable.file.pathAbsolute.localeCompare(b.callable.file.pathAbsolute) ||
+                a.callable.file.srcPath.localeCompare(b.callable.file.srcPath) ||
                     //then sort by method name
                     a.callable.name.localeCompare(b.callable.name));
             });
             //get a list of all callables, indexed by their lower case names
             let callableContainerMap = util_1.util.getCallableContainersByLowerName(callables);
-            let files = this.getOwnFiles();
-            this.program.plugins.emit('beforeScopeValidate', this, files, callableContainerMap);
             this._validate(callableContainerMap);
-            this.program.plugins.emit('afterScopeValidate', this, files, callableContainerMap);
-            this.isValidated = true;
+            // unlink the symbol table so it can't be accessed from the wrong scope
+            this.unlinkSymbolTable();
         });
     }
     _validate(callableContainerMap) {
@@ -388,16 +432,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, callableContainerMap);
         });
     }
     /**
@@ -407,6 +450,84 @@ class Scope {
         this.isValidated = false;
         //clear out various lookups (they'll get regenerated on demand the next time they're requested)
         this.cache.clear();
+        this.clearSymbolTable();
+        this.symbolCache.clear();
+    }
+    get symbolTable() {
+        var _a, _b;
+        if (!this._symbolTable) {
+            this._symbolTable = new SymbolTable_1.SymbolTable((_a = this.getParentScope()) === null || _a === void 0 ? void 0 : _a.symbolTable);
+            this._symbolTable.addSymbol('m', null, new ObjectType_1.ObjectType(this.memberTable));
+            for (let file of this.getOwnFiles()) {
+                if ((0, reflection_1.isBrsFile)(file)) {
+                    this._symbolTable.mergeSymbolTable((_b = file.parser) === null || _b === void 0 ? void 0 : _b.symbolTable);
+                }
+            }
+        }
+        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.
+    * Also links all file symbols tables to this new table
+    * This will only rebuilt if the symbol table has not been built before
+    */
+    linkSymbolTable() {
+        var _a;
+        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;
+                    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));
+        }
+    }
+    unlinkSymbolTable() {
+        var _a;
+        for (let file of this.getOwnFiles()) {
+            if ((0, reflection_1.isBrsFile)(file)) {
+                (_a = file.parser) === null || _a === void 0 ? void 0 : _a.symbolTable.setParent(null);
+                for (const namespace of file.parser.references.namespaceStatements) {
+                    namespace.symbolTable.setParent(null);
+                }
+            }
+        }
     }
     detectVariableNamespaceCollisions(file) {
         //find all function parameters
@@ -418,7 +539,7 @@ class Scope {
                 if (namespace) {
                     this.diagnostics.push(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.parameterMayNotHaveSameNameAsNamespace(param.name.text)), { range: param.name.range, relatedInformation: [{
                                 message: 'Namespace declared here',
-                                location: vscode_languageserver_1.Location.create(vscode_uri_1.URI.file(namespace.file.pathAbsolute).toString(), namespace.nameRange)
+                                location: vscode_languageserver_1.Location.create(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
                             }] }));
                 }
             }
@@ -430,7 +551,7 @@ class Scope {
             if (namespace) {
                 this.diagnostics.push(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.variableMayNotHaveSameNameAsNamespace(assignment.name.text)), { range: assignment.name.range, relatedInformation: [{
                             message: 'Namespace declared here',
-                            location: vscode_languageserver_1.Location.create(vscode_uri_1.URI.file(namespace.file.pathAbsolute).toString(), namespace.nameRange)
+                            location: vscode_languageserver_1.Location.create(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
                         }] }));
             }
         }
@@ -458,20 +579,22 @@ 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 ((0, reflection_1.isCustomType)(func.returnType) && func.returnTypeToken) {
+            const returnType = (0, BscType_1.getTypeFromContext)(func.returnType, { file: file, scope: this, position: (_a = func.range) === null || _a === void 0 ? void 0 : _a.start });
+            if (!returnType && func.returnTypeToken) {
                 // check if this custom type is in our class map
-                const returnTypeName = func.returnType.name;
-                const currentNamespaceName = (_a = func.namespaceName) === null || _a === void 0 ? void 0 : _a.getName(parser_1.ParseMode.BrighterScript);
+                const returnTypeName = func.returnTypeToken.text;
+                const currentNamespaceName = (_b = func.namespaceName) === null || _b === void 0 ? void 0 : _b.getName(parser_1.ParseMode.BrighterScript);
                 if (!this.hasClass(returnTypeName, currentNamespaceName)) {
                     this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidFunctionReturnType(returnTypeName)), { range: func.returnTypeToken.range, file: file }));
                 }
             }
             for (let param of func.parameters) {
-                if ((0, 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);
+                const paramType = (0, BscType_1.getTypeFromContext)(param.type, { file: file, scope: this, position: (_c = param.range) === null || _c === void 0 ? void 0 : _c.start });
+                if (!paramType && param.typeToken) {
+                    const paramTypeName = param.typeToken.text;
+                    const currentNamespaceName = (_d = func.namespaceName) === null || _d === void 0 ? void 0 : _d.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 }));
                     }
@@ -479,6 +602,92 @@ class Scope {
             }
         }
     }
+    /**
+    * Find functions with either the wrong type of parameters, or the wrong number of parameters
+    */
+    diagnosticDetectInvalidFunctionCalls(file, callableContainersByLowerName) {
+        var _a, _b, _c, _d, _e;
+        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.isFunctionType)(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)) {
+                    // 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();
+                        let assignable = false;
+                        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);
+                        if ((0, reflection_1.isCustomType)(argType)) {
+                            const lowerNamespaceName = (_e = expCall.functionExpression.namespaceName) === null || _e === void 0 ? void 0 : _e.getName().toLowerCase();
+                            assignable = argType.isAssignableTo(paramType, argTypeContext, this.getAncestorTypeList(argType.name, lowerNamespaceName));
+                        }
+                        else {
+                            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) => {
@@ -490,131 +699,54 @@ 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 (function scope) that have the same name as scope calls
+     * Detect local variables (vars declared within a function expression) that have the same name as scope calls
      * @param file
      * @param callableContainerMap
      */
     diagnosticDetectShadowedLocalVars(file, callableContainerMap) {
-        var _a;
         const classMap = this.getClassMap();
-        //loop through every function scope
-        for (let scope of file.functionScopes) {
-            //every var declaration in this function scope
-            for (let varDeclaration of scope.variableDeclarations) {
-                const varName = varDeclaration.name;
-                const lowerVarName = varName.toLowerCase();
+        for (let func of file.parser.references.functionExpressions) {
+            //every var declaration in this function expression
+            for (let symbol of func.symbolTable.getOwnSymbols()) {
+                const symbolNameLower = symbol.name.toLowerCase();
                 //if the var is a function
-                if ((0, reflection_1.isFunctionType)(varDeclaration.type)) {
+                if ((0, reflection_1.isFunctionType)(symbol.type)) {
                     //local var function with same name as stdlib function
                     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 }));
+                    globalCallables_1.globalCallableMap.has(symbolNameLower)) {
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('stdlib')), { range: symbol.range, file: file }));
                         //this check needs to come after the stdlib one, because the stdlib functions are included
                         //in the scope function list
                     }
                     else if (
                     //has same name as scope function
-                    callableContainerMap.has(lowerVarName)) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('scope')), { range: varDeclaration.nameRange, file: file }));
+                    callableContainerMap.has(symbolNameLower)) {
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('scope')), { range: symbol.range, file: file }));
                     }
                     //var is not a function
                 }
                 else if (
                 //is NOT a callable from stdlib (because non-function local vars can have same name as stdlib names)
-                !globalCallables_1.globalCallableMap.has(lowerVarName)) {
+                !globalCallables_1.globalCallableMap.has(symbolNameLower)) {
                     //is same name as a callable
-                    if (callableContainerMap.has(lowerVarName)) {
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarShadowedByScopedFunction()), { range: varDeclaration.nameRange, file: file }));
+                    if (callableContainerMap.has(symbolNameLower)) {
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarShadowedByScopedFunction()), { range: symbol.range, file: file }));
                         //has the same name as an in-scope class
                     }
-                    else if (classMap.has(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 }));
+                    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) {
-        //validate all expression calls
-        for (let expCall of file.functionCalls) {
-            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;
-            }
-            //get the local scope for this expression
-            let scope = file.getFunctionScopeAtPosition(expCall.nameRange.start);
-            //if we don't already have a variable with this name.
-            if (!(scope === null || scope === void 0 ? void 0 : scope.getVariableByName(lowerName))) {
-                let callablesWithThisName;
-                if (expCall.functionScope.func.namespaceName) {
-                    // prefer namespaced function
-                    const potentialNamespacedCallable = expCall.functionScope.func.namespaceName.getName(parser_1.ParseMode.BrightScript).toLowerCase() + '_' + lowerName;
-                    callablesWithThisName = callablesByLowerName.get(potentialNamespacedCallable.toLowerCase());
-                }
-                if (!callablesWithThisName) {
-                    // just try it as is
-                    callablesWithThisName = callablesByLowerName.get(lowerName);
-                }
-                //use the first item from callablesByLowerName, because if there are more, that's a separate error
-                let knownCallable = callablesWithThisName ? callablesWithThisName[0] : undefined;
-                //detect calls to unknown functions
-                if (!knownCallable) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.callToUnknownFunction(expCall.name, this.name)), { range: expCall.nameRange, file: file }));
-                }
-            }
-            else {
-                //if we found a variable with the same name as the function, assume the call is "known".
-                //If the variable is a different type, some other check should add a diagnostic for that.
-            }
-        }
-    }
     /**
      * Create diagnostics for any duplicate function declarations
      * @param callablesByLowerName
@@ -691,7 +823,7 @@ class Scope {
             //if we can't find the file
             if (!referencedFile) {
                 //skip the default bslib file, it will exist at transpile time but should not show up in the program during validation cycle
-                if (scriptImport.pkgPath === `source${path.sep}bslib.brs`) {
+                if (scriptImport.pkgPath === `pkg:/source/bslib.brs`) {
                     continue;
                 }
                 let dInfo;