brighterscript 0.70.3 → 0.71.0

package/dist/bscPlugin/codeActions/CodeActionsProcessor.js

@@ -7,35 +7,129 @@ const DiagnosticMessages_1 = require("../../DiagnosticMessages");
 const Parser_1 = require("../../parser/Parser");
 const util_1 = require("../../util");
 const reflection_1 = require("../../astUtils/reflection");
+const visitors_1 = require("../../astUtils/visitors");
 const TokenKind_1 = require("../../lexer/TokenKind");
 class CodeActionsProcessor {
     constructor(event) {
         this.event = event;
         this.suggestedImports = new Set();
     }
+    /**
+     * Processes all diagnostics in the event and emits code actions for each recognized diagnostic code.
+     */
     process() {
+        // First pass: individual fixes for each diagnostic at the cursor position
         for (const diagnostic of this.event.diagnostics) {
             if (diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.cannotFindName || diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.cannotFindFunction) {
-                this.suggestCannotFindName(diagnostic);
+                this.suggestCannotFindNameQuickFix(diagnostic);
             }
             else if (diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.classCouldNotBeFound) {
-                this.suggestClassImports(diagnostic);
+                this.suggestClassImportQuickFix(diagnostic);
             }
             else if (diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.xmlComponentMissingExtendsAttribute) {
-                this.addMissingExtends(diagnostic);
+                this.suggestMissingExtendsQuickFix(diagnostic);
             }
             else if (diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.voidFunctionMayNotReturnValue) {
-                this.addVoidFunctionReturnActions(diagnostic);
+                this.suggestVoidFunctionReturnQuickFixes([diagnostic]);
             }
             else if (diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.nonVoidFunctionMustReturnValue) {
-                this.addNonVoidFunctionReturnActions(diagnostic);
+                this.suggestNonVoidFunctionReturnQuickFixes([diagnostic]);
+            }
+            else if (diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.referencedFileDoesNotExist) {
+                this.suggestRemoveScriptImportQuickFixes([diagnostic]);
+            }
+            else if (diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.unnecessaryScriptImportInChildFromParent) {
+                this.suggestRemoveScriptImportQuickFixes([diagnostic]);
+            }
+            else if (diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.unnecessaryCodebehindScriptImport) {
+                this.suggestRemoveScriptImportQuickFixes([diagnostic]);
+            }
+            else if (diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.scriptImportCaseMismatch) {
+                this.suggestScriptImportCasingQuickFixes([diagnostic]);
+            }
+            else if (diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.missingOverrideKeyword) {
+                this.suggestMissingOverrideQuickFixes([diagnostic]);
+            }
+            else if (diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.cannotUseOverrideKeywordOnConstructorFunction) {
+                this.suggestRemoveOverrideFromConstructorQuickFixes([diagnostic]);
+            }
+        }
+        // Second pass: fix-all actions for any code that appeared in the event.
+        // Also makes sure that fix-all actions appear after individual fixes
+        const eventCodes = new Set(this.event.diagnostics.map(d => d.code));
+        const fixAllDiagsByCode = this.collectFixAllDiagnostics(eventCodes);
+        // only offer fix-all when there are multiple instances of the same issue in the file
+        for (const [code, allInFile] of fixAllDiagsByCode) {
+            if (allInFile.length > 1) {
+                if (code === DiagnosticMessages_1.DiagnosticCodeMap.voidFunctionMayNotReturnValue) {
+                    this.suggestVoidFunctionReturnQuickFixes(allInFile);
+                }
+                else if (code === DiagnosticMessages_1.DiagnosticCodeMap.nonVoidFunctionMustReturnValue) {
+                    this.suggestNonVoidFunctionReturnQuickFixes(allInFile);
+                }
+                else if (code === DiagnosticMessages_1.DiagnosticCodeMap.unnecessaryCodebehindScriptImport) {
+                    this.suggestRemoveScriptImportQuickFixes(allInFile);
+                }
+                else if (code === DiagnosticMessages_1.DiagnosticCodeMap.cannotUseOverrideKeywordOnConstructorFunction) {
+                    this.suggestRemoveOverrideFromConstructorQuickFixes(allInFile);
+                }
+                else if (code === DiagnosticMessages_1.DiagnosticCodeMap.referencedFileDoesNotExist) {
+                    this.suggestRemoveScriptImportQuickFixes(allInFile);
+                }
+                else if (code === DiagnosticMessages_1.DiagnosticCodeMap.unnecessaryScriptImportInChildFromParent) {
+                    this.suggestRemoveScriptImportQuickFixes(allInFile);
+                }
+                else if (code === DiagnosticMessages_1.DiagnosticCodeMap.scriptImportCaseMismatch) {
+                    this.suggestScriptImportCasingQuickFixes(allInFile);
+                }
+                else if (code === DiagnosticMessages_1.DiagnosticCodeMap.missingOverrideKeyword) {
+                    this.suggestMissingOverrideQuickFixes(allInFile);
+                }
             }
         }
+        // Import fix-all aggregates across multiple codes so it runs as its own step
+        if (eventCodes.has(DiagnosticMessages_1.DiagnosticCodeMap.cannotFindName) ||
+            eventCodes.has(DiagnosticMessages_1.DiagnosticCodeMap.cannotFindFunction) ||
+            eventCodes.has(DiagnosticMessages_1.DiagnosticCodeMap.classCouldNotBeFound)) {
+            this.suggestMissingImportsFixAllQuickFix();
+        }
+        this.suggestedImports.clear();
+    }
+    /**
+     * Builds a map of diagnostic code → all matching diagnostics in the current file for each
+     * code in `eventCodes`. Scope-level codes are not present in `file.getDiagnostics()` so they
+     * are sourced from `program.getDiagnostics()` (fetched lazily, only when needed).
+     */
+    collectFixAllDiagnostics(eventCodes) {
+        var _a;
+        const scopeLevelCodes = new Set([
+            DiagnosticMessages_1.DiagnosticCodeMap.referencedFileDoesNotExist,
+            DiagnosticMessages_1.DiagnosticCodeMap.unnecessaryScriptImportInChildFromParent,
+            DiagnosticMessages_1.DiagnosticCodeMap.scriptImportCaseMismatch,
+            DiagnosticMessages_1.DiagnosticCodeMap.missingOverrideKeyword
+        ]);
+        const fileDiagsByCode = new Map();
+        for (const d of this.event.file.getDiagnostics()) {
+            if (!fileDiagsByCode.has(d.code)) {
+                fileDiagsByCode.set(d.code, []);
+            }
+            fileDiagsByCode.get(d.code).push(d);
+        }
+        const allScopeFileDiags = [...eventCodes].some(c => scopeLevelCodes.has(c))
+            ? this.event.program.getDiagnostics().filter(d => d.file === this.event.file)
+            : [];
+        const result = new Map();
+        for (const code of eventCodes) {
+            result.set(code, scopeLevelCodes.has(code)
+                ? allScopeFileDiags.filter(d => d.code === code)
+                : (_a = fileDiagsByCode.get(code)) !== null && _a !== void 0 ? _a : []);
+        }
+        return result;
     }
     /**
      * Generic import suggestion function. Shouldn't be called directly from the main loop, but instead called by more specific diagnostic handlers
      */
-    suggestImports(diagnostic, key, files) {
+    suggestImportQuickFix(diagnostic, key, files) {
         var _a, _b, _c;
         //skip if we already have this suggestion
         if (this.suggestedImports.has(key)) {
@@ -62,29 +156,102 @@ class CodeActionsProcessor {
             }));
         }
     }
