brighterscript 1.0.0-alpha.40 → 1.0.0-alpha.42

package/dist/Program.js

@@ -44,6 +44,8 @@ const thenby_1 = require("thenby");
 const CrossScopeValidator_1 = require("./CrossScopeValidator");
 const DiagnosticManager_1 = require("./DiagnosticManager");
 const ProgramValidator_1 = require("./bscPlugin/validation/ProgramValidator");
+const SymbolTable_1 = require("./SymbolTable");
+const types_1 = require("./types");
 const bslibNonAliasedRokuModulesPkgPath = (0, util_1.standardizePath) `source/roku_modules/rokucommunity_bslib/bslib.brs`;
 const bslibAliasedRokuModulesPkgPath = (0, util_1.standardizePath) `source/roku_modules/bslib/bslib.brs`;
 class Program {
@@ -69,6 +71,17 @@ class Program {
          */
         this.globalScope = undefined;
         this.fileSymbolInformation = new Map();
+        /**
+         *  Map of typetime symbols which depend upon the key symbol
+         */
+        this.symbolDependencies = new Map();
+        /**
+         * Symbol Table for storing custom component types
+         * This is a sibling to the global table (as Components can be used/referenced anywhere)
+         * Keeping custom components out of the global table and in a specific symbol table
+         * compartmentalizes their use
+         */
+        this.componentsTable = new SymbolTable_1.SymbolTable('Custom Components');
         /**
          * A map of every file loaded into this program, indexed by its original file location
          */
@@ -93,8 +106,9 @@ class Program {
         this.components = {};
         /**
          * Keeps a set of all the components that need to have their types updated during the current validation cycle
+         * Map <componentKey, componentName>
          */
-        this.componentSymbolsToUpdate = new Set();
+        this.componentSymbolsToUpdate = new Map();
         this.crossScopeValidation = new CrossScopeValidator_1.CrossScopeValidator(this);
         this.isFirstValidation = true;
         this.sortedScopeNames = undefined;
@@ -121,6 +135,7 @@ class Program {
         this.globalScope.attachDependencyGraph(this.dependencyGraph);
         this.scopes.global = this.globalScope;
         this.populateGlobalSymbolTable();
+        this.globalScope.symbolTable.addSibling(this.componentsTable);
         //hardcode the files list for global scope to only contain the global file
         this.globalScope.getAllFiles = () => [globalCallables_1.globalFile];
         globalCallables_1.globalFile.isValidated = true;
@@ -147,11 +162,12 @@ class Program {
             }
             nodeType = new ComponentType_1.ComponentType(nodeData.name, parentNode);
             nodeType.addBuiltInInterfaces();
+            nodeType.isBuiltIn = true;
             if (nodeData.name === 'Node') {
                 // Add `roSGNode` as shorthand for `roSGNodeNode`
-                this.globalScope.symbolTable.addSymbol('roSGNode', { description: nodeData.description }, nodeType, 2 /* SymbolTypeFlag.typetime */);
+                this.globalScope.symbolTable.addSymbol('roSGNode', { description: nodeData.description, isBuiltIn: true }, nodeType, 2 /* SymbolTypeFlag.typetime */);
             }
-            this.globalScope.symbolTable.addSymbol(nodeName, { description: nodeData.description }, nodeType, 2 /* SymbolTypeFlag.typetime */);
+            this.globalScope.symbolTable.addSymbol(nodeName, { description: nodeData.description, isBuiltIn: true }, nodeType, 2 /* SymbolTypeFlag.typetime */);
         }
         else {
             nodeType = this.globalScope.symbolTable.getSymbolType(nodeName, { flags: 2 /* SymbolTypeFlag.typetime */ });
@@ -163,31 +179,34 @@ class Program {
      */
     populateGlobalSymbolTable() {
         //Setup primitive types in global symbolTable
-        this.globalScope.symbolTable.addSymbol('boolean', undefined, BooleanType_1.BooleanType.instance, 2 /* SymbolTypeFlag.typetime */);
-        this.globalScope.symbolTable.addSymbol('double', undefined, DoubleType_1.DoubleType.instance, 2 /* SymbolTypeFlag.typetime */);
-        this.globalScope.symbolTable.addSymbol('dynamic', undefined, DynamicType_1.DynamicType.instance, 2 /* SymbolTypeFlag.typetime */);
-        this.globalScope.symbolTable.addSymbol('float', undefined, FloatType_1.FloatType.instance, 2 /* SymbolTypeFlag.typetime */);
-        this.globalScope.symbolTable.addSymbol('function', undefined, new FunctionType_1.FunctionType(), 2 /* SymbolTypeFlag.typetime */);
-        this.globalScope.symbolTable.addSymbol('integer', undefined, IntegerType_1.IntegerType.instance, 2 /* SymbolTypeFlag.typetime */);
-        this.globalScope.symbolTable.addSymbol('longinteger', undefined, LongIntegerType_1.LongIntegerType.instance, 2 /* SymbolTypeFlag.typetime */);
-        this.globalScope.symbolTable.addSymbol('object', undefined, new ObjectType_1.ObjectType(), 2 /* SymbolTypeFlag.typetime */);
-        this.globalScope.symbolTable.addSymbol('string', undefined, StringType_1.StringType.instance, 2 /* SymbolTypeFlag.typetime */);
-        this.globalScope.symbolTable.addSymbol('void', undefined, VoidType_1.VoidType.instance, 2 /* SymbolTypeFlag.typetime */);
+        const builtInSymbolData = { isBuiltIn: true };
+        this.globalScope.symbolTable.addSymbol('boolean', builtInSymbolData, BooleanType_1.BooleanType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('double', builtInSymbolData, DoubleType_1.DoubleType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('dynamic', builtInSymbolData, DynamicType_1.DynamicType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('float', builtInSymbolData, FloatType_1.FloatType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('function', builtInSymbolData, new FunctionType_1.FunctionType(), 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('integer', builtInSymbolData, IntegerType_1.IntegerType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('longinteger', builtInSymbolData, LongIntegerType_1.LongIntegerType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('object', builtInSymbolData, new ObjectType_1.ObjectType(), 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('string', builtInSymbolData, StringType_1.StringType.instance, 2 /* SymbolTypeFlag.typetime */);
+        this.globalScope.symbolTable.addSymbol('void', builtInSymbolData, VoidType_1.VoidType.instance, 2 /* SymbolTypeFlag.typetime */);
         BuiltInInterfaceAdder_1.BuiltInInterfaceAdder.getLookupTable = () => this.globalScope.symbolTable;
         for (const callable of globalCallables_1.globalCallables) {
-            this.globalScope.symbolTable.addSymbol(callable.name, { description: callable.shortDescription }, callable.type, 1 /* SymbolTypeFlag.runtime */);
+            this.globalScope.symbolTable.addSymbol(callable.name, Object.assign(Object.assign({}, builtInSymbolData), { description: callable.shortDescription }), callable.type, 1 /* SymbolTypeFlag.runtime */);
         }
         for (const ifaceData of Object.values(roku_types_1.interfaces)) {
             const nodeType = new InterfaceType_1.InterfaceType(ifaceData.name);
             nodeType.addBuiltInInterfaces();
-            this.globalScope.symbolTable.addSymbol(ifaceData.name, { description: ifaceData.description }, nodeType, 2 /* SymbolTypeFlag.typetime */);
+            nodeType.isBuiltIn = true;
+            this.globalScope.symbolTable.addSymbol(ifaceData.name, Object.assign(Object.assign({}, builtInSymbolData), { description: ifaceData.description }), nodeType, 2 /* SymbolTypeFlag.typetime */);
         }
         for (const componentData of Object.values(roku_types_1.components)) {
             const nodeType = new InterfaceType_1.InterfaceType(componentData.name);
             nodeType.addBuiltInInterfaces();
+            nodeType.isBuiltIn = true;
             if (componentData.name !== 'roSGNode') {
                 // we will add `roSGNode` as shorthand for `roSGNodeNode`, since all roSgNode components are SceneGraph nodes
-                this.globalScope.symbolTable.addSymbol(componentData.name, { description: componentData.description }, nodeType, 2 /* SymbolTypeFlag.typetime */);
+                this.globalScope.symbolTable.addSymbol(componentData.name, Object.assign(Object.assign({}, builtInSymbolData), { description: componentData.description }), nodeType, 2 /* SymbolTypeFlag.typetime */);
             }
         }
         for (const nodeData of Object.values(roku_types_1.nodes)) {
@@ -196,7 +215,8 @@ class Program {
         for (const eventData of Object.values(roku_types_1.events)) {
             const nodeType = new InterfaceType_1.InterfaceType(eventData.name);
             nodeType.addBuiltInInterfaces();
-            this.globalScope.symbolTable.addSymbol(eventData.name, { description: eventData.description }, nodeType, 2 /* SymbolTypeFlag.typetime */);
+            nodeType.isBuiltIn = true;
+            this.globalScope.symbolTable.addSymbol(eventData.name, Object.assign(Object.assign({}, builtInSymbolData), { description: eventData.description }), nodeType, 2 /* SymbolTypeFlag.typetime */);
         }
     }
     addFileSymbolInfo(file) {
@@ -320,14 +340,19 @@ class Program {
      */
     addDeferredComponentTypeSymbolCreation(xmlFile) {
         var _a;
-        this.componentSymbolsToUpdate.add({ componentKey: this.getComponentKey(xmlFile), componentName: (_a = xmlFile.componentName) === null || _a === void 0 ? void 0 : _a.text });
+        const componentKey = this.getComponentKey(xmlFile);
+        const componentName = (_a = xmlFile.componentName) === null || _a === void 0 ? void 0 : _a.text;
+        if (this.componentSymbolsToUpdate.has(componentKey)) {
+            return;
+        }
+        this.componentSymbolsToUpdate.set(componentKey, componentName);
     }
     getComponentKey(xmlFile) {
         var _a, _b;
         return ((_b = (_a = xmlFile.componentName) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : xmlFile.pkgPath).toLowerCase();
     }
     /**
-     * Updates the global symbol table with the first component in this.components to have the same name as the component in the file
+     * Resolves symbol table with the first component in this.components to have the same name as the component in the file
      * @param componentKey key getting a component from `this.components`
      * @param componentName the unprefixed name of the component that will be added (e.g. 'MyLabel' NOT 'roSgNodeMyLabel')
      */
@@ -337,18 +362,53 @@ class Program {
             return;
         }
         const components = this.components[componentKey] || [];
+        const previousComponentType = this.componentsTable.getSymbolType(symbolName, { flags: 2 /* SymbolTypeFlag.typetime */ });
         // Remove any existing symbols that match
-        this.globalScope.symbolTable.removeSymbol(symbolName);
-        // There is a component that can be added - use it.
+        this.componentsTable.removeSymbol(symbolName);
         if (components.length > 0) {
+            // There is a component that can be added - use it.
             const componentScope = components[0].scope;
-            // TODO: May need to link symbol tables to get correct types for callfuncs
-            // componentScope.linkSymbolTable();
+            this.componentsTable.removeSymbol(symbolName);
+            componentScope.linkSymbolTable();
             const componentType = componentScope.getComponentType();
             if (componentType) {
-                this.globalScope.symbolTable.addSymbol(symbolName, {}, componentType, 2 /* SymbolTypeFlag.typetime */);
+                this.componentsTable.addSymbol(symbolName, {}, componentType, 2 /* SymbolTypeFlag.typetime */);
+            }
+            const typeData = {};
+            const isSameAsPrevious = previousComponentType && componentType.isEqual(previousComponentType, typeData);
+            const isComponentTypeDifferent = !previousComponentType || (0, reflection_1.isReferenceType)(previousComponentType) || !isSameAsPrevious;
+            componentScope.unlinkSymbolTable();
+            return isComponentTypeDifferent;
+        }
+        // There was a previous component type, but no new one, so it's different
+        return !!previousComponentType;
+    }
+    /**
+     * Adds a reference type to the global symbol table with the first component in this.components to have the same name as the component in the file
+     * This is so on a first validation, these types can be resolved in teh future (eg. when the actual component is created)
+     * If we don't add reference types at this top level, they will be created at the file level, and will never get resolved
+     * @param componentKey key getting a component from `this.components`
+     * @param componentName the unprefixed name of the component that will be added (e.g. 'MyLabel' NOT 'roSgNodeMyLabel')
+     */
+    addComponentReferenceType(componentKey, componentName) {
+        const symbolName = componentName ? util_1.util.getSgNodeTypeName(componentName) : undefined;
+        if (!symbolName) {
+            return;
+        }
+        const components = this.components[componentKey] || [];
+        if (components.length > 0) {
+            // There is a component that can be added,
+            if (!this.componentsTable.hasSymbol(symbolName, 2 /* SymbolTypeFlag.typetime */)) {
+                // it doesn't already exist in the table
+                const componentRefType = new types_1.ReferenceType(symbolName, symbolName, 2 /* SymbolTypeFlag.typetime */, () => this.componentsTable);
+                if (componentRefType) {
+                    this.componentsTable.addSymbol(symbolName, {}, componentRefType, 2 /* SymbolTypeFlag.typetime */);
+                }
             }
-            // TODO: Remember to unlink! componentScope.unlinkSymbolTable();
+        }
+        else {
+            // there is no component. remove from table
+            this.componentsTable.removeSymbol(symbolName);
         }
     }
     /**
@@ -514,7 +574,7 @@ class Program {
                     //create a new scope for this xml file
                     let scope = new XmlScope_1.XmlScope(file, this);
                     this.addScope(scope);
-                    //register this compoent now that we have parsed it and know its component name
+                    //register this componet now that we have parsed it and know its component name
                     this.registerComponent(file, scope);
                     //notify plugins that the scope is created and the component is registered
                     this.plugins.emit('afterScopeCreate', {
@@ -642,6 +702,7 @@ class Program {
             //if there is a scope named the same as this file's path, remove it (i.e. xml scopes)
             let scope = this.scopes[file.destPath];
             if (scope) {
+                this.logger.debug('Removing associated scope', scope.name);
                 const scopeDisposeEvent = {
                     program: this,
                     scope: scope
@@ -662,6 +723,7 @@ class Program {
                 this.dependencyGraph.removeDependency('scope:source', file.dependencyGraphKey);
             }
             if ((0, reflection_1.isBrsFile)(file)) {
+                this.logger.debug('Removing file symbol info', file.srcPath);
                 if (!keepSymbolInformation) {
                     this.fileSymbolInformation.delete(file.pkgPath);
                 }
@@ -669,8 +731,10 @@ class Program {
             }
             //if this is a component, remove it from our components map
             if ((0, reflection_1.isXmlFile)(file)) {
+                this.logger.debug('Unregistering component', file.srcPath);
                 this.unregisterComponent(file);
             }
+            this.logger.debug('Disposing file', file.srcPath);
             //dispose any disposable things on the file
             for (const disposable of (_c = file === null || file === void 0 ? void 0 : file.disposables) !== null && _c !== void 0 ? _c : []) {
                 disposable();
@@ -697,18 +761,43 @@ class Program {
                 fileValidationTime: '',
                 crossScopeValidationTime: '',
                 scopesValidated: 0,
+                changedSymbols: 0,
                 totalLinkTime: '',
                 totalScopeValidationTime: '',
-                componentValidationTime: ''
+                componentValidationTime: '',
+                changedSymbolsTime: ''
             };
             const validationStopwatch = new Stopwatch_1.Stopwatch();
             //validate every file
             const brsFilesValidated = [];
+            const xmlFilesValidated = [];
             const afterValidateFiles = [];
+            const sortedFiles = Object.values(this.files).sort((0, thenby_1.firstBy)(x => x.srcPath));
+            this.logger.time(logging_1.LogLevel.info, ['Prebuild component types'], () => {
+                // cast a wide net for potential changes in components
+                for (const file of sortedFiles) {
+                    if (file.isValidated) {
+                        continue;
+                    }
+                    if ((0, reflection_1.isXmlFile)(file)) {
+                        this.addDeferredComponentTypeSymbolCreation(file);
+                    }
+                    else if ((0, reflection_1.isBrsFile)(file)) {
+                        for (const scope of this.getScopesForFile(file)) {
+                            if ((0, reflection_1.isXmlScope)(scope)) {
+                                this.addDeferredComponentTypeSymbolCreation(scope.xmlFile);
+                            }
+                        }
+                    }
+                }
+                // Create reference component types for any component that changes
+                for (let [componentKey, componentName] of this.componentSymbolsToUpdate.entries()) {
+                    this.addComponentReferenceType(componentKey, componentName);
+                }
+            });
             metrics.fileValidationTime = validationStopwatch.getDurationTextFor(() => {
                 //sort files by path so we get consistent results
-                const files = Object.values(this.files).sort((0, thenby_1.firstBy)(x => x.srcPath));
-                for (const file of files) {
+                for (const file of sortedFiles) {
                     //for every unvalidated file, validate it
                     if (!file.isValidated) {
                         const validateFileEvent = {
@@ -722,6 +811,9 @@ class Program {
                         if ((0, reflection_1.isBrsFile)(file)) {
                             brsFilesValidated.push(file);
                         }
+                        else if ((0, reflection_1.isXmlFile)(file)) {
+                            xmlFilesValidated.push(file);
+                        }
                         afterValidateFiles.push(file);
                     }
                 }
@@ -735,27 +827,88 @@ class Program {
                 }
             }).durationText;
             metrics.filesChanged = afterValidateFiles.length;
+            const changedComponentTypes = [];
             // Build component types for any component that changes
             this.logger.time(logging_1.LogLevel.info, ['Build component types'], () => {
-                for (let { componentKey, componentName } of this.componentSymbolsToUpdate) {
-                    this.updateComponentSymbolInGlobalScope(componentKey, componentName);
+                for (let [componentKey, componentName] of this.componentSymbolsToUpdate.entries()) {
+                    if (this.updateComponentSymbolInGlobalScope(componentKey, componentName)) {
+                        changedComponentTypes.push(util_1.util.getSgNodeTypeName(componentName).toLowerCase());
+                    }
                 }
                 this.componentSymbolsToUpdate.clear();
             });
-            const changedSymbolsMapArr = brsFilesValidated === null || brsFilesValidated === void 0 ? void 0 : brsFilesValidated.map(f => {
-                if ((0, reflection_1.isBrsFile)(f)) {
-                    return f.providedSymbols.changes;
-                }
-                return null;
-            }).filter(x => x);
+            // get set of changed symbols
             const changedSymbols = new Map();
-            for (const flag of [1 /* SymbolTypeFlag.runtime */, 2 /* SymbolTypeFlag.typetime */]) {
-                const changedSymbolsSetArr = changedSymbolsMapArr.map(symMap => symMap.get(flag));
-                changedSymbols.set(flag, new Set(...changedSymbolsSetArr));
+            metrics.changedSymbolsTime = validationStopwatch.getDurationTextFor(() => {
+                var _a, _b, _c, _d;
+                const changedSymbolsMapArr = (_a = [...brsFilesValidated, ...xmlFilesValidated]) === null || _a === void 0 ? void 0 : _a.map(f => {
+                    if ((0, reflection_1.isBrsFile)(f)) {
+                        return f.providedSymbols.changes;
+                    }
+                    return null;
+                }).filter(x => x);
+                // update the map of typetime dependencies
+                for (const file of brsFilesValidated) {
+                    for (const [symbolName, provided] of file.providedSymbols.symbolMap.get(2 /* SymbolTypeFlag.typetime */).entries()) {
+                        // clear existing dependencies
+                        for (const values of this.symbolDependencies.values()) {
+                            values.delete(symbolName);
+                        }
+                        // map types to the set of types that depend upon them
+                        for (const dependentSymbol of (_c = (_b = provided.requiredSymbolNames) === null || _b === void 0 ? void 0 : _b.values()) !== null && _c !== void 0 ? _c : []) {
+                            const dependentSymbolLower = dependentSymbol.toLowerCase();
+                            if (!this.symbolDependencies.has(dependentSymbolLower)) {
+                                this.symbolDependencies.set(dependentSymbolLower, new Set());
+                            }
+                            const symbolsDependentUpon = this.symbolDependencies.get(dependentSymbolLower);
+                            symbolsDependentUpon.add(symbolName);
+                        }
+                    }
+                }
+                for (const flag of [1 /* SymbolTypeFlag.runtime */, 2 /* SymbolTypeFlag.typetime */]) {
+                    const changedSymbolsSetArr = changedSymbolsMapArr.map(symMap => symMap.get(flag));
+                    const changedSymbolSet = new Set();
+                    for (const changeSet of changedSymbolsSetArr) {
+                        for (const change of changeSet) {
+                            changedSymbolSet.add(change);
+                        }
+                    }
+                    changedSymbols.set(flag, changedSymbolSet);
+                }
+                // update changed symbol set with any changed component
+                for (const changedComponentType of changedComponentTypes) {
+                    changedSymbols.get(2 /* SymbolTypeFlag.typetime */).add(changedComponentType);
+                }
+                // Add any additional types that depend on a changed type
+                // as each iteration of the loop might add new types, need to keep checking until nothing new is added
+                const dependentTypesChanged = new Set();
+                let foundDependentTypes = false;
+                const changedTypeSymbols = changedSymbols.get(2 /* SymbolTypeFlag.typetime */);
+                do {
+                    foundDependentTypes = false;
+                    const allChangedTypesSofar = [...Array.from(changedTypeSymbols), ...Array.from(dependentTypesChanged)];
+                    for (const changedSymbol of allChangedTypesSofar) {
+                        const symbolsDependentUponChangedSymbol = (_d = this.symbolDependencies.get(changedSymbol)) !== null && _d !== void 0 ? _d : [];
+                        for (const symbolName of symbolsDependentUponChangedSymbol) {
+                            if (!changedTypeSymbols.has(symbolName) && !dependentTypesChanged.has(symbolName)) {
+                                foundDependentTypes = true;
+                                dependentTypesChanged.add(symbolName);
+                            }
+                        }
+                    }
+                } while (foundDependentTypes);
+                changedSymbols.set(2 /* SymbolTypeFlag.typetime */, new Set([...changedTypeSymbols, ...dependentTypesChanged]));
+            }).durationText;
+            if (this.options.logLevel === logging_1.LogLevel.debug) {
+                const changedRuntime = Array.from(changedSymbols.get(1 /* SymbolTypeFlag.runtime */)).sort();
+                this.logger.debug('Changed Symbols (runTime):', changedRuntime.join(', '));
+                const changedTypetime = Array.from(changedSymbols.get(2 /* SymbolTypeFlag.typetime */)).sort();
+                this.logger.debug('Changed Symbols (typeTime):', changedTypetime.join(', '));
             }
+            metrics.changedSymbols = changedSymbols.get(1 /* SymbolTypeFlag.runtime */).size + changedSymbols.get(2 /* SymbolTypeFlag.typetime */).size;
             const filesToBeValidatedInScopeContext = new Set(afterValidateFiles);
             metrics.crossScopeValidationTime = validationStopwatch.getDurationTextFor(() => {
-                const scopesToCheck = this.getScopesForCrossScopeValidation();
+                const scopesToCheck = this.getScopesForCrossScopeValidation(changedComponentTypes.length > 0);
                 this.crossScopeValidation.buildComponentsMap();
                 this.crossScopeValidation.addDiagnosticsForScopes(scopesToCheck);
                 const filesToRevalidate = this.crossScopeValidation.getFilesRequiringChangedSymbol(scopesToCheck, changedSymbols);
@@ -768,22 +921,26 @@ class Program {
             let validationTime = 0;
             let scopesValidated = 0;
             let changedFiles = new Set(afterValidateFiles);
+            this.currentScopeValidationOptions = {
+                filesToBeValidatedInScopeContext: filesToBeValidatedInScopeContext,
+                changedSymbols: changedSymbols,
+                changedFiles: changedFiles,
+                initialValidation: this.isFirstValidation
+            };
             this.logger.time(logging_1.LogLevel.info, ['Validate all scopes'], () => {
                 //sort the scope names so we get consistent results
                 const scopeNames = this.getSortedScopeNames();
                 for (const file of filesToBeValidatedInScopeContext) {
                     if ((0, reflection_1.isBrsFile)(file)) {
                         file.validationSegmenter.unValidateAllSegments();
+                        for (const scope of this.getScopesForFile(file)) {
+                            scope.invalidate();
+                        }
                     }
                 }
                 for (let scopeName of scopeNames) {
                     let scope = this.scopes[scopeName];
-                    const scopeValidated = scope.validate({
-                        filesToBeValidatedInScopeContext: filesToBeValidatedInScopeContext,
-                        changedSymbols: changedSymbols,
-                        changedFiles: changedFiles,
-                        initialValidation: this.isFirstValidation
-                    });
+                    const scopeValidated = scope.validate(this.currentScopeValidationOptions);
                     if (scopeValidated) {
                         scopesValidated++;
                     }
@@ -812,11 +969,11 @@ class Program {
         }
         this.logger.info(`Validation Metrics: ${logs.join(', ')}`);
     }
-    getScopesForCrossScopeValidation() {
+    getScopesForCrossScopeValidation(someComponentTypeChanged = false) {
         const scopesForCrossScopeValidation = [];
         for (let scopeName of this.getSortedScopeNames()) {
             let scope = this.scopes[scopeName];
-            if (this.globalScope !== scope && !scope.isValidated) {
+            if (this.globalScope !== scope && (someComponentTypeChanged || !scope.isValidated)) {
                 scopesForCrossScopeValidation.push(scope);
             }
         }