Implement Code Actions

tomv564 · felixfbecker · commit 5b7b5b95dcf7 · 2017-05-14T00:17:08.000+02:00
diff --git a/src/lang-handler.ts b/src/lang-handler.ts
@@ -3,6 +3,8 @@ import { FORMAT_TEXT_MAP, Span } from 'opentracing';
 import { inspect } from 'util';
 import { isReponseMessage, Message, NotificationMessage, RequestMessage, ResponseMessage } from 'vscode-jsonrpc/lib/messages';
 import {
+	ApplyWorkspaceEditParams,
+	ApplyWorkspaceEditResponse,
 	LogMessageParams,
 	PublishDiagnosticsParams,
 	TextDocumentIdentifier,
@@ -56,6 +58,13 @@ export interface LanguageClient {
 	 * @param params The diagnostics to send to the client
 	 */
 	textDocumentPublishDiagnostics(params: PublishDiagnosticsParams): void;
+
+	/**
+	 * Requests a set of text changes to be applied to documents in the workspace
+	 * Can occur as as a result of rename or executeCommand (code action).
+	 * @param params The edits to apply to the workspace
+	 */
+	workspaceApplyEdit(params: ApplyWorkspaceEditParams): Promise<ApplyWorkspaceEditResponse>;
 }
 
 /**
@@ -186,4 +195,13 @@ export class RemoteLanguageClient {
 	textDocumentPublishDiagnostics(params: PublishDiagnosticsParams): void {
 		this.notify('textDocument/publishDiagnostics', params);
 	}
+
+	/**
+	 * Requests a set of text changes to be applied to documents in the workspace
+	 * Can occur as as a result of rename or executeCommand (code action).
+	 * @param params The edits to apply to the workspace
+	 */
+	workspaceApplyEdit(params: ApplyWorkspaceEditParams): Promise<ApplyWorkspaceEditResponse> {
+		return this.request('workspace/applyEdit', params).toPromise();
+	}
 }
diff --git a/src/project-manager.ts b/src/project-manager.ts
@@ -622,6 +622,12 @@ export class InMemoryLanguageServiceHost implements ts.LanguageServiceHost {
 		return '' + this.projectVersion;
 	}
 
+	getNewLine(): string {
+		// Although this is optional, language service was sending edits with carriage returns if not specified.
+		// TODO: combine with the FormatOptions defaults.
+		return '\n';
+	}
+
 	/**
 	 * Incrementing current project version, telling TS compiler to invalidate internal data
 	 */
diff --git a/src/test/typescript-service-helpers.ts b/src/test/typescript-service-helpers.ts
@@ -1,8 +1,8 @@
 import * as chai from 'chai';
 import * as sinon from 'sinon';
 import * as ts from 'typescript';
-import { CompletionItemKind, CompletionList, TextDocumentIdentifier, TextDocumentItem } from 'vscode-languageserver';
-import { Hover, Location, SignatureHelp, SymbolInformation, SymbolKind, WorkspaceEdit } from 'vscode-languageserver-types';
+import { CompletionItemKind, CompletionList, DiagnosticSeverity, TextDocumentIdentifier, TextDocumentItem, WorkspaceEdit } from 'vscode-languageserver';
+import { Hover, Location, SignatureHelp, SymbolInformation, SymbolKind } from 'vscode-languageserver-types';
 import { LanguageClient, RemoteLanguageClient } from '../lang-handler';
 import { TextDocumentContentParams, WorkspaceFilesParams } from '../request-type';
 import { SymbolLocationInformation } from '../request-type';
@@ -16,7 +16,7 @@ const assert = chai.assert;
 /**
  * Enforcing strict mode to make tests pass on Windows
  */
-import { setStrict } from '../util';
+import { setStrict, uri2path } from '../util';
 setStrict(true);
 
 export interface TestContext {
@@ -53,6 +53,7 @@ export const initializeTypeScriptService = (createService: TypeScriptServiceFact
 		return Array.from(files.keys()).map(uri => ({ uri }));
 	});
 	this.client.xcacheGet.returns(null);
+	this.client.workspaceApplyEdit.returns(Promise.resolve({applied: true}));
 	this.service = createService(this.client);
 
 	await this.service.initialize({
@@ -2310,6 +2311,137 @@ export function describeTypeScriptService(createService: TypeScriptServiceFactor
 		});
 	});
 
