pFad - Phonifier reborn

diff --git a/src/TODO.todo b/src/TODO.todo new file mode 100644 index 00000000..e625aa45 --- /dev/null +++ b/src/TODO.todo @@ -0,0 +1,25 @@ +TODO + ☐ NEW!!!! Test how long it takes to provide completions before and after splitting into two server. Test in lsp-server.ts and compare with VSCode + ☐ this.documents should live inside tspClient? + ☐ create TypeScriptServiceConfiguration that reads settings from `initializationSettings.tsServer`. Replace `TspClientOptions` passed to `TspClient`. + ✔ look into what Tracer does and whether it's worth implementing @done (22-09-12 23:48) + ☐ Events: + ☐ ConfigFileDiag + ☐ ProjectLanguageServiceState + ☐ ProjectsUpdatedInBackground + ☐ BeginInstallTypes / endInstallTypes + ☐ TypesInstallerInitializationFailed + ☐ ServerState + ☐ Request config.cancelOnResourceChange + +VSCode implementation +- new ElectronServiceProcessFactory() +- lazy_new TypeScriptServiceClientHost() +- receives ElectronServiceProcessFactory +- creates new TypeScriptServiceClient() +- creates new TypeScriptVersionManager() +- starts the server: ensureServiceStarted() -> startService() -> typescriptServerSpawner.spawn() + +- ProcessBasedTsServer <=> TspClient +- ProcessBasedTsServer implements ITypeScriptServer +- ElectronServiceProcessFactory implements TsServerProcessFactory diff --git a/src/commands/commandManager.ts b/src/commands/commandManager.ts new file mode 100644 index 00000000..dab7643b --- /dev/null +++ b/src/commands/commandManager.ts @@ -0,0 +1,39 @@ +// sync: file[extensions/typescript-language-features/src/commands/commandManager.ts] sha[f76ac124233270762d11ec3afaaaafcba53b3bbf] +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +/* + * Copyright (C) 2024 TypeFox and others. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. + * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 + */ + +export interface Command { + readonly id: string; + + execute(...args: any[]): void | any; +} + +export class CommandManager { + private readonly commands = new Map(); + + public dispose(): void { + this.commands.clear(); + } + + public register(command: T): void { + const entry = this.commands.get(command.id); + if (!entry) { + this.commands.set(command.id, command); + } + } + + public handle(command: Command, ...args: any[]): void { + const entry = this.commands.get(command.id); + if (entry) { + entry.execute(...args); + } + } +} diff --git a/src/diagnostic-queue.ts b/src/diagnostic-queue.ts index c29d9722..1d0bfc66 100644 --- a/src/diagnostic-queue.ts +++ b/src/diagnostic-queue.ts @@ -72,7 +72,7 @@ class FileDiagnostics { } } -export class DiagnosticEventQueue { +export class DiagnosticsManager { protected readonly diagnostics = new Map(); private ignoredDiagnosticCodes: Set = new Set(); diff --git a/src/features/codeActions/codeActionManager.ts b/src/features/codeActions/codeActionManager.ts new file mode 100644 index 00000000..adbfaa6b --- /dev/null +++ b/src/features/codeActions/codeActionManager.ts @@ -0,0 +1,129 @@ +/* + * Copyright (C) 2024 TypeFox and others. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. + * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 + */ + +import * as lsp from 'vscode-languageserver'; +import { type ITypeScriptServiceClient } from '../../typescriptService.js'; +import type FileConfigurationManager from '../fileConfigurationManager.js'; +import { CommandManager } from '../../commands/commandManager.js'; +import { LspDocument } from '../../document.js'; +import { type CodeActionProvider, type TsCodeAction } from './codeActionProvider.js'; +import { TypeScriptAutoFixProvider } from './fixAll.js'; +import { TypeScriptQuickFixProvider } from './quickFix.js'; +import { nulToken } from '../../utils/cancellation.js'; +import { type SupportedFeatures } from '../../ts-protocol.js'; +import { DiagnosticsManager } from '../../diagnostic-queue.js'; + +interface ResolveData { + globalId?: number; + providerId?: number; +} + +/** + * Requests code actions from registered providers and ensures that returned code actions have global IDs assigned + * and are cached for the purpose of codeAction/resolve request. + */ +export class CodeActionManager { + private providerMap = new Map; + private nextProviderId = 1; + // global id => TsCodeAction map need for the resolve request + // TODO: make it bound + private tsCodeActionsMap = new Map; + private nextGlobalCodeActionId = 1; + + constructor( + client: ITypeScriptServiceClient, + fileConfigurationManager: FileConfigurationManager, + commandManager: CommandManager, + diagnosticsManager: DiagnosticsManager, + private readonly features: SupportedFeatures, + ) { + this.addProvider(new TypeScriptAutoFixProvider(client, fileConfigurationManager, diagnosticsManager)); + this.addProvider(new TypeScriptQuickFixProvider(client, fileConfigurationManager, commandManager, diagnosticsManager, features)); + } + + public get kinds(): lsp.CodeActionKind[] { + const allKinds: lsp.CodeActionKind[] = []; + + for (const [_, provider] of this.providerMap) { + allKinds.push(...provider.getMetadata().providedCodeActionKinds || []); + } + + return allKinds; + } + + public async provideCodeActions(document: LspDocument, range: lsp.Range, context: lsp.CodeActionContext, token?: lsp.CancellationToken): Promise<(lsp.Command | lsp.CodeAction)[]> { + const allCodeActions: (lsp.Command | lsp.CodeAction)[] = []; + + for (const [providerId, provider] of this.providerMap.entries()) { + const codeActions = await provider.provideCodeActions(document, range, context, token || nulToken); + if (!codeActions) { + continue; + } + + for (const action of codeActions) { + if (lsp.Command.is(action)) { + allCodeActions.push(action); + continue; + } + + const lspCodeAction = action.toLspCodeAction(); + + if (provider.isCodeActionResolvable(action)) { + const globalId = this.nextGlobalCodeActionId++; + this.tsCodeActionsMap.set(globalId, action); + lspCodeAction.data = { + globalId, + providerId, + } satisfies ResolveData; + } + + allCodeActions.push(lspCodeAction); + } + } + + return allCodeActions; + } + + public async resolveCodeAction(codeAction: lsp.CodeAction, token?: lsp.CancellationToken): Promise { + if (!this.features.codeActionResolveSupport) { + return codeAction; + } + + const { globalId, providerId } = codeAction.data as ResolveData || {}; + if (globalId === undefined || providerId === undefined) { + return codeAction; + } + + const provider = this.providerMap.get(providerId); + if (!provider || !provider.resolveCodeAction) { + return codeAction; + } + + const tsCodeAction = this.tsCodeActionsMap.get(globalId); + if (!tsCodeAction || !providerId) { + return codeAction; + } + + const resolvedTsCodeAction = await provider.resolveCodeAction(tsCodeAction, token || nulToken); + if (!resolvedTsCodeAction) { + return codeAction; + } + + const lspCodeAction = resolvedTsCodeAction.toLspCodeAction(); + for (const property of this.features.codeActionResolveSupport.properties as Array) { + if (property in lspCodeAction) { + codeAction[property] = lspCodeAction[property]; + } + } + + return codeAction; + } + + private addProvider(provider: CodeActionProvider): void { + this.providerMap.set(this.nextProviderId++, provider); + } +} diff --git a/src/features/codeActions/codeActionProvider.ts b/src/features/codeActions/codeActionProvider.ts new file mode 100644 index 00000000..5bfc46f3 --- /dev/null +++ b/src/features/codeActions/codeActionProvider.ts @@ -0,0 +1,99 @@ +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +/* + * Copyright (C) 2022 TypeFox and others. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. + * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 + */ + +import * as lsp from 'vscode-languageserver'; +import type { LspDocument } from '../../document.js'; + +export class TsCodeAction implements lsp.CodeAction { + public command: lsp.CodeAction['command']; + public diagnostics: lsp.CodeAction['diagnostics']; + public disabled: lsp.CodeAction['disabled']; + public edit: lsp.CodeAction['edit']; + public isPreferred: lsp.CodeAction['isPreferred']; + + constructor( + public readonly title: string, + public readonly kind: lsp.CodeActionKind, + ) { + } + + toLspCodeAction(): lsp.CodeAction { + const codeAction = lsp.CodeAction.create(this.title, this.kind); + + if (this.command !== undefined) { + codeAction.command = this.command; + } + if (this.diagnostics !== undefined) { + codeAction.diagnostics = this.diagnostics; + } + if (this.disabled !== undefined) { + codeAction.disabled = this.disabled; + } + if (this.edit !== undefined) { + codeAction.edit = this.edit; + } + if (this.isPreferred !== undefined) { + codeAction.isPreferred = this.isPreferred; + } + + return codeAction; + } +} + +type ProviderResult = T | undefined | null | Thenable; + +/** + * Provides contextual actions for code. Code actions typically either fix problems or beautify/refactor code. + */ +export interface CodeActionProvider { + getMetadata(): CodeActionProviderMetadata; + + /** + * Get code actions for a given range in a document. + */ + provideCodeActions(document: LspDocument, range: lsp.Range, context: lsp.CodeActionContext, token: lsp.CancellationToken): ProviderResult<(lsp.Command | T)[]>; + + /** + * Whether given code action can be resolved with `resolveCodeAction`. + */ + isCodeActionResolvable(codeAction: T): boolean; + + /** + * Given a code action fill in its {@linkcode CodeAction.edit edit}-property. Changes to + * all other properties, like title, are ignored. A code action that has an edit + * will not be resolved. + * + * *Note* that a code action provider that returns commands, not code actions, cannot successfully + * implement this function. Returning commands is deprecated and instead code actions should be + * returned. + * + * @param codeAction A code action. + * @param token A cancellation token. + * @returns The resolved code action or a thenable that resolves to such. It is OK to return the given + * `item`. When no result is returned, the given `item` will be used. + */ + resolveCodeAction?(codeAction: T, token: lsp.CancellationToken): ProviderResult; +} + +/** + * Metadata about the type of code actions that a {@link CodeActionProvider} provides. + */ +export interface CodeActionProviderMetadata { + /** + * List of {@link CodeActionKind CodeActionKinds} that a {@link CodeActionProvider} may return. + * + * This list is used to determine if a given `CodeActionProvider` should be invoked or not. + * To avoid unnecessary computation, every `CodeActionProvider` should list use `providedCodeActionKinds`. The + * list of kinds may either be generic, such as `[CodeActionKind.Refactor]`, or list out every kind provided, + * such as `[CodeActionKind.Refactor.Extract.append('function'), CodeActionKind.Refactor.Extract.append('constant'), ...]`. + */ + readonly providedCodeActionKinds?: readonly lsp.CodeActionKind[]; +} diff --git a/src/features/codeActions/fixAll.ts b/src/features/codeActions/fixAll.ts new file mode 100644 index 00000000..396784a6 --- /dev/null +++ b/src/features/codeActions/fixAll.ts @@ -0,0 +1,266 @@ +// sync: file[extensions/typescript-language-features/src/languageFeatures/fixAll.ts] sha[f76ac124233270762d11ec3afaaaafcba53b3bbf] +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +/* + * Copyright (C) 2024 TypeFox and others. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. + * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 + */ + +import * as lsp from 'vscode-languageserver'; +import { type ts, CommandTypes } from '../../ts-protocol.js'; +import * as errorCodes from '../../utils/errorCodes.js'; +import * as fixNames from '../../utils/fixNames.js'; +import * as typeConverters from '../../utils/typeConverters.js'; +import { type ITypeScriptServiceClient } from '../../typescriptService.js'; +// import { DiagnosticsManager } from './diagnostics.js'; +import FileConfigurationManager from '../fileConfigurationManager.js'; +import { CodeActionProvider, CodeActionProviderMetadata, TsCodeAction } from './codeActionProvider.js'; +import { CodeActionKind } from '../../utils/types.js'; +import type { LspDocument } from '../../document.js'; +import { toTextDocumentEdit } from '../../protocol-translation.js'; +import { type DiagnosticsManager } from '../../diagnostic-queue.js'; + +interface AutoFix { + readonly codes: Set; + readonly fixName: string; +} + +async function buildIndividualFixes( + fixes: readonly AutoFix[], + client: ITypeScriptServiceClient, + file: string, + diagnostics: readonly lsp.Diagnostic[], + token: lsp.CancellationToken, +): Promise { + const documentChanges: lsp.TextDocumentEdit[] = []; + + for (const diagnostic of diagnostics) { + for (const { codes, fixName } of fixes) { + if (token.isCancellationRequested) { + return; + } + + if (!codes.has(diagnostic.code as number)) { + continue; + } + + const args: ts.server.protocol.CodeFixRequestArgs = { + ...typeConverters.Range.toFileRangeRequestArgs(file, diagnostic.range), + errorCodes: [+(diagnostic.code!)], + }; + + const response = await client.execute(CommandTypes.GetCodeFixes, args, token); + if (response.type !== 'response') { + continue; + } + + const fix = response.body?.find(fix => fix.fixName === fixName); + if (fix) { + documentChanges.push(...fix.changes.map(change => toTextDocumentEdit(change, client))); + break; + } + } + } + + return { + documentChanges, + }; +} + +async function buildCombinedFix( + fixes: readonly AutoFix[], + client: ITypeScriptServiceClient, + file: string, + diagnostics: readonly lsp.Diagnostic[], + token: lsp.CancellationToken, +): Promise { + for (const diagnostic of diagnostics) { + for (const { codes, fixName } of fixes) { + if (token.isCancellationRequested) { + return; + } + + if (!codes.has(diagnostic.code as number)) { + continue; + } + + const args: ts.server.protocol.CodeFixRequestArgs = { + ...typeConverters.Range.toFileRangeRequestArgs(file, diagnostic.range), + errorCodes: [+(diagnostic.code!)], + }; + + const response = await client.execute(CommandTypes.GetCodeFixes, args, token); + if (response.type !== 'response' || !response.body?.length) { + continue; + } + + const fix = response.body?.find(fix => fix.fixName === fixName); + if (!fix) { + continue; + } + + if (!fix.fixId) { + return { + documentChanges: fix.changes.map(change => toTextDocumentEdit(change, client)), + } satisfies lsp.WorkspaceEdit; + } + + const combinedArgs: ts.server.protocol.GetCombinedCodeFixRequestArgs = { + scope: { + type: 'file', + args: { file }, + }, + fixId: fix.fixId, + }; + + const combinedResponse = await client.execute(CommandTypes.GetCombinedCodeFix, combinedArgs, token); + if (combinedResponse.type !== 'response' || !combinedResponse.body) { + return; + } + + return { + documentChanges: combinedResponse.body.changes.map(change => toTextDocumentEdit(change, client)), + } satisfies lsp.WorkspaceEdit; + } + } +} + +// #region Source Actions + +abstract class SourceAction extends TsCodeAction { + abstract build( + client: ITypeScriptServiceClient, + file: string, + diagnostics: readonly lsp.Diagnostic[], + token: lsp.CancellationToken, + ): Promise; +} + +class SourceFixAll extends SourceAction { + static readonly kind = CodeActionKind.SourceFixAllTs; + + constructor() { + super('Fix all fixable JS/TS issues', SourceFixAll.kind.value); + } + + async build(client: ITypeScriptServiceClient, file: string, diagnostics: readonly lsp.Diagnostic[], token: lsp.CancellationToken): Promise { + this.edit = await buildIndividualFixes([ + { codes: errorCodes.incorrectlyImplementsInterface, fixName: fixNames.classIncorrectlyImplementsInterface }, + { codes: errorCodes.asyncOnlyAllowedInAsyncFunctions, fixName: fixNames.awaitInSyncFunction }, + ], client, file, diagnostics, token); + + const edits = await buildCombinedFix([ + { codes: errorCodes.unreachableCode, fixName: fixNames.unreachableCode }, + ], client, file, diagnostics, token); + if (edits?.documentChanges) { + this.edit?.documentChanges?.push(...edits.documentChanges); + } + } +} + +class SourceRemoveUnused extends SourceAction { + static readonly kind = CodeActionKind.SourceRemoveUnusedTs; + + constructor() { + super('Remove all unused code', SourceRemoveUnused.kind.value); + } + + async build(client: ITypeScriptServiceClient, file: string, diagnostics: readonly lsp.Diagnostic[], token: lsp.CancellationToken): Promise { + this.edit = await buildCombinedFix([ + { codes: errorCodes.variableDeclaredButNeverUsed, fixName: fixNames.unusedIdentifier }, + ], client, file, diagnostics, token); + } +} + +class SourceAddMissingImports extends SourceAction { + static readonly kind = CodeActionKind.SourceAddMissingImportsTs; + + constructor() { + super('Add all missing imports', SourceAddMissingImports.kind.value); + } + + async build(client: ITypeScriptServiceClient, file: string, diagnostics: readonly lsp.Diagnostic[], token: lsp.CancellationToken): Promise { + this.edit = await buildCombinedFix([ + { codes: errorCodes.cannotFindName, fixName: fixNames.fixImport }, + ], client, file, diagnostics, token); + } +} + +//#endregion + +export class TypeScriptAutoFixProvider implements CodeActionProvider { + private static readonly kindProviders = [ + SourceFixAll, + SourceRemoveUnused, + SourceAddMissingImports, + ]; + + constructor( + private readonly client: ITypeScriptServiceClient, + private readonly fileConfigurationManager: FileConfigurationManager, + private readonly diagnosticsManager: DiagnosticsManager, + ) { } + + public getMetadata(): CodeActionProviderMetadata { + return { + providedCodeActionKinds: TypeScriptAutoFixProvider.kindProviders.map(x => x.kind.value), + }; + } + + public async provideCodeActions( + document: LspDocument, + _range: lsp.Range, + context: lsp.CodeActionContext, + token: lsp.CancellationToken, + ): Promise { + if (!context.only?.length) { + return undefined; + } + + const sourceKinds = context.only + .map(kind => new CodeActionKind(kind)) + .filter(codeActionKind => CodeActionKind.Source.intersects(codeActionKind)); + if (!sourceKinds.length) { + return undefined; + } + + // TODO: Since we rely on diagnostics pointing at errors in the correct places, we can't proceed if we are not + // sure that diagnostics are up-to-date. Thus we check if there are pending diagnostic requests for the file. + // In general would be better to replace the whole diagnostics handling logic with the one from + // bufferSyncSupport.ts in VSCode's typescript language features. + if (this.client.hasPendingDiagnostics(document.uri)) { + return undefined; + } + + const actions = this.getFixAllActions(sourceKinds); + const diagnostics = this.diagnosticsManager.getDiagnosticsForFile(document.filepath); + if (!diagnostics.length) { + // Actions are a no-op in this case but we still want to return them + return actions; + } + + await this.fileConfigurationManager.ensureConfigurationForDocument(document, token); + + if (token.isCancellationRequested) { + return undefined; + } + + await Promise.all(actions.map(action => action.build(this.client, document.filepath, diagnostics, token))); + + return actions; + } + + public isCodeActionResolvable(_codeAction: TsCodeAction): boolean { + return false; + } + + private getFixAllActions(kinds: CodeActionKind[]): SourceAction[] { + return TypeScriptAutoFixProvider.kindProviders + .filter(provider => kinds.some(only => only.intersects(provider.kind))) + .map(provider => new provider()); + } +} diff --git a/src/features/codeActions/quickFix.ts b/src/features/codeActions/quickFix.ts new file mode 100644 index 00000000..5e1715e9 --- /dev/null +++ b/src/features/codeActions/quickFix.ts @@ -0,0 +1,440 @@ +// sync: file[extensions/typescript-language-features/src/languageFeatures/quickFix.ts] sha[f76ac124233270762d11ec3afaaaafcba53b3bbf] +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +/* + * Copyright (C) 2024 TypeFox and others. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. + * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 + */ + +/* eslint-disable @typescript-eslint/ban-types */ + +import * as lsp from 'vscode-languageserver'; +import { URI } from 'vscode-uri'; +import { type ts, CommandTypes, type SupportedFeatures } from '../../ts-protocol.js'; +import { type Command, CommandManager } from '../../commands/commandManager.js'; +import * as fixNames from '../../utils/fixNames.js'; +import * as typeConverters from '../../utils/typeConverters.js'; +import { type ITypeScriptServiceClient } from '../../typescriptService.js'; +import { memoize } from '../../utils/memoize.js'; +import { equals } from '../../utils/objects.js'; +// import { DiagnosticsManager } from './diagnostics.js'; +import FileConfigurationManager from '../fileConfigurationManager.js'; +import { applyCodeActionCommands, getEditForCodeAction } from '../util/codeAction.js'; +import { CodeActionProvider, CodeActionProviderMetadata, TsCodeAction } from './codeActionProvider.js'; +import { LspDocument } from '../../document.js'; +import { toTextDocumentEdit } from '../../protocol-translation.js'; +import { CodeActionKind } from '../../utils/types.js'; +import { type DiagnosticsManager } from '../../diagnostic-queue.js'; + +type ApplyCodeActionCommand_args = { + readonly documentUri: string; + readonly diagnostic: lsp.Diagnostic; + readonly action: ts.server.protocol.CodeFixAction; +}; + +class ApplyCodeActionCommand implements Command { + public static readonly ID = '_typescript.applyCodeActionCommand'; + public readonly id = ApplyCodeActionCommand.ID; + + constructor( + private readonly client: ITypeScriptServiceClient, + // private readonly diagnosticManager: DiagnosticsManager, + ) { } + + // public async execute({ documentUri, action, diagnostic }: ApplyCodeActionCommand_args): Promise { + public async execute({ action }: ApplyCodeActionCommand_args): Promise { + // this.diagnosticManager.deleteDiagnostic(documentUri, diagnostic); + const codeActionResult = await applyCodeActionCommands(this.client, action.commands); + return codeActionResult; + } +} + +type ApplyFixAllCodeAction_args = { + readonly action: TsQuickFixAllCodeAction; +}; + +class ApplyFixAllCodeAction implements Command { + public static readonly ID = '_typescript.applyFixAllCodeAction'; + public readonly id = ApplyFixAllCodeAction.ID; + + constructor( + private readonly client: ITypeScriptServiceClient, + ) { } + + public async execute(args: ApplyFixAllCodeAction_args): Promise { + if (args.action.combinedResponse) { + await applyCodeActionCommands(this.client, args.action.combinedResponse.body.commands); + } + } +} + +/** + * Unique set of diagnostics keyed on diagnostic range and error code. + */ +class DiagnosticsSet { + public static from(diagnostics: lsp.Diagnostic[]) { + const values = new Map(); + for (const diagnostic of diagnostics) { + values.set(DiagnosticsSet.key(diagnostic), diagnostic); + } + return new DiagnosticsSet(values); + } + + private static key(diagnostic: lsp.Diagnostic) { + const { start, end } = diagnostic.range; + return `${diagnostic.code}-${start.line},${start.character}-${end.line},${end.character}`; + } + + private constructor( + private readonly _values: Map, + ) { } + + public get values(): Iterable { + return this._values.values(); + } + + public get size() { + return this._values.size; + } +} + +class TsQuickFixCodeAction extends TsCodeAction { + constructor( + public readonly tsAction: ts.server.protocol.CodeFixAction, + title: string, + kind: lsp.CodeActionKind, + ) { + super(title, kind); + } +} + +class TsQuickFixAllCodeAction extends TsQuickFixCodeAction { + constructor( + tsAction: ts.server.protocol.CodeFixAction, + public readonly file: string, + title: string, + kind: lsp.CodeActionKind, + ) { + super(tsAction, title, kind); + } + + public combinedResponse?: ts.server.protocol.GetCombinedCodeFixResponse; +} + +class CodeActionSet { + private readonly _actions = new Set(); + private readonly _fixAllActions = new Map<{}, TsQuickFixCodeAction>(); + private readonly _aiActions = new Set(); + + public *values(): Iterable { + yield* this._actions; + yield* this._aiActions; + } + + public addAction(action: TsQuickFixCodeAction) { + for (const existing of this._actions) { + if (action.tsAction.fixName === existing.tsAction.fixName && equals(action.edit, existing.edit)) { + this._actions.delete(existing); + } + } + + this._actions.add(action); + + if (action.tsAction.fixId) { + // If we have an existing fix all action, then make sure it follows this action + const existingFixAll = this._fixAllActions.get(action.tsAction.fixId); + if (existingFixAll) { + this._actions.delete(existingFixAll); + this._actions.add(existingFixAll); + } + } + } + + public addFixAllAction(fixId: {}, action: TsQuickFixCodeAction) { + const existing = this._fixAllActions.get(fixId); + if (existing) { + // reinsert action at back of actions list + this._actions.delete(existing); + } + this.addAction(action); + this._fixAllActions.set(fixId, action); + } + + public hasFixAllAction(fixId: {}) { + return this._fixAllActions.has(fixId); + } +} + +class SupportedCodeActionProvider { + public constructor( + private readonly client: ITypeScriptServiceClient, + ) { } + + public async getFixableDiagnosticsForContext(diagnostics: readonly lsp.Diagnostic[]): Promise { + const fixableCodes = await this.fixableDiagnosticCodes; + return DiagnosticsSet.from( + diagnostics.filter(diagnostic => typeof diagnostic.code !== 'undefined' && fixableCodes.has(diagnostic.code + ''))); + } + + @memoize + private get fixableDiagnosticCodes(): Thenable> { + return this.client.execute(CommandTypes.GetSupportedCodeFixes, null) + .then(response => response.type === 'response' ? response.body || [] : []) + .then(codes => new Set(codes)); + } +} + +export class TypeScriptQuickFixProvider implements CodeActionProvider { + private static readonly _maxCodeActionsPerFile: number = 1000; + private readonly supportedCodeActionProvider: SupportedCodeActionProvider; + + constructor( + private readonly client: ITypeScriptServiceClient, + private readonly fileConfigurationManager: FileConfigurationManager, + commandManager: CommandManager, + private readonly diagnosticsManager: DiagnosticsManager, + private features: SupportedFeatures, + ) { + commandManager.register(new ApplyCodeActionCommand(client/*, diagnosticsManager*/)); + commandManager.register(new ApplyFixAllCodeAction(client)); + + this.supportedCodeActionProvider = new SupportedCodeActionProvider(client); + } + + public getMetadata(): CodeActionProviderMetadata { + return { + providedCodeActionKinds: [CodeActionKind.QuickFix.value], + }; + } + + public async provideCodeActions( + document: LspDocument, + range: lsp.Range, + context: lsp.CodeActionContext, + token: lsp.CancellationToken, + ): Promise { + let diagnostics = context.diagnostics; + if (this.client.hasPendingDiagnostics(document.uri)) { + // Delay for 500ms when there are pending diagnostics before recomputing up-to-date diagnostics. + await new Promise((resolve) => { + setTimeout(resolve, 500); + }); + + if (token.isCancellationRequested) { + return; + } + const allDiagnostics: lsp.Diagnostic[] = []; + + // // Match ranges again after getting new diagnostics + for (const diagnostic of this.diagnosticsManager.getDiagnosticsForFile(document.filepath)) { + if (typeConverters.Range.intersection(range, diagnostic.range)) { + const newLen = allDiagnostics.push(diagnostic); + if (newLen > TypeScriptQuickFixProvider._maxCodeActionsPerFile) { + break; + } + } + } + diagnostics = allDiagnostics; + } + + const fixableDiagnostics = await this.supportedCodeActionProvider.getFixableDiagnosticsForContext(diagnostics); + if (!fixableDiagnostics.size || token.isCancellationRequested) { + return; + } + + await this.fileConfigurationManager.ensureConfigurationForDocument(document, token); + if (token.isCancellationRequested) { + return; + } + + const results = new CodeActionSet(); + for (const diagnostic of fixableDiagnostics.values) { + await this.getFixesForDiagnostic(document, diagnostic, results, token); + if (token.isCancellationRequested) { + return; + } + } + + const allActions = Array.from(results.values()); + for (const action of allActions) { + action.isPreferred = isPreferredFix(action, allActions); + } + return allActions; + } + + public isCodeActionResolvable(codeAction: TsQuickFixCodeAction): codeAction is TsQuickFixAllCodeAction { + return codeAction instanceof TsQuickFixAllCodeAction; + } + + public async resolveCodeAction(codeAction: TsQuickFixCodeAction, token: lsp.CancellationToken): Promise { + if (!this.isCodeActionResolvable(codeAction) || !codeAction.tsAction.fixId) { + return codeAction; + } + + const arg: ts.server.protocol.GetCombinedCodeFixRequestArgs = { + scope: { + type: 'file', + args: { file: codeAction.file }, + }, + fixId: codeAction.tsAction.fixId, + }; + + const response = await this.client.execute(CommandTypes.GetCombinedCodeFix, arg, token); + if (response.type === 'response') { + codeAction.combinedResponse = response; + codeAction.edit = { documentChanges: response.body.changes.map(change => toTextDocumentEdit(change, this.client)) }; + } + + return codeAction; + } + + private async getFixesForDiagnostic( + document: LspDocument, + diagnostic: lsp.Diagnostic, + results: CodeActionSet, + token: lsp.CancellationToken, + ): Promise { + const args: ts.server.protocol.CodeFixRequestArgs = { + ...typeConverters.Range.toFileRangeRequestArgs(document.filepath, diagnostic.range), + errorCodes: [+(diagnostic.code!)], + }; + const response = await this.client.execute(CommandTypes.GetCodeFixes, args, token); + if (response.type !== 'response' || !response.body) { + return results; + } + + for (const tsCodeFix of response.body) { + for (const action of this.getFixesForTsCodeAction(document, diagnostic, tsCodeFix)) { + results.addAction(action); + } + if (this.features.codeActionResolveSupport) { + this.addFixAllForTsCodeAction(results, document.uri, document.filepath, diagnostic, tsCodeFix); + } + } + return results; + } + + private getFixesForTsCodeAction( + document: LspDocument, + diagnostic: lsp.Diagnostic, + action: ts.server.protocol.CodeFixAction, + ): TsQuickFixCodeAction[] { + const actions: TsQuickFixCodeAction[] = []; + const codeAction = new TsQuickFixCodeAction(action, action.description, lsp.CodeActionKind.QuickFix); + codeAction.edit = getEditForCodeAction(this.client, action); + codeAction.diagnostics = [diagnostic]; + codeAction.command = { + command: ApplyCodeActionCommand.ID, + arguments: [{ action, diagnostic, documentUri: document.uri.toString() } satisfies ApplyCodeActionCommand_args], + title: '', + }; + actions.push(codeAction); + return actions; + } + + private addFixAllForTsCodeAction( + results: CodeActionSet, + _resource: URI, + file: string, + diagnostic: lsp.Diagnostic, + tsAction: ts.server.protocol.CodeFixAction, + ): CodeActionSet { + if (!tsAction.fixId || results.hasFixAllAction(tsAction.fixId)) { + return results; + } + + // Make sure there are multiple diagnostics of the same type in the file + if (!this.diagnosticsManager.getDiagnosticsForFile(file).some(x => { + if (x === diagnostic) { + return false; + } + return x.code === diagnostic.code + || fixAllErrorCodes.has(x.code as number) && fixAllErrorCodes.get(x.code as number) === fixAllErrorCodes.get(diagnostic.code as number); + })) { + return results; + } + + const action = new TsQuickFixAllCodeAction( + tsAction, + file, + tsAction.fixAllDescription || `${tsAction.description} (Fix all in file)`, + lsp.CodeActionKind.QuickFix); + + action.diagnostics = [diagnostic]; + // TODO: Recursive property causes error on stringifying. + // action.command = { + // command: ApplyFixAllCodeAction.ID, + // arguments: [{ action } satisfies ApplyFixAllCodeAction_args], + // title: '', + // }; + results.addFixAllAction(tsAction.fixId, action); + return results; + } +} + +// Some fix all actions can actually fix multiple differnt diagnostics. Make sure we still show the fix all action +// in such cases +const fixAllErrorCodes = new Map([ + // Missing async + [2339, 2339], + [2345, 2339], +]); + +const preferredFixes = new Map([ + [fixNames.annotateWithTypeFromJSDoc, { priority: 2 }], + [fixNames.constructorForDerivedNeedSuperCall, { priority: 2 }], + [fixNames.extendsInterfaceBecomesImplements, { priority: 2 }], + [fixNames.awaitInSyncFunction, { priority: 2 }], + [fixNames.removeUnnecessaryAwait, { priority: 2 }], + [fixNames.classIncorrectlyImplementsInterface, { priority: 3 }], + [fixNames.classDoesntImplementInheritedAbstractMember, { priority: 3 }], + [fixNames.unreachableCode, { priority: 2 }], + [fixNames.unusedIdentifier, { priority: 2 }], + [fixNames.forgottenThisPropertyAccess, { priority: 2 }], + [fixNames.spelling, { priority: 0 }], + [fixNames.addMissingAwait, { priority: 2 }], + [fixNames.addMissingOverride, { priority: 2 }], + [fixNames.addMissingNewOperator, { priority: 2 }], + [fixNames.fixImport, { priority: 1, thereCanOnlyBeOne: true }], +]); + +function isPreferredFix( + action: TsQuickFixCodeAction, + allActions: readonly TsQuickFixCodeAction[], +): boolean { + if (action instanceof TsQuickFixAllCodeAction) { + return false; + } + + const fixPriority = preferredFixes.get(action.tsAction.fixName); + if (!fixPriority) { + return false; + } + + return allActions.every(otherAction => { + if (otherAction === action) { + return true; + } + + if (otherAction instanceof TsQuickFixAllCodeAction) { + return true; + } + + const otherFixPriority = preferredFixes.get(otherAction.tsAction.fixName); + if (!otherFixPriority || otherFixPriority.priority < fixPriority.priority) { + return true; + } else if (otherFixPriority.priority > fixPriority.priority) { + return false; + } + + if (fixPriority.thereCanOnlyBeOne && action.tsAction.fixName === otherAction.tsAction.fixName) { + return false; + } + + return true; + }); +} diff --git a/src/features/fix-all.ts b/src/features/fix-all.ts deleted file mode 100644 index 9807d030..00000000 --- a/src/features/fix-all.ts +++ /dev/null @@ -1,207 +0,0 @@ -/*--------------------------------------------------------------------------------------------- - * Copyright (c) Microsoft Corporation. All rights reserved. - * Licensed under the MIT License. See License.txt in the project root for license information. - *--------------------------------------------------------------------------------------------*/ - -import * as lsp from 'vscode-languageserver'; -import { toTextDocumentEdit } from '../protocol-translation.js'; -import { CommandTypes } from '../ts-protocol.js'; -import type { ts } from '../ts-protocol.js'; -import { TsClient } from '../ts-client.js'; -import * as errorCodes from '../utils/errorCodes.js'; -import * as fixNames from '../utils/fixNames.js'; -import { CodeActionKind } from '../utils/types.js'; -import { Range } from '../utils/typeConverters.js'; - -interface AutoFix { - readonly codes: Set; - readonly fixName: string; -} - -async function buildIndividualFixes( - fixes: readonly AutoFix[], - client: TsClient, - file: string, - diagnostics: readonly lsp.Diagnostic[], -): Promise { - const edits: lsp.TextDocumentEdit[] = []; - for (const diagnostic of diagnostics) { - for (const { codes, fixName } of fixes) { - if (!codes.has(diagnostic.code as number)) { - continue; - } - - const args: ts.server.protocol.CodeFixRequestArgs = { - ...Range.toFileRangeRequestArgs(file, diagnostic.range), - errorCodes: [+diagnostic.code!], - }; - - const response = await client.execute(CommandTypes.GetCodeFixes, args); - if (response.type !== 'response') { - continue; - } - - const fix = response.body?.find(fix => fix.fixName === fixName); - if (fix) { - edits.push(...fix.changes.map(change => toTextDocumentEdit(change, client))); - break; - } - } - } - return edits; -} - -async function buildCombinedFix( - fixes: readonly AutoFix[], - client: TsClient, - file: string, - diagnostics: readonly lsp.Diagnostic[], -): Promise { - const edits: lsp.TextDocumentEdit[] = []; - for (const diagnostic of diagnostics) { - for (const { codes, fixName } of fixes) { - if (!codes.has(diagnostic.code as number)) { - continue; - } - - const args: ts.server.protocol.CodeFixRequestArgs = { - ...Range.toFileRangeRequestArgs(file, diagnostic.range), - errorCodes: [+diagnostic.code!], - }; - - const response = await client.execute(CommandTypes.GetCodeFixes, args); - if (response.type !== 'response' || !response.body?.length) { - continue; - } - - const fix = response.body?.find(fix => fix.fixName === fixName); - if (!fix) { - continue; - } - - if (!fix.fixId) { - edits.push(...fix.changes.map(change => toTextDocumentEdit(change, client))); - return edits; - } - - const combinedArgs: ts.server.protocol.GetCombinedCodeFixRequestArgs = { - scope: { - type: 'file', - args: { file }, - }, - fixId: fix.fixId, - }; - - const combinedResponse = await client.execute(CommandTypes.GetCombinedCodeFix, combinedArgs); - if (combinedResponse.type !== 'response' || !combinedResponse.body) { - return edits; - } - - edits.push(...combinedResponse.body.changes.map(change => toTextDocumentEdit(change, client))); - return edits; - } - } - return edits; -} - -// #region Source Actions - -abstract class SourceAction { - abstract build( - client: TsClient, - file: string, - diagnostics: readonly lsp.Diagnostic[] - ): Promise; -} - -class SourceFixAll extends SourceAction { - private readonly title = 'Fix all'; - static readonly kind = CodeActionKind.SourceFixAllTs; - - async build( - client: TsClient, - file: string, - diagnostics: readonly lsp.Diagnostic[], - ): Promise { - const edits: lsp.TextDocumentEdit[] = []; - edits.push(...await buildIndividualFixes([ - { codes: errorCodes.incorrectlyImplementsInterface, fixName: fixNames.classIncorrectlyImplementsInterface }, - { codes: errorCodes.asyncOnlyAllowedInAsyncFunctions, fixName: fixNames.awaitInSyncFunction }, - ], client, file, diagnostics)); - edits.push(...await buildCombinedFix([ - { codes: errorCodes.unreachableCode, fixName: fixNames.unreachableCode }, - ], client, file, diagnostics)); - if (!edits.length) { - return null; - } - return lsp.CodeAction.create(this.title, { documentChanges: edits }, SourceFixAll.kind.value); - } -} - -class SourceRemoveUnused extends SourceAction { - private readonly title = 'Remove all unused code'; - static readonly kind = CodeActionKind.SourceRemoveUnusedTs; - - async build( - client: TsClient, - file: string, - diagnostics: readonly lsp.Diagnostic[], - ): Promise { - const edits = await buildCombinedFix([ - { codes: errorCodes.variableDeclaredButNeverUsed, fixName: fixNames.unusedIdentifier }, - ], client, file, diagnostics); - if (!edits.length) { - return null; - } - return lsp.CodeAction.create(this.title, { documentChanges: edits }, SourceRemoveUnused.kind.value); - } -} - -class SourceAddMissingImports extends SourceAction { - private readonly title = 'Add all missing imports'; - static readonly kind = CodeActionKind.SourceAddMissingImportsTs; - - async build( - client: TsClient, - file: string, - diagnostics: readonly lsp.Diagnostic[], - ): Promise { - const edits = await buildCombinedFix([ - { codes: errorCodes.cannotFindName, fixName: fixNames.fixImport }, - ], client, file, diagnostics); - if (!edits.length) { - return null; - } - return lsp.CodeAction.create(this.title, { documentChanges: edits }, SourceAddMissingImports.kind.value); - } -} - -//#endregion - -export class TypeScriptAutoFixProvider { - private static kindProviders = [ - SourceFixAll, - SourceRemoveUnused, - SourceAddMissingImports, - ]; - - public static get kinds(): CodeActionKind[] { - return TypeScriptAutoFixProvider.kindProviders.map(provider => provider.kind); - } - - constructor(private readonly client: TsClient) {} - - public async provideCodeActions( - kinds: CodeActionKind[], - file: string, - diagnostics: lsp.Diagnostic[], - ): Promise { - const results: Promise[] = []; - for (const provider of TypeScriptAutoFixProvider.kindProviders) { - if (kinds.some(kind => kind.contains(provider.kind))) { - results.push((new provider).build(this.client, file, diagnostics)); - } - } - return (await Promise.all(results)).flatMap(result => result || []); - } -} diff --git a/src/features/util/codeAction.ts b/src/features/util/codeAction.ts new file mode 100644 index 00000000..cc0b6421 --- /dev/null +++ b/src/features/util/codeAction.ts @@ -0,0 +1,54 @@ +// sync: file[extensions/typescript-language-features/src/languageFeatures/util/codeAction.ts] sha[f76ac124233270762d11ec3afaaaafcba53b3bbf] +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ +/* + * Copyright (C) 2022 TypeFox and others. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. + * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 + */ + +import * as lsp from 'vscode-languageserver'; +import { CommandTypes, type ts } from '../../ts-protocol.js'; +import { ITypeScriptServiceClient } from '../../typescriptService.js'; +import { toTextDocumentEdit } from '../../protocol-translation.js'; +import { LspClient } from '../../lsp-client.js'; + +export function getEditForCodeAction( + client: ITypeScriptServiceClient, + action: ts.server.protocol.CodeAction, +): lsp.WorkspaceEdit | undefined { + return action.changes?.length + ? { documentChanges: action.changes.map(change => toTextDocumentEdit(change, client)) } + : undefined; +} + +export async function applyCodeAction( + client: ITypeScriptServiceClient, + lspClient: LspClient, + action: ts.server.protocol.CodeAction, + token: lsp.CancellationToken, +): Promise { + const workspaceEdit = getEditForCodeAction(client, action); + if (workspaceEdit) { + if (!await lspClient.applyWorkspaceEdit({ edit: workspaceEdit })) { + return false; + } + } + return applyCodeActionCommands(client, action.commands, token); +} + +export async function applyCodeActionCommands( + client: ITypeScriptServiceClient, + commands: ReadonlyArray

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.