brighterscript 1.0.0-alpha.52 → 1.0.0-alpha.53

package/dist/Program.js

@@ -4,6 +4,7 @@ exports.Program = void 0;
 const assert = require("assert");
 const fsExtra = require("fs-extra");
 const path = require("path");
+const semver = require("semver");
 const vscode_languageserver_1 = require("vscode-languageserver");
 const Scope_1 = require("./Scope");
 const SymbolTable_1 = require("./SymbolTable");
@@ -16,6 +17,7 @@ const logging_1 = require("./logging");
 const chalk_1 = require("chalk");
 const globalCallables_1 = require("./globalCallables");
 const Manifest_1 = require("./preprocessor/Manifest");
+const RokuConstants_1 = require("./RokuConstants");
 const vscode_uri_1 = require("vscode-uri");
 const PluginInterface_1 = require("./PluginInterface");
 const reflection_1 = require("./astUtils/reflection");
@@ -53,6 +55,10 @@ const deferred_1 = require("./deferred");
 const roFunctionType_1 = require("./types/roFunctionType");
 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`;
+/**
+ * The built-in Roku SceneGraph nodes, keyed by their lower-case name
+ */
+const builtInSceneGraphNodes = roku_types_1.nodes;
 class Program {
     constructor(
     /**
@@ -121,6 +127,7 @@ class Program {
             xmlFilesValidated: [],
             changedSymbols: new Map(),
             changedComponentTypes: [],
+            scopesToInvalidate: [],
             scopesToValidate: [],
             filesToBeValidatedInScopeContext: new Set()
         };
@@ -140,12 +147,19 @@ class Program {
         this.validationMinSyncDuration = 75;
         this.getFilePathCache = new Map();
         this.sortedScopeNames = undefined;
+        this.scopesPerFile = new Map();
         this.getTranspiledFileContentsPipeline = new ActionPipeline_1.ActionPipeline();
         this.buildPipeline = new ActionPipeline_1.ActionPipeline();
         this.options = util_1.util.normalizeConfig(options);
         this.logger = logger !== null && logger !== void 0 ? logger : (0, logging_1.createLogger)(options);
         this.plugins = plugins || new PluginInterface_1.default([], { logger: this.logger });
         this.diagnostics = diagnosticsManager || new DiagnosticManager_1.DiagnosticManager();
+        //surface warnings for any deprecated bsconfig options that were used to build `this.options`
+        const deprecationDiagnostics = this.options._deprecationDiagnostics;
+        if ((deprecationDiagnostics === null || deprecationDiagnostics === void 0 ? void 0 : deprecationDiagnostics.length) > 0) {
+            this.diagnostics.register(deprecationDiagnostics);
+        }
+        delete this.options._deprecationDiagnostics;
         //try to find a location for the diagnostic if it doesn't have one
         this.diagnostics.locationResolver = (args) => {
             //find the first xml scope for this diagnostic
@@ -657,6 +671,112 @@ class Program {
         var _a;
         return (_a = this.getComponent(componentName)) === null || _a === void 0 ? void 0 : _a.scope;
     }
+    /**
+     * Get the names of all known SceneGraph nodes: the built-in Roku nodes plus every component
+     * defined in this program. Names keep their original casing and are deduplicated by lower-case name.
+     */
+    getSceneGraphNodeNames() {
+        var _a, _b;
+        const namesByLowerName = new Map();
+        for (const node of Object.values(builtInSceneGraphNodes)) {
+            namesByLowerName.set(node.name.toLowerCase(), node.name);
+        }
+        for (const componentName in this.components) {
+            const displayName = (_b = (_a = this.components[componentName][0]) === null || _a === void 0 ? void 0 : _a.file.componentName) === null || _b === void 0 ? void 0 : _b.text;
+            if (displayName) {
+                namesByLowerName.set(displayName.toLowerCase(), displayName);
+            }
+        }
+        return [...namesByLowerName.values()];
+    }
+    /**
+     * Determine whether a SceneGraph node with the given name exists, either as a built-in Roku node
+     * or as a component defined in this program.
+     */
+    hasSceneGraphNode(nodeName) {
+        if (!nodeName) {
+            return false;
+        }
+        return !!builtInSceneGraphNodes[nodeName.toLowerCase()] || !!this.getComponent(nodeName);
+    }
+    /**
+     * Get the built-in Roku node data and/or the project component file backing a SceneGraph node name.
+     * Returns `undefined` when no node or component matches.
+     */
+    getSceneGraphNode(nodeName) {
+        var _a;
+        if (!nodeName) {
+            return undefined;
+        }
+        const builtInNode = builtInSceneGraphNodes[nodeName.toLowerCase()];
+        const componentFile = (_a = this.getComponent(nodeName)) === null || _a === void 0 ? void 0 : _a.file;
+        if (!builtInNode && !componentFile) {
+            return undefined;
+        }
+        return { builtInNode: builtInNode, componentFile: componentFile };
+    }
+    /**
+     * Get every field available on a SceneGraph node, walking the full `extends` chain across both
+     * built-in Roku nodes and project components. Fields declared closer to the node take precedence
+     * over inherited fields with the same name.
+     */
+    getSceneGraphNodeFields(nodeName) {
+        const fieldsByLowerName = new Map();
+        const visitedNodeNames = new Set();
+        const addField = (field) => {
+            if (!field.name) {
+                return;
+            }
+            const lowerName = field.name.toLowerCase();
+            //the first definition we encounter is the closest one, so it wins
+            if (!fieldsByLowerName.has(lowerName)) {
+                fieldsByLowerName.set(lowerName, field);
+            }
+        };
+        const walk = (currentNodeName, origin) => {
+            var _a, _b, _c, _d, _e, _f;
+            const lowerName = currentNodeName === null || currentNodeName === void 0 ? void 0 : currentNodeName.toLowerCase();
+            if (!lowerName || visitedNodeNames.has(lowerName)) {
+                return;
+            }
+            visitedNodeNames.add(lowerName);
+            //prefer a project component (a project component can shadow a built-in of the same name)
+            const component = this.getComponent(currentNodeName);
+            if (component) {
+                for (const field of (_c = (_b = (_a = component.file.ast.componentElement) === null || _a === void 0 ? void 0 : _a.interfaceElement) === null || _b === void 0 ? void 0 : _b.fields) !== null && _c !== void 0 ? _c : []) {
+                    addField({ name: field.id, type: field.type, default: field.value, origin: origin });
+                }
+                const parentName = (_d = component.file.ast.componentElement) === null || _d === void 0 ? void 0 : _d.extends;
+                if (parentName) {
+                    walk(parentName, 'inherited');
+                }
+                return;
+            }
+            const builtInNode = builtInSceneGraphNodes[lowerName];
+            if (builtInNode) {
+                for (const field of (_e = builtInNode.fields) !== null && _e !== void 0 ? _e : []) {
+                    addField({
+                        name: field.name,
+                        type: field.type,
+                        default: field.default,
+                        description: field.description,
+                        accessPermission: field.accessPermission,
+                        origin: origin
+                    });
+                }
+                if ((_f = builtInNode.extends) === null || _f === void 0 ? void 0 : _f.name) {
+                    walk(builtInNode.extends.name, 'inherited');
+                }
+                else if (lowerName !== 'node') {
+                    //some scraped node entries are missing `extends` data, but every SceneGraph node
+                    //ultimately descends from Node, so fall back to Node to keep its universal fields
+                    walk('Node', 'inherited');
+                }
+            }
+        };
+        walk(nodeName, 'own');
+        return [...fieldsByLowerName.values()];
+    }
     /**
      * Update internal maps with this file reference
      */
@@ -665,9 +785,11 @@ class Program {
             file: file,
             program: this
         };
+        this.scopesPerFile.clear();
         this.plugins.emit('beforeAddFile', fileAddEvent);
         this.files[file.srcPath.toLowerCase()] = file;
         this.destMap.set(file.destPath.toLowerCase(), file);
+        this.plugins.emit('addFile', fileAddEvent);
         this.plugins.emit('afterAddFile', fileAddEvent);
         return file;
     }
@@ -677,6 +799,7 @@ class Program {
     unassignFile(file) {
         delete this.files[file.srcPath.toLowerCase()];
         this.destMap.delete(file.destPath.toLowerCase());
+        this.scopesPerFile.clear();
         return file;
     }
     setFile(fileParam, fileData) {
@@ -785,6 +908,7 @@ class Program {
             destPath = (0, util_1.standardizePath) `${util_1.util.replaceCaseInsensitive(srcPath, rootDir, '')}`;
         }
         else {
+            //`fileParam` here is `FileObj | { srcPath?: string; pkgPath?: string }`; duck-type across both shapes
             let param = fileParam;
             if (param.src) {
                 srcPath = (0, util_1.standardizePath) `${param.src}`;
@@ -884,6 +1008,7 @@ class Program {
             this.diagnostics.clearForFile(file.srcPath);
             const event = { file: file, program: this };
             this.plugins.emit('beforeRemoveFile', event);
+            this.plugins.emit('removeFile', event);
             //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) {
@@ -950,11 +1075,12 @@ class Program {
         const xmlFilesValidated = this.validationDetails.xmlFilesValidated;
         const changedSymbols = this.validationDetails.changedSymbols;
         const changedComponentTypes = this.validationDetails.changedComponentTypes;
+        const scopesToInvalidate = this.validationDetails.scopesToInvalidate;
         const scopesToValidate = this.validationDetails.scopesToValidate;
         const filesToBeValidatedInScopeContext = this.validationDetails.filesToBeValidatedInScopeContext;
         //validate every file
         let logValidateEnd = (status) => { };
-        //will be populated later on during the correspnding sequencer event
+        //will be populated later on during the corresponding sequencer event
         let filesToProcess;
         const sequencer = new Sequencer_1.Sequencer({
             name: 'program.validate',
@@ -1028,7 +1154,7 @@ class Program {
             if ((0, reflection_1.isXmlFile)(file)) {
                 this.addDeferredComponentTypeSymbolCreation(file);
             }
-            else if ((0, reflection_1.isBrsFile)(file)) {
+            else if ((0, reflection_1.isBrsFile)(file) && !this.isFirstValidation) {
                 const fileHasChanges = file.providedSymbols.changes.get(1 /* SymbolTypeFlag.runtime */).size > 0 || file.providedSymbols.changes.get(2 /* SymbolTypeFlag.typetime */).size > 0;
                 if (fileHasChanges) {
                     for (const scope of this.getScopesForFile(file)) {
@@ -1136,9 +1262,11 @@ class Program {
             this.logger.time(logging_1.LogLevel.info, ['addDiagnosticsForScopes'], () => {
                 this.crossScopeValidation.addDiagnosticsForScopes(scopesToCheck);
             });
-            const filesToRevalidate = this.crossScopeValidation.getFilesRequiringChangedSymbol(scopesToCheck, changedSymbols);
-            for (const file of filesToRevalidate) {
-                filesToBeValidatedInScopeContext.add(file);
+            if (!this.isFirstValidation) {
+                const filesToRevalidate = this.crossScopeValidation.getFilesRequiringChangedSymbol(scopesToCheck, changedSymbols);
+                for (const file of filesToRevalidate) {
+                    filesToBeValidatedInScopeContext.add(file);
+                }
             }
             this.currentScopeValidationOptions = {
                 filesToBeValidatedInScopeContext: filesToBeValidatedInScopeContext,
@@ -1149,18 +1277,29 @@ class Program {
             //can reset changedComponent types
             this.validationDetails.changedComponentTypes = [];
         })
-            .forEach('invalidate affected scopes', () => filesToBeValidatedInScopeContext, (file) => {
+            .forEach('invalidating file segments', () => filesToBeValidatedInScopeContext, (file) => {
             if ((0, reflection_1.isBrsFile)(file)) {
                 file.validationSegmenter.unValidateAllSegments();
-                for (const scope of this.getScopesForFile(file)) {
+                if (!this.isFirstValidation) {
+                    scopesToInvalidate.push(...this.getScopesForFile(file));
+                }
+            }
+        })
+            .once('invalidate affected scopes', () => {
+            if (this.isFirstValidation) {
+                for (const scope of this.getAllUserScopes()) {
+                    scope.invalidate();
+                }
+            }
+            else {
+                for (const scope of scopesToInvalidate) {
                     scope.invalidate();
                 }
             }
         })
             .once('checking scopes to validate', () => {
             //sort the scope names so we get consistent results
-            for (const scopeName of this.getSortedScopeNames()) {
-                let scope = this.scopes[scopeName];
+            for (const scope of this.getAllUserScopes()) {
                 if (scope.shouldValidate(this.currentScopeValidationOptions)) {
                     scopesToValidate.push(scope);
                 }
@@ -1184,17 +1323,21 @@ class Program {
         })
             .once('detect duplicate component names', () => {
             this.detectDuplicateComponentNames();
-            this.isFirstValidation = false;
-            // can reset other validation details
-            this.validationDetails.changedSymbols = new Map();
-            this.validationDetails.scopesToValidate = [];
-            this.validationDetails.filesToBeValidatedInScopeContext = new Set();
+        })
+            .once('detect diagnostic filter issues', () => {
+            this.diagnostics.detectPathLikeDiagnosticFilterCodes(this.options, { tags: [ProgramValidator_1.ProgramValidatorDiagnosticsTag] });
         })
             .onCancel(() => {
             logValidateEnd('cancelled');
         })
             .onSuccess(() => {
             logValidateEnd();
+            this.isFirstValidation = false;
+            // can reset other validation details
+            this.validationDetails.changedSymbols = new Map();
+            this.validationDetails.scopesToInvalidate = [];
+            this.validationDetails.scopesToValidate = [];
+            this.validationDetails.filesToBeValidatedInScopeContext = new Set();
         })
             .onComplete(() => {
             var _a, _b;
@@ -1228,8 +1371,7 @@ class Program {
     }
     getScopesForCrossScopeValidation(someComponentTypeChanged, didProvidedSymbolChange) {
         const scopesForCrossScopeValidation = [];
-        for (let scopeName of this.getSortedScopeNames()) {
-            let scope = this.scopes[scopeName];
+        for (let scope of this.getAllUserScopes()) {
             if (this.globalScope === scope) {
                 continue;
             }
@@ -1358,12 +1500,19 @@ class Program {
         }
         return this.sortedScopeNames;
     }
+    getAllUserScopes() {
+        return Object.values(this.scopes).filter(s => s.name !== 'global');
+    }
     /**
      * Get a list of all scopes the file is loaded into
      * @param file the file
      */
     getScopesForFile(file) {
         const resolvedFile = typeof file === 'string' ? this.getFile(file) : file;
+        const cachedResult = this.scopesPerFile.get(resolvedFile);
+        if (cachedResult) {
+            return cachedResult;
+        }
         let result = [];
         if (resolvedFile) {
             const scopeKeys = this.getSortedScopeNames();
@@ -1374,6 +1523,7 @@ class Program {
                 }
             }
         }
+        this.scopesPerFile.set(resolvedFile, result);
         return result;
     }
     /**
@@ -1515,9 +1665,6 @@ class Program {
         this.plugins.emit('afterProvideDefinition', event);
         return event.definitions;
     }
-    /**
-     * Get hover information for a file and position
-     */
     getHover(srcPath, position) {
         let file = this.getFile(srcPath);
         let result;
@@ -1643,8 +1790,9 @@ class Program {
     }
     /**
      * Compute "source fix all" code actions for the given file.
-     * Fires the `onGetSourceFixAllCodeActions` plugin event with all diagnostics for the file (no range filter),
-     * then converts each contributed SourceFixAllCodeAction into an LSP CodeAction.
+     * Fires the `provideSourceFixAllCodeActions` plugin event (along with its before/after variants)
+     * with all diagnostics for the file (no range filter), then converts each contributed
+     * SourceFixAllCodeAction into an LSP CodeAction.
      */
     getSourceFixAllCodeActions(srcPath) {
         const actions = [];
@@ -1655,13 +1803,16 @@ class Program {
                 .getDiagnostics()
                 .filter(x => { var _a; return ((_a = x.location) === null || _a === void 0 ? void 0 : _a.uri) === fileUri; });
             const scopes = this.getScopesForFile(file);
-            this.plugins.emit('onGetSourceFixAllCodeActions', {
+            const event = {
                 program: this,
                 file: file,
                 diagnostics: diagnostics,
                 scopes: scopes,
                 actions: actions
-            });
+            };
+            this.plugins.emit('beforeProvideSourceFixAllCodeActions', event);
+            this.plugins.emit('provideSourceFixAllCodeActions', event);
+            this.plugins.emit('afterProvideSourceFixAllCodeActions', event);
         }
         return actions.map(action => {
             var _a;
@@ -1899,6 +2050,7 @@ class Program {
             files: files,
             outDir: outDir
         });
+        await this.plugins.emitAsync('writeProgram', programEvent);
         //empty the out directory
         await fsExtra.emptyDir(outDir);
         const serializedFiles = [...files]
@@ -1931,6 +2083,7 @@ class Program {
                 editor: this.editor,
                 files: (_a = options === null || options === void 0 ? void 0 : options.files) !== null && _a !== void 0 ? _a : Object.values(this.files)
             });
+            await this.plugins.emitAsync('buildProgram', event);
             //prepare the program (and files) for building
             event.files = await this.prepare(event.files);
             //stage the entire program
@@ -2073,9 +2226,13 @@ class Program {
             const parsedManifest = (0, Manifest_1.parseManifest)(contents);
             this.buildBsConstsIntoParsedManifest(parsedManifest);
             this._manifest = parsedManifest;
+            this._manifestEntries = (0, Manifest_1.parseManifestEntries)(contents);
+            this._manifestPath = manifestPath;
         }
         catch (e) {
             this._manifest = new Map();
+            this._manifestEntries = [];
+            this._manifestPath = undefined;
         }
     }
     /**
@@ -2087,6 +2244,99 @@ class Program {
         }
         return this._manifest;
     }
+    /**
+     * Get the manifest as a list of `{ key, value, range }` entries with line/column ranges
+     * suitable for attaching diagnostics to specific manifest lines.
+     *
+     * NOTE: protected for now. The shape of this data is likely to evolve as we build out
+     * more manifest-aware features (validation rules, autocomplete, etc.). External plugins
+     * shouldn't depend on this until we commit to a stable API.
+     */
+    getManifestEntries() {
+        if (!this._manifestEntries) {
+            this.loadManifest();
+        }
+        return this._manifestEntries;
+    }
+    /**
+     * Returns the absolute path of the loaded manifest file, or undefined if no manifest was found.
+     *
+     * NOTE: protected for now. Once brighterscript treats the manifest as a proper file
+     * (with editor / BscFile integration) callers should consume that instead of poking at
+     * the Program. External plugins shouldn't depend on this in the meantime.
+     */
+    getManifestPath() {
+        if (!this._manifest) {
+            this.loadManifest();
+        }
+        return this._manifestPath;
+    }
+    /**
+     * The minimum Roku firmware version brighterscript should assume the user is targeting.
+     * If `options.minFirmwareVersion` is set AND parseable as semver, the canonical coerced
+     * form ("15.0" → "15.0.0") wins; otherwise (unset or unparseable) falls back to
+     * {@link DEFAULT_MIN_FIRMWARE_VERSION}. The return is always a valid semver string so
+     * downstream callers can pass it directly to `semver.gte`/`semver.lt` without re-coercing.
+     * Cached after first call.
+     */
+    getMinFirmwareVersion() {
+        if (this._minFirmwareVersion === undefined) {
+            const userValue = this.options.minFirmwareVersion;
+            const coerced = userValue ? semver.coerce(userValue) : undefined;
+            this._minFirmwareVersion = coerced ? coerced.version : RokuConstants_1.DEFAULT_MIN_FIRMWARE_VERSION;
+        }
+        return this._minFirmwareVersion;
+    }
+    /**
+     * What the project's target firmware natively understands, derived from
+     * {@link getMinFirmwareVersion}. These are facts about the device, not decisions about what
+     * to do — a caller finding a missing capability decides whether to transpile around it (as
+     * `continue` does) or report a diagnostic (as optional chaining does).
+     * Cached after first call.
+     */
+    get firmwareCapabilities() {
+        if (this._firmwareCapabilities === undefined) {
+            this._firmwareCapabilities = (0, RokuConstants_1.getFirmwareCapabilities)(this.getMinFirmwareVersion());
+        }
+        return this._firmwareCapabilities;
+    }
+    /**
+     * Returns the effective `rsg_version` for this program in canonical semver form (e.g. "1.2"
+     * → "1.2.0"). If the manifest declares a value explicitly and it's parseable, the canonical
+     * form wins; otherwise (manifest silent OR value is malformed) we fall back to the highest
+     * known rsg_version whose `becameDefaultAt` is `<=` the effective minimum firmware version,
+     * driven by {@link RSG_VERSIONS}. Cached after first call.
+     *
+     * Manifest validation (format errors, etc.) happens in `ProgramValidator` against the raw
+     * entry — that path doesn't go through this method.
+     */
+    getRsgVersion() {
+        if (this._rsgVersion !== undefined) {
+            return this._rsgVersion;
+        }
+        const explicit = this.getManifest().get('rsg_version');
+        const explicitCoerced = explicit !== undefined ? semver.coerce(explicit.trim()) : undefined;
+        if (explicitCoerced) {
+            this._rsgVersion = explicitCoerced.version;
+            return this._rsgVersion;
+        }
+        //walk known rsg_versions in descending order (newest first) and return the first whose
+        //becameDefaultAt <= effective firmware. As long as some entry has becameDefaultAt: '0.0.0'
+        //(currently `1.1`), this loop always finds a match.
+        const minFirmwareVersion = this.getMinFirmwareVersion();
+        const candidates = Object.entries(RokuConstants_1.RSG_VERSIONS)
+            .filter(([, info]) => info.becameDefaultAt !== undefined)
+            .sort(([a], [b]) => semver.rcompare(semver.coerce(a), semver.coerce(b)));
+        for (const [version, info] of candidates) {
+            if (semver.gte(minFirmwareVersion, info.becameDefaultAt)) {
+                this._rsgVersion = semver.coerce(version).version;
+                return this._rsgVersion;
+            }
+        }
+        //unreachable as long as RSG_VERSIONS contains an entry with becameDefaultAt: '0.0.0'
+        this._rsgVersion = RokuConstants_1.DEFAULT_MIN_FIRMWARE_VERSION;
+        return this._rsgVersion;
+    }
     dispose() {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         this.plugins.emit('beforeRemoveProgram', { program: this });