+	describe('textDocumentCodeAction()', function (this: TestContext) {
+		beforeEach(initializeTypeScriptService(createService, rootUri, new Map([
+			[rootUri + 'package.json', '{ "name": "mypkg" }'],
+			[rootUri + 'a.ts', [
+				'class A {',
+				'  constructor() {',
+				'    missingThis = 33;',
+				'  }',
+				'}',
+				'const a = new A();'
+			].join('\n')]
+		])) as any);
+
+		afterEach(shutdownService as any);
+
+		it('suggests a missing this', async function (this: TestContext) {
+			await this.service.textDocumentDidOpen({
+				textDocument: {
+					uri: rootUri + 'a.ts',
+					languageId: 'typescript',
+					text: [
+						'class A {',
+						' missingThis: number;',
+						'  constructor() {',
+						'    missingThis = 33;',
+						'  }',
+						'}',
+						'const a = new A();'
+					].join('\n'),
+					version: 1
+				}
+			});
+
+			const firstDiagnostic = {
+				range: {
+					start: { line: 3, character: 4 },
+					end: { line: 3, character: 15 }
+				},
+				message: 'Cannot find name \'missingThis\'. Did you mean the instance member \'this.missingThis\'?',
+				severity: DiagnosticSeverity.Error,
+				code: 2663,
+				source: 'ts'
+			};
+			const actions = await this.service.textDocumentCodeAction({
+				textDocument: {
+					uri: rootUri + 'a.ts'
+				},
+				range: firstDiagnostic.range,
+				context: {
+					diagnostics: [firstDiagnostic]
+				}
+			}).toArray().map(patches => apply(null, patches)).toPromise();
+			assert.lengthOf(actions, 1);
+			assert.sameDeepMembers(actions, [
+				{
+					title: 'Add \'this.\' to unresolved variable.',
+					command: 'codeFix',
+					arguments: [
+						{
+							fileName: uri2path(rootUri + 'a.ts'),
+							textChanges: [
+								{
+									span: { start: 50, length: 15 },
+									newText: '\t  this.missingThis'
+								}
+							]
+						}
+					]
+				}
+			]);
+
+		} as any);
+	} as any);
+
+	describe('workspaceExecuteCommand()', function (this: TestContext) {
+		beforeEach(initializeTypeScriptService(createService, rootUri, new Map([
+			[rootUri + 'package.json', '{ "name": "mypkg" }'],
+			[rootUri + 'a.ts', [
+				'class A {',
+				'  constructor() {',
+				'    missingThis = 33;',
+				'  }',
+				'}',
+				'const a = new A();'
+			].join('\n')]
+		])) as any);
+
+		afterEach(shutdownService as any);
+
+		it('should return edits for a codeFix command', async function (this: TestContext) {
+			const result = await this.service.workspaceExecuteCommand({
+				command: 'codeFix',
+				arguments: [
+					{
+						fileName: uri2path(rootUri + 'a.ts'),
+						textChanges: [
+							{
+								span: { start: 50, length: 15 },
+								newText: '\t  this.missingThis'
+							}
+						]
+					}
+				]
+			}).toArray().map(patches => apply(null, patches)).toPromise();
+
+			assert.isUndefined(result);
+
+			sinon.assert.called(this.client.workspaceApplyEdit);
+			const workspaceEdit = this.client.workspaceApplyEdit.lastCall.args[0];
+			assert.deepEqual(workspaceEdit, {
+				edit: {
+					changes: {
+						[rootUri + 'a.ts']: [{
+							newText: '\t  this.missingThis',
+							range: {
+								end: {
+									character: 9,
+									line: 5
+								},
+								start: {
+									character: 0,
+									line: 3
+								}
+							}
+						}]
+					}
+				}
+			});
+		} as any);
+	} as any);
+
 	describe('Special file names', function (this: TestContext) {
 
 		beforeEach(initializeTypeScriptService(createService, rootUri, new Map([
diff --git a/src/typescript-service.ts b/src/typescript-service.ts
@@ -6,6 +6,9 @@ import { Span } from 'opentracing';
 import * as path from 'path';
 import * as ts from 'typescript';
 import {
+	ApplyWorkspaceEditParams,
+	CodeActionParams,
+	Command,
 	CompletionItem,
 	CompletionItemKind,
 	CompletionList,
@@ -14,10 +17,12 @@ import {
 	DidOpenTextDocumentParams,
 	DidSaveTextDocumentParams,
 	DocumentSymbolParams,
+	ExecuteCommandParams,
 	Hover,
 	Location,
 	MarkedString,
 	ParameterInformation,
+	Range as LSRange,
 	ReferenceParams,
 	RenameParams,
 	SignatureHelp,
@@ -69,6 +74,29 @@ export interface TypeScriptServiceOptions {
 
 export type TypeScriptServiceFactory = (client: LanguageClient, options?: TypeScriptServiceOptions) => TypeScriptService;
 
+// defaults from https://github.com/Microsoft/vscode/blob/master/tsfmt.json
+// A formattingProvider could be implemented to read editorconfig etc.
+const formatSettings: ts.FormatCodeSettings = {
+	indentSize: 4,
+	tabSize: 4,
+	newLineCharacter: '\n',
+	convertTabsToSpaces: false,
+	indentStyle: ts.IndentStyle.Smart,
+	insertSpaceAfterCommaDelimiter: true,
+	insertSpaceAfterSemicolonInForStatements: true,
+	insertSpaceBeforeAndAfterBinaryOperators: true,
+	insertSpaceAfterKeywordsInControlFlowStatements: true,
+	insertSpaceAfterFunctionKeywordForAnonymousFunctions: false,
+	insertSpaceBeforeFunctionParenthesis: false,
+	insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
+	insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,
+	insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
+	insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
+	insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false,
+	placeOpenBraceOnNewLineForFunctions: false,
+	placeOpenBraceOnNewLineForControlBlocks: false
+};
+
 /**
  * Handles incoming requests and return responses. There is a one-to-one-to-one
  * correspondence between TCP connection, TypeScriptService instance, and
@@ -210,6 +238,11 @@ export class TypeScriptService {
 					resolveProvider: false,
 					triggerCharacters: ['.']
 				},
+				codeActionProvider: true,
+				renameProvider: true,
+				executeCommandProvider: {
+					commands: []
+				},
 				xpackagesProvider: true
 			}
 		};
@@ -1008,6 +1041,94 @@ export class TypeScriptService {
 			.map(signatureHelp => ({ op: 'add', path: '', value: signatureHelp }) as AddPatch);
 	}
 
+	textDocumentCodeAction(params: CodeActionParams, span = new Span()): Observable<OpPatch> {
+		return this.projectManager.ensureReferencedFiles(params.textDocument.uri, undefined, undefined, span)
+			.toArray()
+			.map((): Command[] => {
+				const filePath = uri2path(params.textDocument.uri);
+				const configuration = this.projectManager.getConfiguration(filePath);
+				configuration.ensureBasicFiles(span);
+
+				const sourceFile = this._getSourceFile(configuration, filePath, span);
+				if (!sourceFile) {
+					throw new Error(`expected source file ${filePath} to exist in configuration`);
+				}
+
+				const start: number = ts.getPositionOfLineAndCharacter(sourceFile, params.range.start.line, params.range.start.character);
+				const end: number = ts.getPositionOfLineAndCharacter(sourceFile, params.range.end.line, params.range.end.character);
+				const errorCodes: number[] = [];
+				for (const diagnostic of params.context.diagnostics) {
+					if (typeof(diagnostic.code) === 'number') {
+						errorCodes.push(diagnostic.code);
+					}
+				}
+
+				const fixes: ts.CodeAction[] = configuration.getService().getCodeFixesAtPosition(filePath, start, end, errorCodes, formatSettings);
+				if (!fixes) {
+					return [];
+				}
+
+				return fixes.map(fix => Command.create(fix.description, 'codeFix', ...fix.changes));
+			})
+			.map(command => ({ op: 'add', path: '', value: command }) as AddPatch);
+	}
+
+	workspaceExecuteCommand(params: ExecuteCommandParams, span = new Span()): Observable<OpPatch> {
+		switch (params.command) {
+			case 'codeFix':
+				if (params.arguments && params.arguments.length === 1) {
+					return Observable
+						.fromPromise(this.executeCodeFixCommand(params.arguments, span))
+						.map(result => ({op: 'add', path: '', value: result }) as OpPatch);
+				} else {
+					throw new Error(`Command ${params.command} requires arguments`);
+				}
+			default:
+				throw new Error(`Unknown command ${params.command}`);
+		}
+	}
+
+	convertTextChange(textChange: ts.TextChange, sourceFile: ts.SourceFile): TextEdit {
+		const start = ts.getLineAndCharacterOfPosition(sourceFile, textChange.span.start);
+		if (textChange.span.length) {
+			const end = ts.getLineAndCharacterOfPosition(sourceFile, textChange.span.start + textChange.span.length);
+			const range = LSRange.create(start, end);
+			if (textChange.newText) {
+				return TextEdit.replace(range, textChange.newText);
+			} else {
+				return TextEdit.del(range);
+			}
+		} else {
+			return TextEdit.insert(start, textChange.newText);
+		}
+	}
+
+	async executeCodeFixCommand(fileTextChanges: ts.FileTextChanges[], span = new Span()): Promise<void> {
+		if (fileTextChanges.length === 0) {
+			throw new Error('No changes supplied for code fix command');
+		}
+
+		await this.projectManager.ensureOwnFiles(span);
+		const configuration = this.projectManager.getConfiguration(fileTextChanges[0].fileName);
+		configuration.ensureBasicFiles(span);
+		const fileToEdits: {[uri: string]: TextEdit[]} = {};
+		for (const change of fileTextChanges) {
+			const sourceFile = this._getSourceFile(configuration, change.fileName, span);
+			if (!sourceFile) {
+				throw new Error(`expected source file ${change.fileName} to exist in configuration`);
+			}
+			fileToEdits[path2uri(this.root, change.fileName)] =
+				change.textChanges.map(tc => this.convertTextChange(tc, sourceFile));
+		}
+
+		const params: ApplyWorkspaceEditParams = {
+			edit:  {
+				changes: fileToEdits
+			}
+		};
+		return this.client.workspaceApplyEdit(params).then(r => undefined);
+	}
+
 	/**
 	 * The rename request is sent from the client to the server to perform a workspace-wide rename of a symbol.
 	 *
