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) => ({
@@ -623,13 +624,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.spec.ts

@@ -52,6 +52,7 @@ describe('LanguageServer', () => {
         sendNotification: () => null,
         sendDiagnostics: () => null,
         onExecuteCommand: () => null,
+        onCodeAction: () => null,
         onDidOpenTextDocument: () => null,
         onDidChangeTextDocument: () => null,
         onDidCloseTextDocument: () => null,

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';
@@ -24,6 +24,7 @@ import { isBrsFile, isXmlFile, isClassMethodStatement, isXmlScope } from './astU
 import type { FunctionStatement, Statement } from './parser/Statement';
 import { ParseMode } from './parser';
 import { TokenKind } from './lexer';
+import { BscPlugin } from './bscPlugin/BscPlugin';
 const startOfSourcePkgPath = `source${path.sep}`;
 
 export interface SourceObj {
@@ -69,6 +70,10 @@ export class Program {
         this.logger = logger || new Logger(options.logLevel as LogLevel);
         this.plugins = plugins || new PluginInterface([], undefined);
 
+        //inject the bsc plugin as the first plugin in the stack.
+        //eslint-disable-next-line @typescript-eslint/dot-notation
+        this.plugins['plugins'].unshift(new BscPlugin());
+
         //normalize the root dir path
         this.options.rootDir = util.getRootDir(this.options);
 
@@ -733,6 +738,32 @@ 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('beforeProgramGetCodeActions', this, file, range, codeActions);
+
+        //get code actions from the file
+        file.getCodeActions(range, codeActions);
+
+        //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 this file is a member of
+                scope.getCodeActions(file, range, codeActions);
+            }
+        }
+
+        this.plugins.emit('afterProgramGetCodeActions', this, 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, codeActions: CodeAction[]) {
+        const diagnostics = this.diagnostics.filter(x => x.range?.start.line === range.start.line);
+        this.program.plugins.emit('onScopeGetCodeActions', this, file, range, diagnostics, codeActions);
+    }
+
     /**
      * Get the list of callables available in this scope (either declared in this scope or in a parent scope)
      */

src/XmlScope.spec.ts

@@ -3,20 +3,24 @@ import { Position, Range } from 'vscode-languageserver';
 import { DiagnosticMessages } from './DiagnosticMessages';
 import type { XmlFile } from './files/XmlFile';
 import { Program } from './Program';
-import { trim } from './testHelpers.spec';
+import { expectCodeActions, 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();
+
+            expectCodeActions(() => {
+                program.getComponentScope('child').getCodeActions(
+                    codebehind,
+                    // doSo|mething()
+                    util.createRange(2, 24, 2, 24),
+                    []
+                );
+            }, [{
+                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,4 +1,4 @@
-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 type { XmlFile } from './files/XmlFile';
@@ -153,6 +153,11 @@ export class XmlScope extends Scope {
         });
     }
 
+    public getCodeActions(file: BscFile, range: Range, codeActions: CodeAction[]) {
+        const relevantDiagnostics = this.diagnostics.filter(x => x.range?.start.line === range.start.line);
+        this.program.plugins.emit('onScopeGetCodeActions', this, file, range, relevantDiagnostics, codeActions);
+    }
+
     /**
      * Get the definition (where was this thing first defined) of the symbol under the position
      */

src/bscPlugin/BscPlugin.ts

@@ -0,0 +1,22 @@
+import type { CodeAction, Range } from 'vscode-languageserver';
+import { isXmlFile, isXmlScope } from '../astUtils/reflection';
+import type { BscFile, BsDiagnostic, CompilerPlugin } from '../interfaces';
+import type { Scope } from '../Scope';
+import { XmlFileCodeActionsProcessor } from './codeActions/XmlFileCodeActionsProcessor';
+import { XmlScopeCodeActionProcessor } from './codeActions/XmlScopeCodeActionsProcessor';
+
+export class BscPlugin implements CompilerPlugin {
+    public name = 'BscPlugin';
+
+    public onFileGetCodeActions(file: BscFile, range: Range, diagnostics: BsDiagnostic[], codeActions: CodeAction[]) {
+        if (isXmlFile(file)) {
+            new XmlFileCodeActionsProcessor(file, range, diagnostics, codeActions).process();
+        }
+    }
+
+    public onScopeGetCodeActions(scope: Scope, file: BscFile, range: Range, diagnostics: BsDiagnostic[], codeActions: CodeAction[]) {
+        if (isXmlScope(scope)) {
+            new XmlScopeCodeActionProcessor(scope, file, range, diagnostics, codeActions).process();
+        }
+    }
+}

src/bscPlugin/codeActions/XmlFileCodeActionsProcessor.ts

@@ -0,0 +1,44 @@
+import type { CodeAction, Range } from 'vscode-languageserver';
+import { CodeActionKind } from 'vscode-languageserver';
+import { DiagnosticCodeMap } from '../../DiagnosticMessages';
+import type { XmlFile } from '../../files/XmlFile';
+import type { BsDiagnostic } from '../../interfaces';
+import util from '../../util';
+
+export class XmlFileCodeActionsProcessor {
+    public constructor(
+        public file: XmlFile,
+        public range: Range,
+        public diagnostics: BsDiagnostic[],
+        public codeActions: CodeAction[]
+    ) {
+
+    }
+
+    public process() {
+        for (const diagnostic of this.diagnostics) {
+            if (diagnostic.code === DiagnosticCodeMap.xmlComponentMissingExtendsAttribute) {
+                this.addMissingExtends();
+            }
+        }
+    }
+
+    private addMissingExtends() {
+        //add the attribute at the end of the first attribute, or after the `<component` if no attributes
+        const pos = (this.file.parser.ast.component.attributes[0] ?? this.file.parser.ast.component.tag).range.end;
+        this.codeActions.push(
+            util.createCodeAction({
+                title: `Add default extends attribute`,
+                // diagnostics: [diagnostic],
+                isPreferred: true,
+                kind: CodeActionKind.QuickFix,
+                changes: [{
+                    type: 'insert',
+                    filePath: this.file.pathAbsolute,
+                    position: util.createPosition(pos.line, pos.character),
+                    newText: ' extends="Group"'
+                }]
+            })
+        );
+    }
+}

src/bscPlugin/codeActions/XmlScopeCodeActionsProcessor.ts

@@ -0,0 +1,58 @@
+import type { CodeAction, Range } from 'vscode-languageserver';
+import { isBrsFile } from '../../astUtils/reflection';
+import { DiagnosticCodeMap } from '../../DiagnosticMessages';
+import type { BscFile, BsDiagnostic } from '../../interfaces';
+import util from '../../util';
+import type { XmlScope } from '../../XmlScope';
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class XmlScopeCodeActionProcessor {
+    public constructor(
+        public scope: XmlScope,
+        public file: BscFile,
+        public range: Range,
+        public diagnostics: BsDiagnostic[],
+        public codeActions: CodeAction[]
+    ) {
+
+    }
+
+    public process() {
+        for (const diagnostic of this.diagnostics) {
+            if (diagnostic.code === DiagnosticCodeMap.callToUnknownFunction) {
+                this.importXmlScript(diagnostic);
+            }
+        }
+    }
+
+    public importXmlScript(diagnostic: BsDiagnostic) {
+        //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.scope.program.files) {
+            const file = this.scope.program.files[key];
+            if (isBrsFile(file)) {
+                //TODO handle namespace-relative function calls
+                const stmt = file.parser.references.functionStatementLookup.get(lowerFunctionName);
+                const slashOpenToken = this.scope.xmlFile.parser.ast.component?.ast.SLASH_OPEN?.[0];
+                if (stmt && slashOpenToken) {
+                    const pkgPath = util.getRokuPkgPath(file.pkgPath);
+                    this.codeActions.push(
+                        util.createCodeAction({
+                            title: `Import "${pkgPath}" into component "${this.scope.xmlFile.componentName.text ?? this.scope.name}"`,
+                            // diagnostics: [diagnostic]
+                            changes: [{
+                                filePath: this.scope.xmlFile.pathAbsolute,
+                                newText: `  <script type="text/brightscript" uri="${pkgPath}" />\n`,
+                                type: 'insert',
+                                position: util.createPosition(slashOpenToken.startLine - 1, slashOpenToken.startColumn - 1)
+                            }]
+                        })
+                    );
+                }
+            }
+        }
+    }
+
+}