brighterscript 0.66.0-alpha.6 → 0.66.0-alpha.8

package/dist/Scope.js

@@ -4,6 +4,7 @@ exports.Scope = void 0;
 const path = require("path");
 const chalk_1 = require("chalk");
 const DiagnosticMessages_1 = require("./DiagnosticMessages");
+const interfaces_1 = require("./interfaces");
 const ClassValidator_1 = require("./validators/ClassValidator");
 const Parser_1 = require("./parser/Parser");
 const util_1 = require("./util");
@@ -40,6 +41,7 @@ class Scope {
          * 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)}'`;
@@ -53,6 +55,20 @@ 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());
     }
     /**
@@ -356,14 +372,14 @@ class Scope {
     }
     /**
      * Get the file from this scope with the given path.
-     * @param filePath can be a srcPath or pkgPath
+     * @param filePath can be a srcPath or destPath
      * @param normalizePath should this function repair and standardize the path? Passing false should have a performance boost if you can guarantee your path is already sanitized
      */
     getFile(filePath, normalizePath = true) {
         if (typeof filePath !== 'string') {
             return undefined;
         }
-        const key = path.isAbsolute(filePath) ? 'srcPath' : 'pkgPath';
+        const key = path.isAbsolute(filePath) ? 'srcPath' : 'destPath';
         let map = this.cache.getOrAdd('fileMaps-srcPath', () => {
             const result = new Map();
             for (const file of this.getAllFiles()) {
@@ -404,26 +420,26 @@ class Scope {
                     }
                 }
             }
-            this.logDebug('getAllFiles', () => result.map(x => x.pkgPath));
+            this.logDebug('getAllFiles', () => result.map(x => x.destPath));
             return result;
         });
     }
     /**
-     * Get the list of errors for this scope. It's calculated on the fly, so
-     * call this sparingly.
+     * Get the list of errors for this scope. It's calculated on the fly, so call this sparingly.
      */
     getDiagnostics() {
-        let diagnosticLists = [this.diagnostics];
         //add diagnostics from every referenced file
-        this.enumerateOwnFiles((file) => {
-            diagnosticLists.push(file.getDiagnostics());
-        });
-        let allDiagnostics = Array.prototype.concat.apply([], diagnosticLists);
-        let filteredDiagnostics = allDiagnostics.filter((x) => {
+        const diagnostics = [
+            //diagnostics raised on this scope
+            ...this.diagnostics,
+            //get diagnostics from all files
+            ...this.getOwnFiles().map(x => { var _a; return (_a = x.diagnostics) !== null && _a !== void 0 ? _a : []; }).flat()
+        ]
+            //exclude diagnostics that match any of the comment flags
+            .filter((x) => {
             return !util_1.util.diagnosticIsSuppressed(x);
         });
-        //filter out diangostics that match any of the comment flags
-        return filteredDiagnostics;
+        return diagnostics;
     }
     addDiagnostics(diagnostics) {
         this.diagnostics.push(...diagnostics);
@@ -481,7 +497,7 @@ class Scope {
         const files = this.getOwnFiles();
         for (const file of files) {
             //either XML components or files without a typedef
-            if ((0, reflection_1.isXmlFile)(file) || !file.hasTypedef) {
+            if ((0, reflection_1.isXmlFile)(file) || ((0, reflection_1.isBrsFile)(file) && !file.hasTypedef)) {
                 callback(file);
             }
         }
@@ -492,14 +508,16 @@ class Scope {
      */
     getOwnCallables() {
         let result = [];
-        this.logDebug('getOwnCallables() files: ', () => this.getOwnFiles().map(x => x.pkgPath));
+        this.logDebug('getOwnCallables() files: ', () => this.getOwnFiles().map(x => x.destPath));
         //get callables from own files
         this.enumerateOwnFiles((file) => {
-            for (let callable of file.callables) {
-                result.push({
-                    callable: callable,
-                    scope: this
-                });
+            if ((0, reflection_1.isBrsFile)(file)) {
+                for (let callable of file.callables) {
+                    result.push({
+                        callable: callable,
+                        scope: this
+                    });
+                }
             }
         });
         return result;
@@ -507,74 +525,27 @@ class Scope {
     /**
      * Builds a tree of namespace objects
      */
-    buildNamespaceLookup() {
+    buildNamespaceLookup(options = { okToCache: true }) {
         let namespaceLookup = new Map();
+        options.okToCache = true;
         this.enumerateBrsFiles((file) => {
-            for (let namespaceStatement of file.parser.references.namespaceStatements) {
-                let nameParts = namespaceStatement.getNameParts();
-                let loopName = null;
-                let lowerLoopName = null;
-                let parentNameLower = 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 i = 0; i < nameParts.length; i++) {
-                    let part = nameParts[i];
-                    let lowerPartName = part.text.toLowerCase();
-                    if (i === 0) {
-                        loopName = part.text;
-                        lowerLoopName = lowerPartName;
-                    }
-                    else {
-                        parentNameLower = lowerLoopName;
-                        loopName += '.' + part.text;
-                        lowerLoopName += '.' + lowerPartName;
-                    }
-                    if (!namespaceLookup.has(lowerLoopName)) {
-                        namespaceLookup.set(lowerLoopName, {
-                            file: file,
-                            fullName: loopName,
-                            fullNameLower: lowerLoopName,
-                            parentNameLower: parentNameLower,
-                            nameParts: nameParts.slice(0, i),
-                            nameRange: namespaceStatement.nameExpression.range,
-                            lastPartName: part.text,
-                            lastPartNameLower: lowerPartName,
-                            namespaces: new Map(),
-                            classStatements: new Map(),
-                            functionStatements: new Map(),
-                            enumStatements: new Map(),
-                            constStatements: new Map(),
-                            statements: [],
-                            // the aggregate symbol table should have no parent. It should include just the symbols of the namespace.
-                            symbolTable: new SymbolTable_1.SymbolTable(`Namespace Aggregate: '${loopName}'`)
-                        });
-                    }
-                }
-                let ns = namespaceLookup.get(lowerLoopName);
-                ns.statements.push(...namespaceStatement.body.statements);
-                for (let statement of namespaceStatement.body.statements) {
-                    if ((0, reflection_1.isClassStatement)(statement) && statement.name) {
-                        ns.classStatements.set(statement.name.text.toLowerCase(), statement);
-                    }
-                    else if ((0, reflection_1.isFunctionStatement)(statement) && statement.name) {
-                        ns.functionStatements.set(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);
-                    }
+            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);
                 }
-                // 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) {
-                if (ns.parentNameLower) {
-                    const parent = namespaceLookup.get(ns.parentNameLower);
-                    parent.namespaces.set(ns.lastPartNameLower, ns);
+                else {
+                    const existingContainer = namespaceLookup.get(lowerNamespaceName);
+                    existingContainer.classStatements = new Map([...existingContainer.classStatements, ...nsContainer.classStatements]);
+                    existingContainer.constStatements = new Map([...existingContainer.constStatements, ...nsContainer.constStatements]);
+                    existingContainer.enumStatements = new Map([...existingContainer.enumStatements, ...nsContainer.enumStatements]);
+                    existingContainer.functionStatements = new Map([...existingContainer.functionStatements, ...nsContainer.functionStatements]);
+                    existingContainer.namespaces = new Map([...existingContainer.namespaces, ...nsContainer.namespaces]);
+                    existingContainer.namespaceStatements.push(...nsContainer.namespaceStatements);
+                    existingContainer.symbolTable.mergeSymbolTable(nsContainer.symbolTable);
                 }
             }
         });
@@ -590,9 +561,9 @@ class Scope {
     logDebug(...args) {
         this.program.logger.debug(this._debugLogComponentName, ...args);
     }
-    validate(force = false) {
+    validate(validationOptions = { force: false }) {
         //if this scope is already validated, no need to revalidate
-        if (this.isValidated === true && !force) {
+        if (this.isValidated === true && !validationOptions.force) {
             this.logDebug('validate(): already validated');
             return;
         }
@@ -601,10 +572,10 @@ class Scope {
             //validate our parent before we validate ourself
             if (parentScope && parentScope.isValidated === false) {
                 this.logDebug('validate(): validating parent first');
-                parentScope.validate(force);
+                parentScope.validate(validationOptions);
             }
             //clear the scope's errors list (we will populate them from this method)
-            this.diagnostics = [];
+            this.clearScopeLevelDiagnostics();
             let callables = this.getAllCallables();
             //sort the callables by filepath and then method name, so the errors will be consistent
             // eslint-disable-next-line prefer-arrow-callback
@@ -635,7 +606,9 @@ class Scope {
             this.linkSymbolTable();
             const scopeValidateEvent = {
                 program: this.program,
-                scope: this
+                scope: this,
+                changedFiles: validationOptions === null || validationOptions === void 0 ? void 0 : validationOptions.changedFiles,
+                changedSymbols: validationOptions === null || validationOptions === void 0 ? void 0 : validationOptions.changedSymbols
             };
             this.program.plugins.emit('beforeScopeValidate', scopeValidateEvent);
             this.program.plugins.emit('onScopeValidate', scopeValidateEvent);
@@ -660,6 +633,16 @@ class Scope {
             this.detectVariableNamespaceCollisions(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.
      */
@@ -701,69 +684,68 @@ class Scope {
      * ```
      */
     linkSymbolTable() {
+        var _a;
         SymbolTable_1.SymbolTable.cacheVerifier.generateToken();
-        const allNamespaces = [];
         for (const file of this.getAllFiles()) {
             if ((0, reflection_1.isBrsFile)(file)) {
                 this.linkSymbolTableDisposables.push(file.parser.symbolTable.pushParentProvider(() => this.symbolTable));
-                allNamespaces.push(...file.parser.references.namespaceStatements);
             }
         }
-        const aggregatesAdded = new Set();
         //Add namespace aggregates to namespace member tables
-        for (const namespace of allNamespaces) {
-            //link each NamespaceType member table with the aggregate NamespaceLookup SymbolTable
-            let namespaceParts = namespace.getNameParts();
-            let fullNamespaceName = namespaceParts[0].text;
-            for (let i = 1; i < namespaceParts.length; i++) {
-                fullNamespaceName += '.' + namespaceParts[i].text;
-            }
-            // eslint-disable-next-line no-bitwise
-            let getTypeOptions = { flags: SymbolTable_1.SymbolTypeFlag.runtime | SymbolTable_1.SymbolTypeFlag.typetime };
+        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 nameSoFar = '';
-            const symbolTable = this.symbolTable;
-            for (const nsNamePartToken of namespaceParts) {
-                // for each section of the namespace name, add it as either a top level symbol (if it is the first part)
-                // or as a member to the containing namespace.
-                let previousNSType = currentNSType;
-                const nsNamePart = nsNamePartToken.text;
-                currentNSType = currentNSType === null
-                    ? symbolTable.getSymbolType(nsNamePart, getTypeOptions)
-                    : currentNSType.getMemberType(nsNamePart, getTypeOptions);
-                nameSoFar = nameSoFar === '' ? nsNamePart : `${nameSoFar}.${nsNamePart}`;
-                let isFinalNamespace = nameSoFar.toLowerCase() === fullNamespaceName.toLowerCase();
-                if (!(0, reflection_1.isNamespaceType)(currentNSType)) {
-                    if (!currentNSType || (0, reflection_1.isReferenceType)(currentNSType)) {
-                        currentNSType = isFinalNamespace
-                            ? namespace.getType(getTypeOptions)
-                            : new NamespaceType_1.NamespaceType(nameSoFar);
-                        if (previousNSType) {
-                            // adding as a member of existing NS
-                            previousNSType.addMember(nsNamePart, { definingNode: namespace }, currentNSType, getTypeOptions.flags);
-                        }
-                        else {
-                            symbolTable.addSymbol(nsNamePart, { definingNode: namespace }, currentNSType, getTypeOptions.flags);
-                        }
+            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 {
-                        break;
+                        this.symbolTable.addSymbol(nsContainer.lastPartName, { definingNode: existingNsStmt }, currentNSType, getTypeOptions.flags);
+                        this.symbolsAddedDuringLinking.push({ symbolTable: this.symbolTable, name: nsContainer.lastPartName, flags: getTypeOptions.flags });
                     }
                 }
-                // Now that the namespace type is built, add the aggregate as a sibling
-                const lowerNameSpace = nameSoFar.toLowerCase();
-                let aggregateNSSymbolTable = this.namespaceLookup.get(nameSoFar.toLowerCase()).symbolTable;
-                if (!aggregatesAdded.has(lowerNameSpace)) {
-                    this.linkSymbolTableDisposables.push(currentNSType.memberTable.addSibling(aggregateNSSymbolTable));
-                    aggregatesAdded.add(lowerNameSpace);
-                }
-                if (isFinalNamespace) {
-                    this.linkSymbolTableDisposables.push(namespace.getSymbolTable().addSibling(aggregateNSSymbolTable));
+                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();
         }
@@ -778,7 +760,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({ file: file }, DiagnosticMessages_1.DiagnosticMessages.parameterMayNotHaveSameNameAsNamespace(param.name.text)), { range: param.name.range, relatedInformation: [{
+                    this.diagnostics.push(Object.assign(Object.assign({ origin: interfaces_1.DiagnosticOrigin.Scope, file: file }, DiagnosticMessages_1.DiagnosticMessages.parameterMayNotHaveSameNameAsNamespace(param.name.text)), { range: param.name.range, relatedInformation: [{
                                 message: 'Namespace declared here',
                                 location: util_1.util.createLocation(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
                             }] }));
@@ -790,7 +772,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({ file: file }, DiagnosticMessages_1.DiagnosticMessages.variableMayNotHaveSameNameAsNamespace(assignment.name.text)), { range: assignment.name.range, relatedInformation: [{
+                this.diagnostics.push(Object.assign(Object.assign({ origin: interfaces_1.DiagnosticOrigin.Scope, file: file }, DiagnosticMessages_1.DiagnosticMessages.variableMayNotHaveSameNameAsNamespace(assignment.name.text)), { range: assignment.name.range, relatedInformation: [{
                             message: 'Namespace declared here',
                             location: util_1.util.createLocation(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
                         }] }));
@@ -807,11 +789,11 @@ class Scope {
             if (lowerFuncName) {
                 //find function declarations with the same name as a stdlib function
                 if (globalCallables_1.globalCallableMap.has(lowerFuncName)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.scopeFunctionShadowedByBuiltInFunction()), { range: func.nameRange, file: file }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.scopeFunctionShadowedByBuiltInFunction()), { range: func.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
                 }
                 //find any functions that have the same name as a class
                 if (this.hasClass(lowerFuncName)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionCannotHaveSameNameAsClass(funcName)), { range: func.nameRange, file: file }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionCannotHaveSameNameAsClass(funcName)), { range: func.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
                 }
             }
         }
@@ -830,7 +812,9 @@ class Scope {
     validateClasses() {
         let validator = new ClassValidator_1.BsClassValidator();
         validator.validate(this);
-        this.diagnostics.push(...validator.diagnostics);
+        this.diagnostics.push(...validator.diagnostics.map(diag => {
+            return Object.assign(Object.assign({}, diag), { origin: interfaces_1.DiagnosticOrigin.Scope });
+        }));
     }
     /**
      * Detect local variables (function scope) that have the same name as scope calls
@@ -839,39 +823,34 @@ class Scope {
         var _a;
         const classMap = this.getClassMap();
         //loop through every function scope
-        for (let scope of file.functionScopes) {
+        for (let funcScope of file.functionScopes) {
             //every var declaration in this function scope
-            for (let varDeclaration of scope.variableDeclarations) {
+            for (let varDeclaration of funcScope.variableDeclarations) {
                 const varName = varDeclaration.name;
                 const lowerVarName = varName.toLowerCase();
-                //if the var is a function
-                if ((0, reflection_1.isCallableType)(varDeclaration.getType())) {
+                const varIsFunction = () => {
+                    return (0, reflection_1.isCallableType)(varDeclaration.getType());
+                };
+                if (
+                //has same name as stdlib
+                globalCallables_1.globalCallableMap.has(lowerVarName)) {
                     //local var function with same name as stdlib function
-                    if (
-                    //has same name as stdlib
-                    globalCallables_1.globalCallableMap.has(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 }));
+                    if (varIsFunction()) {
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('stdlib')), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
                     }
-                    //var is not a function
                 }
-                else if (
-                //is NOT a callable from stdlib (because non-function local vars can have same name as stdlib names)
-                !globalCallables_1.globalCallableMap.has(lowerVarName)) {
+                else if (callableContainerMap.has(lowerVarName)) {
                     //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 }));
-                        //has the same name as an in-scope class
+                    if (varIsFunction()) {
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('scope')), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
                     }
-                    else if (classMap.has(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 {
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarShadowedByScopedFunction()), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
                     }
+                    //has the same name as an in-scope class
+                }
+                else if (classMap.has(lowerVarName)) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarSameNameAsClass((_a = classMap.get(lowerVarName)) === null || _a === void 0 ? void 0 : _a.item.getName(Parser_1.ParseMode.BrighterScript))), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
                 }
             }
         }
@@ -910,9 +889,9 @@ class Scope {
                             //same file: skip redundant imports
                             continue;
                         }
-                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.overridesAncestorFunction(container.callable.name, container.scope.name, shadowedCallable.callable.file.pkgPath, 
+                        this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.overridesAncestorFunction(container.callable.name, container.scope.name, shadowedCallable.callable.file.destPath, 
                         //grab the last item in the list, which should be the closest ancestor's version
-                        shadowedCallable.scope.name)), { range: container.callable.nameRange, file: container.callable.file }));
+                        shadowedCallable.scope.name)), { range: container.callable.nameRange, file: container.callable.file, origin: interfaces_1.DiagnosticOrigin.Scope }));
                     }
                 }
             }
@@ -920,7 +899,7 @@ class Scope {
             if (ownCallables.length > 1) {
                 for (let callableContainer of ownCallables) {
                     let callable = callableContainer.callable;
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.duplicateFunctionImplementation(callable.name, callableContainer.scope.name)), { range: util_1.util.createRange(callable.nameRange.start.line, callable.nameRange.start.character, callable.nameRange.start.line, callable.nameRange.end.character), file: callable.file }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.duplicateFunctionImplementation(callable.name, callableContainer.scope.name)), { range: util_1.util.createRange(callable.nameRange.start.line, callable.nameRange.start.character, callable.nameRange.start.line, callable.nameRange.end.character), file: callable.file, origin: interfaces_1.DiagnosticOrigin.Scope }));
                 }
             }
         }
@@ -947,11 +926,11 @@ class Scope {
         let scriptImports = this.getOwnScriptImports();
         //verify every script import
         for (let scriptImport of scriptImports) {
-            let referencedFile = this.getFileByRelativePath(scriptImport.pkgPath);
+            let referencedFile = this.getFileByRelativePath(scriptImport.destPath);
             //if we can't find the file
             if (!referencedFile) {
                 //skip the default bslib file, it will exist at transpile time but should not show up in the program during validation cycle
-                if (scriptImport.pkgPath === `source${path.sep}bslib.brs`) {
+                if (scriptImport.destPath === this.program.bslibPkgPath) {
                     continue;
                 }
                 let dInfo;
@@ -961,11 +940,11 @@ class Scope {
                 else {
                     dInfo = DiagnosticMessages_1.DiagnosticMessages.referencedFileDoesNotExist();
                 }
-                this.diagnostics.push(Object.assign(Object.assign({}, dInfo), { range: scriptImport.filePathRange, file: scriptImport.sourceFile }));
+                this.diagnostics.push(Object.assign(Object.assign({}, dInfo), { range: scriptImport.filePathRange, file: scriptImport.sourceFile, origin: interfaces_1.DiagnosticOrigin.Scope }));
                 //if the character casing of the script import path does not match that of the actual path
             }
-            else if (scriptImport.pkgPath !== referencedFile.pkgPath) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.scriptImportCaseMismatch(referencedFile.pkgPath)), { range: scriptImport.filePathRange, file: scriptImport.sourceFile }));
+            else if (scriptImport.destPath !== referencedFile.destPath) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.scriptImportCaseMismatch(referencedFile.destPath)), { range: scriptImport.filePathRange, file: scriptImport.sourceFile, origin: interfaces_1.DiagnosticOrigin.Scope }));
             }
         }
     }
@@ -978,7 +957,7 @@ class Scope {
         }
         let files = this.getAllFiles();
         for (let file of files) {
-            if (file.pkgPath.toLowerCase() === relativePath.toLowerCase()) {
+            if (file.destPath.toLowerCase() === relativePath.toLowerCase()) {
                 return file;
             }
         }