Add codeAction support

src/DiagnosticMessages.ts

@@ -17,6 +17,7 @@ export let DiagnosticMessages = {
     callToUnknownFunction: (name: string, scopeName: string) => ({
         message: `Cannot find function with name '${name}' when this file is included in scope '${scopeName}'`,
         code: 1001,
+        functionName: name,
         severity: DiagnosticSeverity.Error
     }),
     mismatchArgumentCount: (expectedCount: number | string, actualCount: number) => ({
@@ -608,13 +609,13 @@ export let DiagnosticMessages = {
     })
 };
 
-let allCodes = [] as number[];
+export const DiagnosticCodeMap = {} as Record<keyof (typeof DiagnosticMessages), number>;
+export let diagnosticCodes = [] as number[];
 for (let key in DiagnosticMessages) {
-    allCodes.push(DiagnosticMessages[key]().code);
+    diagnosticCodes.push(DiagnosticMessages[key]().code);
+    DiagnosticCodeMap[key] = DiagnosticMessages[key]().code;
 }
 
-export let diagnosticCodes = allCodes;
-
 export interface DiagnosticInfo {
     message: string;
     code: number;

src/LanguageServer.ts

@@ -17,15 +17,17 @@ import type {
     DocumentSymbolParams,
     ReferenceParams,
     SignatureHelp,
-    SignatureHelpParams
+    SignatureHelpParams,
+    CodeActionParams
 } from 'vscode-languageserver';
 import {
     createConnection,
     DidChangeConfigurationNotification,
     FileChangeType,
     ProposedFeatures,
     TextDocuments,
-    TextDocumentSyncKind
+    TextDocumentSyncKind,
+    CodeActionKind
 } from 'vscode-languageserver';
 import { URI } from 'vscode-uri';
 import { TextDocument } from 'vscode-languageserver-textdocument';
@@ -143,6 +145,8 @@ export class LanguageServer {
 
         this.connection.onReferences(this.onReferences.bind(this));
 
+        this.connection.onCodeAction(this.onCodeAction.bind(this));
+
         /*
         this.connection.onDidOpenTextDocument((params) => {
              // A text document got opened in VSCode.
@@ -196,6 +200,9 @@ export class LanguageServer {
                 documentSymbolProvider: true,
                 workspaceSymbolProvider: true,
                 referencesProvider: true,
+                codeActionProvider: {
+                    codeActionKinds: [CodeActionKind.Refactor]
+                },
                 signatureHelpProvider: {
                     triggerCharacters: ['(', ',']
                 },
@@ -543,6 +550,22 @@ export class LanguageServer {
         return item;
     }
 
+    private async onCodeAction(params: CodeActionParams) {
+        //ensure programs are initialized
+        await this.waitAllProgramFirstRuns();
+
+        let filePath = util.uriToPath(params.textDocument.uri);
+
+        //wait until the file has settled
+        await this.keyedThrottler.onIdleOnce(filePath, true);
+
+        let codeActions = this
+            .getWorkspaces()
+            .flatMap(workspace => workspace.builder.program.getCodeActions(filePath, params.range));
+
+        return codeActions;
+    }
+
     /**
      * Reload all specified workspaces, or all workspaces if no workspaces are specified
      */

src/Program.ts

@@ -1,7 +1,7 @@
 import * as assert from 'assert';
 import * as fsExtra from 'fs-extra';
 import * as path from 'path';
-import type { CompletionItem, Position, SignatureInformation } from 'vscode-languageserver';
+import type { CodeAction, CompletionItem, Position, Range, SignatureInformation } from 'vscode-languageserver';
 import { Location, CompletionItemKind } from 'vscode-languageserver';
 import type { BsConfig } from './BsConfig';
 import { Scope } from './Scope';
@@ -733,6 +733,36 @@ export class Program {
         return Promise.resolve(file.getHover(position));
     }
 
+    /**
+     * Compute code actions for the given file and range
+     */
+    public getCodeActions(pathAbsolute: string, range: Range) {
+        const codeActions = [] as CodeAction[];
+        const file = this.getFile(pathAbsolute);
+
+        this.plugins.emit('beforeGetCodeActions', file, range, codeActions);
+
+        //get code actions from the file
+        codeActions.push(
+            ...file.getCodeActions(range)
+        );
+
+        //get code actions from every scope this file is a member of
+        for (let key in this.scopes) {
+            let scope = this.scopes[key];
+
+            if (scope.hasFile(file)) {
+                //get code actions from each scope
+                codeActions.push(
+                    ...scope.getCodeActions(file, range)
+                );
+            }
+        }
+
+        this.plugins.emit('afterGetCodeActions', file, range, codeActions);
+        return codeActions;
+    }
+
     public getSignatureHelp(filepath: string, position: Position): SignatureInfoObj[] {
         let file: BrsFile = this.getFile(filepath);
         if (!file || !isBrsFile(file)) {

src/Scope.ts

@@ -1,4 +1,4 @@
-import type { CompletionItem, Position, Range } from 'vscode-languageserver';
+import type { CodeAction, CompletionItem, Position, Range } from 'vscode-languageserver';
 import { CompletionItemKind, Location } from 'vscode-languageserver';
 import chalk from 'chalk';
 import type { DiagnosticInfo } from './DiagnosticMessages';
@@ -243,6 +243,11 @@ export class Scope {
         this.diagnostics.push(...diagnostics);
     }
 
+    public getCodeActions(file: BscFile, range: Range) {
+        const result = [] as CodeAction[];
+        return result;
+    }
+
     /**
      * Get the list of callables available in this scope (either declared in this scope or in a parent scope)
      */

src/XmlScope.spec.ts

@@ -6,17 +6,21 @@ import { Program } from './Program';
 import { trim } from './testHelpers.spec';
 import { standardizePath as s, util } from './util';
 let rootDir = s`${process.cwd()}/rootDir`;
+import { createSandbox } from 'sinon';
+const sinon = createSandbox();
 
 describe('XmlScope', () => {
     let program: Program;
     beforeEach(() => {
         program = new Program({
             rootDir: rootDir
         });
+        sinon.restore();
     });
 
     afterEach(() => {
         program.dispose();
+        sinon.restore();
     });
 
     describe('constructor', () => {
@@ -187,4 +191,42 @@ describe('XmlScope', () => {
             });
         });
     });
+
+    describe('getCodeActions', () => {
+        it('sugests import script tag for function from not-imported file', () => {
+            program.addOrReplaceFile('components/comp1.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="child">
+                    <script uri="comp1.brs" />
+                </component>
+            `);
+            const codebehind = program.addOrReplaceFile('components/comp1.brs', `
+                sub init()
+                    doSomething()
+                end sub
+            `);
+            program.addOrReplaceFile('source/common.brs', `
+                sub doSomething()
+                end sub
+            `);
+            program.validate();
+            const stub = sinon.stub(util, 'createCodeAction');
+            const actions = program.getComponentScope('child').getCodeActions(
+                codebehind,
+                // doSo|mething()
+                util.createRange(2, 24, 2, 24)
+            );
+            expect(actions).to.be.lengthOf(1);
+
+            expect(stub.getCalls()[0].args[0]).to.eql({
+                title: `Import "pkg:/source/common.brs" into component "child"`,
+                changes: [{
+                    filePath: s`${rootDir}/components/comp1.xml`,
+                    newText: '  <script type="text/brightscript" uri="pkg:/source/common.brs" />\n',
+                    type: 'insert',
+                    position: util.createPosition(3, 0)
+                }]
+            });
+        });
+    });
 });

src/XmlScope.ts

@@ -1,11 +1,11 @@
-import type { Location, Position } from 'vscode-languageserver';
+import type { CodeAction, Location, Position, Range } from 'vscode-languageserver';
 import { Scope } from './Scope';
-import { DiagnosticMessages } from './DiagnosticMessages';
+import { DiagnosticMessages, DiagnosticCodeMap } from './DiagnosticMessages';
 import type { XmlFile } from './files/XmlFile';
 import type { BscFile, CallableContainerMap, FileReference } from './interfaces';
 import type { Program } from './Program';
 import util from './util';
-import { isXmlFile } from './astUtils/reflection';
+import { isBrsFile, isXmlFile } from './astUtils/reflection';
 import { SGFieldTypes } from './parser/SGTypes';
 import type { SGTag } from './parser/SGTypes';
 
@@ -153,6 +153,46 @@ export class XmlScope extends Scope {
         });
     }
 
+    public getCodeActions(file: BscFile, range: Range) {
+        const result = [] as CodeAction[];
+        for (const diagnostic of this.diagnostics) {
+            //skip diagnostics that don't occur on this line
+            if (diagnostic.range?.start.line !== range.start.line) {
+                continue;
+            }
+            if (diagnostic.code === DiagnosticCodeMap.callToUnknownFunction) {
+                //functionName is stored on this specific diagnostic
+                const lowerFunctionName = (diagnostic as any).functionName.toLowerCase();
+
+                //find every file with this function defined
+                for (const key in this.program.files) {
+                    const file = this.program.files[key];
+                    if (isBrsFile(file)) {
+                        //TODO handle namespace-relative function calls
+                        const stmt = file.parser.references.functionStatementLookup.get(lowerFunctionName);
+                        const slashOpenToken = this.xmlFile.parser.ast.component?.ast.SLASH_OPEN?.[0];
+                        if (stmt && slashOpenToken) {
+                            const pkgPath = util.getRokuPkgPath(file.pkgPath);
+                            result.push(
+                                util.createCodeAction({
+                                    title: `Import "${pkgPath}" into component "${this.xmlFile.componentName.text ?? this.name}"`,
+                                    // diagnostics: [diagnostic]
+                                    changes: [{
+                                        filePath: this.xmlFile.pathAbsolute,
+                                        newText: `  <script type="text/brightscript" uri="${pkgPath}" />\n`,
+                                        type: 'insert',
+                                        position: util.createPosition(slashOpenToken.startLine - 1, slashOpenToken.startColumn - 1)
+                                    }]
+                                })
+                            );
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
     /**
      * Get the definition (where was this thing first defined) of the symbol under the position
      */

src/files/BrsFile.ts

@@ -1,6 +1,6 @@
 import type { CodeWithSourceMap } from 'source-map';
 import { SourceNode } from 'source-map';
-import type { CompletionItem, Hover, Range, Position } from 'vscode-languageserver';
+import type { CompletionItem, Hover, Range, Position, CodeAction } from 'vscode-languageserver';
 import { CompletionItemKind, SymbolKind, Location, SignatureInformation, ParameterInformation, DocumentSymbol, SymbolInformation } from 'vscode-languageserver';
 import chalk from 'chalk';
 import * as path from 'path';
@@ -1466,6 +1466,10 @@ export class BrsFile {
         }
     }
 
+    public getCodeActions(range: Range): CodeAction[] {
+        return [];
+    }
+
     public getSignatureHelpForNamespaceMethods(callableName: string, dottedGetText: string, scope: Scope): { key: string; signature: SignatureInformation }[] {
         if (!dottedGetText) {
             return [];

src/files/XmlFile.ts

@@ -1,7 +1,8 @@
 import * as path from 'path';
 import type { CodeWithSourceMap } from 'source-map';
 import { SourceNode } from 'source-map';
-import type { CompletionItem, Hover, Location, Position, Range } from 'vscode-languageserver';
+import type { CodeAction, CompletionItem, Hover, Location, Position, Range } from 'vscode-languageserver';
+import { CodeActionKind } from 'vscode-languageserver';
 import { DiagnosticMessages } from '../DiagnosticMessages';
 import type { FunctionScope } from '../FunctionScope';
 import type { Callable, BsDiagnostic, File, FileReference, FunctionCall } from '../interfaces';
@@ -369,6 +370,38 @@ export class XmlFile {
         return null;
     }
 
+    public getCodeActions(range: Range) {
+        const result = [] as CodeAction[];
+
+        for (const diagnostic of this.diagnostics) {
+            //skip diagnostics that don't occur on this line
+            if (diagnostic.range?.start.line !== range.start.line) {
+                continue;
+            }
+            if (diagnostic.code === DiagnosticMessages.xmlComponentMissingExtendsAttribute().code) {
+                //add the attribute at the end of the first attribute, or after the `<component` if no attributes
+                const pos = (this.parser.ast.component.attributes[0] ?? this.parser.ast.component.tag).range.end;
+                //add this extends attribute right after the closing `>` token
+                range.end.character -= 1;
+                result.push(
+                    util.createCodeAction({
+                        title: `Add default extends attribute`,
+                        // diagnostics: [diagnostic],
+                        isPreferred: true,
+                        kind: CodeActionKind.QuickFix,
+                        changes: [{
+                            type: 'insert',
+                            filePath: this.pathAbsolute,
+                            position: util.createPosition(pos.line, pos.character),
+                            newText: ' extends="Group"'
+                        }]
+                    })
+                );
+            }
+        }
+        return result;
+    }
+
     public getReferences(position: Position): Promise<Location[]> { //eslint-disable-line
         //TODO implement
         return null;

src/interfaces.ts

@@ -1,4 +1,4 @@
-import type { Range, Diagnostic } from 'vscode-languageserver';
+import type { Range, Diagnostic, CodeAction, Position, CodeActionKind } from 'vscode-languageserver';
 import type { Scope } from './Scope';
 import type { BrsFile } from './files/BrsFile';
 import type { XmlFile } from './files/XmlFile';
@@ -187,6 +187,8 @@ export interface CompilerPlugin {
     afterFileTranspile?: (entry: TranspileObj) => void;
     beforeFileDispose?: (file: BscFile) => void;
     afterFileDispose?: (file: BscFile) => void;
+    beforeGetCodeActions?: (file: BscFile, range: Range, codeActions: CodeAction[]) => void;
+    afterGetCodeActions?: (file: BscFile, range: Range, codeActions: CodeAction[]) => void;
 }
 
 export interface TypedefProvider {
@@ -202,3 +204,25 @@ export interface ExpressionInfo {
     varExpressions: Expression[];
     uniqueVarNames: string[];
 }
+
+export interface CodeActionShorthand {
+    title: string;
+    diagnostics?: Diagnostic[];
+    kind?: CodeActionKind;
+    isPreferred?: boolean;
+    changes: Array<InsertChange | ReplaceChange>;
+}
+
+export interface InsertChange {
+    filePath: string;
+    newText: string;
+    type: 'insert';
+    position: Position;
+}
+
+export interface ReplaceChange {
+    filePath: string;
+    newText: string;
+    type: 'replace';
+    range: Range;
+}