-    suggestCannotFindName(diagnostic) {
+    /**
+     * Suggests import statements for an unresolved name (function, class, namespace, or enum).
+     */
+    suggestCannotFindNameQuickFix(diagnostic) {
         var _a;
         //skip if not a BrighterScript file
         if (diagnostic.file.parseMode !== Parser_1.ParseMode.BrighterScript) {
             return;
         }
         const lowerName = ((_a = diagnostic.data.fullName) !== null && _a !== void 0 ? _a : diagnostic.data.name).toLowerCase();
-        this.suggestImports(diagnostic, lowerName, [
+        this.suggestImportQuickFix(diagnostic, lowerName, [
             ...this.event.file.program.findFilesForFunction(lowerName),
             ...this.event.file.program.findFilesForClass(lowerName),
             ...this.event.file.program.findFilesForNamespace(lowerName),
             ...this.event.file.program.findFilesForEnum(lowerName)
         ]);
     }
-    suggestClassImports(diagnostic) {
+    /**
+     * Suggests import statements for an unresolved class name.
+     */
+    suggestClassImportQuickFix(diagnostic) {
         //skip if not a BrighterScript file
         if (diagnostic.file.parseMode !== Parser_1.ParseMode.BrighterScript) {
             return;
         }
         const lowerClassName = diagnostic.data.className.toLowerCase();
-        this.suggestImports(diagnostic, lowerClassName, this.event.file.program.findFilesForClass(lowerClassName));
+        this.suggestImportQuickFix(diagnostic, lowerClassName, this.event.file.program.findFilesForClass(lowerClassName));
     }
-    addMissingExtends(diagnostic) {
+    /**
+     * Scans all import-related diagnostics in the file and emits a single composite
+     * "Fix all: Add missing imports" action when 2+ unambiguous imports are needed.
+     * Ambiguous names (multiple possible source files) are excluded since we cannot
+     * automatically choose one.
+     */
+    suggestMissingImportsFixAllQuickFix() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        if (!(0, reflection_1.isBrsFile)(this.event.file) || this.event.file.parseMode !== Parser_1.ParseMode.BrighterScript) {
+            return;
+        }
+        const file = this.event.file;
+        const importStatements = file.parser.references.importStatements;
+        const insertPosition = (_c = (_b = (_a = importStatements[importStatements.length - 1]) === null || _a === void 0 ? void 0 : _a.importToken.range) === null || _b === void 0 ? void 0 : _b.start) !== null && _c !== void 0 ? _c : util_1.util.createPosition(0, 0);
+        const changes = [];
+        const addedPaths = new Set();
+        // cannotFindName/classCouldNotBeFound are scope-level diagnostics, so we must
+        // use program.getDiagnostics() (filtered by file) rather than file.getDiagnostics().
+        const allFileDiagnostics = this.event.program.getDiagnostics().filter(d => d.file === file);
+        for (const diagnostic of allFileDiagnostics) {
+            let files = [];
+            if (diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.cannotFindName || diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.cannotFindFunction) {
+                const cannotFindNameDiagnostic = diagnostic;
+                const lowerName = (_g = ((_e = (_d = cannotFindNameDiagnostic.data) === null || _d === void 0 ? void 0 : _d.fullName) !== null && _e !== void 0 ? _e : (_f = cannotFindNameDiagnostic.data) === null || _f === void 0 ? void 0 : _f.name)) === null || _g === void 0 ? void 0 : _g.toLowerCase();
+                if (lowerName) {
+                    files = [
+                        ...file.program.findFilesForFunction(lowerName),
+                        ...file.program.findFilesForClass(lowerName),
+                        ...file.program.findFilesForNamespace(lowerName),
+                        ...file.program.findFilesForEnum(lowerName)
+                    ];
+                }
+            }
+            else if (diagnostic.code === DiagnosticMessages_1.DiagnosticCodeMap.classCouldNotBeFound) {
+                const classCouldNotBeFoundDiagnostic = diagnostic;
+                const lowerClassName = (_j = (_h = classCouldNotBeFoundDiagnostic.data) === null || _h === void 0 ? void 0 : _h.className) === null || _j === void 0 ? void 0 : _j.toLowerCase();
+                if (lowerClassName) {
+                    files = file.program.findFilesForClass(lowerClassName);
+                }
+            }
+            //skip ambiguous names — we can't choose a file automatically
+            if (files.length !== 1) {
+                continue;
+            }
+            const pkgPath = util_1.util.getRokuPkgPath(files[0].pkgPath);
+            if (!addedPaths.has(pkgPath)) {
+                addedPaths.add(pkgPath);
+                changes.push({
+                    type: 'insert',
+                    filePath: file.srcPath,
+                    position: insertPosition,
+                    newText: `import "${pkgPath}"\n`
+                });
+            }
+        }
+        if (changes.length > 1) {
+            this.event.codeActions.push(CodeActionUtil_1.codeActionUtil.createCodeAction({
+                title: `Fix all: Auto fixable missing imports`,
+                kind: vscode_languageserver_1.CodeActionKind.QuickFix,
+                changes: changes
+            }));
+        }
+    }
+    /**
+     * Adds code actions to insert a missing `extends` attribute on an XML component tag.
+     * Offers Group, Task, and ContentNode as common choices.
+     */
+    suggestMissingExtendsQuickFix(diagnostic) {
         var _a;
         const srcPath = this.event.file.srcPath;
         const { component } = this.event.file.parser.ast;
@@ -125,19 +292,17 @@ class CodeActionsProcessor {
                 }]
         }));
     }
-    addVoidFunctionReturnActions(diagnostic) {
+    /**
+     * Adds code actions to resolve a `voidFunctionMayNotReturnValue` diagnostic.
+     * Offers removing the return value, converting sub→function, or removing an `as void` return type.
+     */
+    suggestVoidFunctionReturnQuickFixes(diagnostics) {
         var _a, _b, _c, _d;
-        this.event.codeActions.push(CodeActionUtil_1.codeActionUtil.createCodeAction({
-            title: `Remove return value`,
-            diagnostics: [diagnostic],
-            kind: vscode_languageserver_1.CodeActionKind.QuickFix,
-            changes: [{
-                    type: 'delete',
-                    filePath: this.event.file.srcPath,
-                    range: util_1.util.createRange(diagnostic.range.start.line, diagnostic.range.start.character + 'return'.length, diagnostic.range.end.line, diagnostic.range.end.character)
-                }]
-        }));
-        if ((0, reflection_1.isBrsFile)(this.event.file)) {
+        const changes = diagnostics.map(d => this.getRemoveReturnValueChange(d));
+        this.emitOrFixAll(`Remove return value`, `Fix all: Remove void return values`, changes, diagnostics[0]);
+        //contextual BrsFile actions only apply to the individual (single-violation) case
+        if (changes.length === 1 && (0, reflection_1.isBrsFile)(this.event.file)) {
+            const diagnostic = diagnostics[0];
             const expression = this.event.file.getClosestExpression(diagnostic.range.start);
             const func = expression.findAncestor(reflection_1.isFunctionExpression);
             //if we're in a sub and we do not have a return type, suggest converting to a function
@@ -154,19 +319,9 @@ class CodeActionsProcessor {
                     kind: vscode_languageserver_1.CodeActionKind.QuickFix,
                     changes: [
                         //function
-                        {
-                            type: 'replace',
-                            filePath: this.event.file.srcPath,
-                            range: func.functionType.range,
-                            newText: functionTypeText
-                        },
+                        { type: 'replace', filePath: this.event.file.srcPath, range: func.functionType.range, newText: functionTypeText },
                         //end function
-                        {
-                            type: 'replace',
-                            filePath: this.event.file.srcPath,
-                            range: func.end.range,
-                            newText: endFunctionTypeText
-                        }
+                        { type: 'replace', filePath: this.event.file.srcPath, range: func.end.range, newText: endFunctionTypeText }
                     ]
                 }));
             }
@@ -176,90 +331,217 @@ class CodeActionsProcessor {
                     title: `Remove return type from function declaration`,
                     diagnostics: [diagnostic],
                     kind: vscode_languageserver_1.CodeActionKind.QuickFix,
-                    changes: [{
-                            type: 'delete',
-                            filePath: this.event.file.srcPath,
-                            // )| as void|
-                            range: util_1.util.createRange(func.rightParen.range.start.line, func.rightParen.range.start.character + 1, func.returnTypeToken.range.end.line, func.returnTypeToken.range.end.character)
-                        }]
+                    changes: [this.getRemoveFunctionReturnTypeChange(func)]
                 }));
             }
         }
     }
-    addNonVoidFunctionReturnActions(diagnostic) {
+    /**
+     * Adds code actions to resolve a `nonVoidFunctionMustReturnValue` diagnostic.
+     * Offers removing the return type from a sub, adding `as void` to a function, or converting function→sub.
+     */
+    suggestNonVoidFunctionReturnQuickFixes(diagnostics) {
+        if (!(0, reflection_1.isBrsFile)(this.event.file)) {
+            return;
+        }
+        const file = this.event.file;
+        //find tokens for `as`, `void`, `sub`, `end sub` in the file if possible
+        let asText;
+        let voidText;
+        let subText;
+        let endSubText;
+        for (const token of file.parser.tokens) {
+            if (asText && voidText && subText && endSubText) {
+                break;
+            }
+            if ((token === null || token === void 0 ? void 0 : token.kind) === TokenKind_1.TokenKind.As) {
+                asText = token === null || token === void 0 ? void 0 : token.text;
+            }
+            else if ((token === null || token === void 0 ? void 0 : token.kind) === TokenKind_1.TokenKind.Void) {
+                voidText = token === null || token === void 0 ? void 0 : token.text;
+            }
+            else if ((token === null || token === void 0 ? void 0 : token.kind) === TokenKind_1.TokenKind.Sub) {
+                subText = token === null || token === void 0 ? void 0 : token.text;
+            }
+            else if ((token === null || token === void 0 ? void 0 : token.kind) === TokenKind_1.TokenKind.EndSub) {
+                endSubText = token === null || token === void 0 ? void 0 : token.text;
+            }
+        }
+        // Build per-fix-type change arrays, deduplicating by enclosing function so that one
+        // function with multiple bare returns only contributes one change.
+        const removeReturnTypeChanges = [];
+        const addVoidChanges = [];
+        const seenFunctions = new Set();
+        for (const d of diagnostics) {
+            const expr = file.getClosestExpression(d.range.start);
+            const fn = expr === null || expr === void 0 ? void 0 : expr.findAncestor(reflection_1.isFunctionExpression);
+            if (!fn) {
+                continue;
+            }
+            const fnKey = `${fn.range.start.line}:${fn.range.start.character}`;
+            if (seenFunctions.has(fnKey)) {
+                continue;
+            }
+            seenFunctions.add(fnKey);
+            if (fn.functionType.kind === TokenKind_1.TokenKind.Sub && fn.returnTypeToken && fn.returnTypeToken.kind !== TokenKind_1.TokenKind.Void) {
+                removeReturnTypeChanges.push(this.getRemoveFunctionReturnTypeChange(fn));
+            }
+            else if (fn.functionType.kind === TokenKind_1.TokenKind.Function && !fn.returnTypeToken) {
+                addVoidChanges.push({
+                    type: 'insert',
+                    filePath: this.event.file.srcPath,
+                    position: fn.rightParen.range.end,
+                    newText: ` ${asText !== null && asText !== void 0 ? asText : 'as'} ${voidText !== null && voidText !== void 0 ? voidText : 'void'}`
+                });
+            }
+        }
+        this.emitOrFixAll(`Remove return type from sub declaration`, `Fix all: Remove return type from sub declarations`, removeReturnTypeChanges, diagnostics[0]);
+        this.emitOrFixAll(`Add void return type to function declaration`, `Fix all: Add void return type to function declarations`, addVoidChanges, diagnostics[0]);
+        //'Convert function to sub' has no fix-all variant; only add it for the individual case
+        if (addVoidChanges.length === 1 && diagnostics.length === 1) {
+            const func = file.getClosestExpression(diagnostics[0].range.start).findAncestor(reflection_1.isFunctionExpression);
+            this.event.codeActions.push(CodeActionUtil_1.codeActionUtil.createCodeAction({
+                title: `Convert function to sub`,
+                diagnostics: [diagnostics[0]],
+                kind: vscode_languageserver_1.CodeActionKind.QuickFix,
+                changes: [
+                    { type: 'replace', filePath: file.srcPath, range: func.functionType.range, newText: subText !== null && subText !== void 0 ? subText : 'sub' },
+                    { type: 'replace', filePath: file.srcPath, range: func.end.range, newText: endSubText !== null && endSubText !== void 0 ? endSubText : 'end sub' }
+                ]
+            }));
+        }
+    }
+    // ---- script import fixes ----
+    /**
+     * Adds code actions to delete one or more unnecessary or broken script import lines.
+     */
+    suggestRemoveScriptImportQuickFixes(diagnostics) {
+        var _a, _b;
+        const titles = {
+            [DiagnosticMessages_1.DiagnosticCodeMap.unnecessaryScriptImportInChildFromParent]: ['Remove redundant script import', 'Fix all: Remove redundant script imports'],
+            [DiagnosticMessages_1.DiagnosticCodeMap.unnecessaryCodebehindScriptImport]: ['Remove unnecessary codebehind import', 'Fix all: Remove unnecessary codebehind imports']
+        };
+        const [singleTitle, fixAllTitle] = (_b = titles[(_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.code]) !== null && _b !== void 0 ? _b : ['Remove script import', 'Fix all: Remove script imports'];
+        const changes = diagnostics.map(diagnostic => {
+            return {
+                type: 'delete',
+                filePath: this.event.file.srcPath,
+                range: util_1.util.createRange(diagnostic.range.start.line, 0, diagnostic.range.start.line + 1, 0)
+            };
+        });
+        this.emitOrFixAll(singleTitle, fixAllTitle, changes, diagnostics[0]);
+    }
+    /**
+     * Adds code actions to correct the casing of script import paths to match the actual file name on disk.
+     */
+    suggestScriptImportCasingQuickFixes(diagnostics) {
         var _a;
-        if ((0, reflection_1.isBrsFile)(this.event.file)) {
-            const expression = this.event.file.getClosestExpression(diagnostic.range.start);
-            const func = expression.findAncestor(reflection_1.isFunctionExpression);
-            //`sub as <non-void type>`, suggest removing the return type
-            if (func.functionType.kind === TokenKind_1.TokenKind.Sub && func.returnTypeToken && ((_a = func.returnTypeToken) === null || _a === void 0 ? void 0 : _a.kind) !== TokenKind_1.TokenKind.Void) {
-                this.event.codeActions.push(CodeActionUtil_1.codeActionUtil.createCodeAction({
-                    title: `Remove return type from sub declaration`,
-                    diagnostics: [diagnostic],
-                    kind: vscode_languageserver_1.CodeActionKind.QuickFix,
-                    changes: [{
-                            type: 'delete',
-                            filePath: this.event.file.srcPath,
-                            // )| as void|
-                            range: util_1.util.createRange(func.rightParen.range.start.line, func.rightParen.range.start.character + 1, func.returnTypeToken.range.end.line, func.returnTypeToken.range.end.character)
-                        }]
-                }));
+        const changes = [];
+        for (const diagnostic of diagnostics) {
+            const correctFilePath = (_a = diagnostic.data) === null || _a === void 0 ? void 0 : _a.correctFilePath;
+            if (!correctFilePath) {
+                continue;
             }
-            //function with no return type.
-            if (func.functionType.kind === TokenKind_1.TokenKind.Function && !func.returnTypeToken) {
-                //find tokens for `as` and `void` in the file if possible
-                let asText;
-                let voidText;
-                let subText;
-                let endSubText;
-                for (const token of this.event.file.parser.tokens) {
-                    if (asText && voidText && subText && endSubText) {
-                        break;
-                    }
-                    if ((token === null || token === void 0 ? void 0 : token.kind) === TokenKind_1.TokenKind.As) {
-                        asText = token === null || token === void 0 ? void 0 : token.text;
-                    }
-                    else if ((token === null || token === void 0 ? void 0 : token.kind) === TokenKind_1.TokenKind.Void) {
-                        voidText = token === null || token === void 0 ? void 0 : token.text;
-                    }
-                    else if ((token === null || token === void 0 ? void 0 : token.kind) === TokenKind_1.TokenKind.Sub) {
-                        subText = token === null || token === void 0 ? void 0 : token.text;
-                    }
-                    else if ((token === null || token === void 0 ? void 0 : token.kind) === TokenKind_1.TokenKind.EndSub) {
-                        endSubText = token === null || token === void 0 ? void 0 : token.text;
-                    }
+            changes.push({
+                type: 'replace',
+                filePath: this.event.file.srcPath,
+                range: diagnostic.range,
+                newText: correctFilePath
+            });
+        }
+        this.emitOrFixAll('Fix script import path casing', 'Fix all: Fix script import path casing', changes, diagnostics[0]);
+    }
+    // ---- override keyword fixes ----
+    /**
+     * Adds code actions to insert the missing `override` keyword before a method declaration.
+     */
+    suggestMissingOverrideQuickFixes(diagnostics) {
+        if (!(0, reflection_1.isBrsFile)(this.event.file)) {
+            return;
+        }
+        const file = this.event.file;
+        const changes = [];
+        for (const diagnostic of diagnostics) {
+            let insertPosition;
+            file.ast.walk((node) => {
+                var _a, _b, _c, _d, _e, _f;
+                if ((0, reflection_1.isMethodStatement)(node) &&
+                    ((_b = (_a = node.range) === null || _a === void 0 ? void 0 : _a.start) === null || _b === void 0 ? void 0 : _b.line) === diagnostic.range.start.line &&
+                    ((_d = (_c = node.range) === null || _c === void 0 ? void 0 : _c.start) === null || _d === void 0 ? void 0 : _d.character) === diagnostic.range.start.character) {
+                    insertPosition = (_f = (_e = node.func.functionType) === null || _e === void 0 ? void 0 : _e.range) === null || _f === void 0 ? void 0 : _f.start;
                 }
-                //suggest converting to `as void`
-                this.event.codeActions.push(CodeActionUtil_1.codeActionUtil.createCodeAction({
-                    title: `Add void return type to function declaration`,
-                    diagnostics: [diagnostic],
-                    kind: vscode_languageserver_1.CodeActionKind.QuickFix,
-                    changes: [{
-                            type: 'insert',
-                            filePath: this.event.file.srcPath,
-                            position: func.rightParen.range.end,
-                            newText: ` ${asText !== null && asText !== void 0 ? asText : 'as'} ${voidText !== null && voidText !== void 0 ? voidText : 'void'}`
-                        }]
-                }));
-                //suggest converting to sub
-                this.event.codeActions.push(CodeActionUtil_1.codeActionUtil.createCodeAction({
-                    title: `Convert function to sub`,
-                    diagnostics: [diagnostic],
-                    kind: vscode_languageserver_1.CodeActionKind.QuickFix,
-                    changes: [{
-                            type: 'replace',
-                            filePath: this.event.file.srcPath,
-                            range: func.functionType.range,
-                            newText: subText !== null && subText !== void 0 ? subText : 'sub'
-                        }, {
-                            type: 'replace',
-                            filePath: this.event.file.srcPath,
-                            range: func.end.range,
-                            newText: endSubText !== null && endSubText !== void 0 ? endSubText : 'end sub'
-                        }]
-                }));
+            }, { walkMode: visitors_1.WalkMode.visitStatementsRecursive });
+            if (insertPosition) {
+                changes.push({
+                    type: 'insert',
+                    filePath: file.srcPath,
+                    position: insertPosition,
+                    newText: 'override '
+                });
             }
         }
+        this.emitOrFixAll(`Add missing 'override' keyword`, `Fix all: Add missing 'override' keywords`, changes, diagnostics[0]);
+    }
+    /**
+     * Adds code actions to remove the invalid `override` keyword from a constructor method.
+     */
+    suggestRemoveOverrideFromConstructorQuickFixes(diagnostics) {
+        const changes = diagnostics.map(d => ({
+            type: 'delete',
+            filePath: this.event.file.srcPath,
+            // delete "override " — the keyword token plus the trailing space before function/sub
+            range: util_1.util.createRange(d.range.start.line, d.range.start.character, d.range.end.line, d.range.end.character + 1)
+        }));
+        this.emitOrFixAll(`Remove 'override' from constructor`, `Fix all: Remove 'override' from constructors`, changes, diagnostics[0]);
+    }
+    // ---- change helpers ----
+    /**
+     * Builds a delete change that removes the return value from a `return <expr>` statement,
+     * leaving just a bare `return`.
+     */
+    getRemoveReturnValueChange(diagnostic) {
+        return {
+            type: 'delete',
+            filePath: this.event.file.srcPath,
+            range: util_1.util.createRange(diagnostic.range.start.line, diagnostic.range.start.character + 'return'.length, diagnostic.range.end.line, diagnostic.range.end.character)
+        };
+    }
+    /**
+     * Builds the change that deletes `) as <type>` from a function/sub declaration.
+     * Used for both `as void` on a function and any return type on a sub.
+     */
+    getRemoveFunctionReturnTypeChange(func) {
+        return {
+            type: 'delete',
+            filePath: this.event.file.srcPath,
+            // )| as <type>|
+            range: util_1.util.createRange(func.rightParen.range.start.line, func.rightParen.range.start.character + 1, func.returnTypeToken.range.end.line, func.returnTypeToken.range.end.character)
+        };
+    }
+    /**
+     * Emits a single code action when there is exactly one change, or a "fix all" composite
+     * action when there are multiple changes (same pattern as ESLint's "Fix all X problems").
+     * Does nothing when the changes array is empty.
+     */
+    emitOrFixAll(singleTitle, fixAllTitle, changes, diagnostic) {
+        if (changes.length === 0) {
+            return;
+        }
+        if (changes.length === 1) {
+            this.event.codeActions.push(CodeActionUtil_1.codeActionUtil.createCodeAction({
+                title: singleTitle,
+                diagnostics: [diagnostic],
+                kind: vscode_languageserver_1.CodeActionKind.QuickFix,
+                changes: changes
+            }));
+        }
+        else {
+            this.event.codeActions.push(CodeActionUtil_1.codeActionUtil.createCodeAction({
+                title: fixAllTitle,
+                kind: vscode_languageserver_1.CodeActionKind.QuickFix,
+                changes: changes
+            }));
+        }
     }
 }
 exports.CodeActionsProcessor = CodeActionsProcessor;