Microsoft/vscode
1
0
Fork 0
mirror of https://github.com/microsoft/vscode.git synced 2026-04-22 01:29:04 +01:00
Code Issues Packages Projects Releases Wiki Activity

Move ServerResponse into namespace

Browse Source
This commit is contained in:
Matt Bierner
2019-01-25 17:06:14 -08:00
parent ccb5a625c2
commit ef25b181ea
8 changed files with 50 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
extensions/typescript-language-features/src/commands/goToProjectConfiguration.ts
View File

@@ -69,7 +69,7 @@ async function goToProjectConfig(
return;
}
let res: ServerResponse<protocol.ProjectInfoResponse> | undefined;
let res: ServerResponse.Response<protocol.ProjectInfoResponse> | undefined;
try {
res = await client.execute('projectInfo', { file, needFileNameList: false }, nulToken);
} catch {

2
extensions/typescript-language-features/src/features/rename.ts
View File

@@ -79,7 +79,7 @@ class TypeScriptRenameProvider implements vscode.RenameProvider {
document: vscode.TextDocument,
position: vscode.Position,
token: vscode.CancellationToken
): Promise<ServerResponse<Proto.RenameResponse> | undefined> {
): Promise<ServerResponse.Response<Proto.RenameResponse> | undefined> {
const file = this.client.toOpenedFilePath(document);
if (!file) {
return undefined;

20
extensions/typescript-language-features/src/test/cachedResponse.test.ts
View File

@@ -8,7 +8,7 @@ import 'mocha';
import * as vscode from 'vscode';
import * as Proto from '../protocol';
import { CachedResponse } from '../tsServer/cachedResponse';
import { ServerResponse, CancelledResponse } from '../typescriptService';
import { ServerResponse } from '../typescriptService';
suite('CachedResponse', () => {
test('should cache simple response for same document', async () => {
@@ -36,12 +36,12 @@ suite('CachedResponse', () => {
const doc = await createTextDocument();
const response = new CachedResponse();
const cancelledResponder = createEventualResponder<CancelledResponse>();
const cancelledResponder = createEventualResponder<ServerResponse.Cancelled>();
const result1 = response.execute(doc, () => cancelledResponder.promise);
const result2 = response.execute(doc, respondWith('test-0'));
const result3 = response.execute(doc, respondWith('test-1'));
cancelledResponder.resolve(new CancelledResponse('cancelled'));
cancelledResponder.resolve(new ServerResponse.Cancelled('cancelled'));
assert.strictEqual((await result1).type, 'cancelled');
assertResult(await result2, 'test-0');
@@ -52,12 +52,12 @@ suite('CachedResponse', () => {
const doc = await createTextDocument();
const response = new CachedResponse();
const cancelledResponder = createEventualResponder<CancelledResponse>();
const cancelledResponder = createEventualResponder<ServerResponse.Cancelled>();
const result1 = response.execute(doc, respondWith('test-0'));
const result2 = response.execute(doc, () => cancelledResponder.promise);
const result3 = response.execute(doc, respondWith('test-1'));
cancelledResponder.resolve(new CancelledResponse('cancelled'));
cancelledResponder.resolve(new ServerResponse.Cancelled('cancelled'));
assertResult(await result1, 'test-0');
assertResult(await result2, 'test-0');
@@ -69,8 +69,8 @@ suite('CachedResponse', () => {
const doc2 = await createTextDocument();
const response = new CachedResponse();
const cancelledResponder = createEventualResponder<CancelledResponse>();
const cancelledResponder2 = createEventualResponder<CancelledResponse>();
const cancelledResponder = createEventualResponder<ServerResponse.Cancelled>();
const cancelledResponder2 = createEventualResponder<ServerResponse.Cancelled>();
const result1 = response.execute(doc1, () => cancelledResponder.promise);
const result2 = response.execute(doc1, respondWith('test-0'));
@@ -79,8 +79,8 @@ suite('CachedResponse', () => {
const result5 = response.execute(doc2, respondWith('test-2'));
const result6 = response.execute(doc1, respondWith('test-3'));
cancelledResponder.resolve(new CancelledResponse('cancelled'));
cancelledResponder2.resolve(new CancelledResponse('cancelled'));
cancelledResponder.resolve(new ServerResponse.Cancelled('cancelled'));
cancelledResponder2.resolve(new ServerResponse.Cancelled('cancelled'));
assert.strictEqual((await result1).type, 'cancelled');
assertResult(await result2, 'test-0');
@@ -99,7 +99,7 @@ function createTextDocument() {
return vscode.workspace.openTextDocument({ language: 'javascript', content: '' });
}
function assertResult(result: ServerResponse<Proto.Response>, command: string) {
function assertResult(result: ServerResponse.Response<Proto.Response>, command: string) {
if (result.type === 'response') {
assert.strictEqual(result.command, command);
} else {

8
extensions/typescript-language-features/src/tsServer/cachedResponse.ts
View File

@@ -7,13 +7,13 @@ import * as vscode from 'vscode';
import * as Proto from '../protocol';
import { ServerResponse } from '../typescriptService';
type Resolve<T extends Proto.Response> = () => Promise<ServerResponse<T>>;
type Resolve<T extends Proto.Response> = () => Promise<ServerResponse.Response<T>>;
/**
* Caches a class of TS Server request based on document.
*/
export class CachedResponse<T extends Proto.Response> {
private response?: Promise<ServerResponse<T>>;
private response?: Promise<ServerResponse.Response<T>>;
private version: number = -1;
private document: string = '';
@@ -25,7 +25,7 @@ export class CachedResponse<T extends Proto.Response> {
public execute(
document: vscode.TextDocument,
resolve: Resolve<T>
): Promise<ServerResponse<T>> {
): Promise<ServerResponse.Response<T>> {
if (this.response && this.matches(document)) {
// Chain so that on cancellation we fall back to the next resolve
return this.response = this.response.then(result => result.type === 'cancelled' ? resolve() : result);
@@ -40,7 +40,7 @@ export class CachedResponse<T extends Proto.Response> {
private async reset(
document: vscode.TextDocument,
resolve: Resolve<T>
): Promise<ServerResponse<T>> {
): Promise<ServerResponse.Response<T>> {
this.version = document.version;
this.document = document.uri.toString();
return this.response = resolve();

12
extensions/typescript-language-features/src/tsServer/callbackMap.ts
View File

@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import * as Proto from '../protocol';
import { CancelledResponse, ServerResponse } from '../typescriptService';
import { ServerResponse } from '../typescriptService';
export interface CallbackItem<R> {
readonly onSuccess: (value: R) => void;
@@ -14,11 +14,11 @@ export interface CallbackItem<R> {
}
export class CallbackMap<R extends Proto.Response> {
private readonly _callbacks = new Map<number, CallbackItem<ServerResponse<R> | undefined>>();
private readonly _asyncCallbacks = new Map<number, CallbackItem<ServerResponse<R> | undefined>>();
private readonly _callbacks = new Map<number, CallbackItem<ServerResponse.Response<R> | undefined>>();
private readonly _asyncCallbacks = new Map<number, CallbackItem<ServerResponse.Response<R> | undefined>>();
public destroy(cause: string): void {
const cancellation = new CancelledResponse(cause);
const cancellation = new ServerResponse.Cancelled(cause);
for (const callback of this._callbacks.values()) {
callback.onSuccess(cancellation);
}
@@ -29,7 +29,7 @@ export class CallbackMap<R extends Proto.Response> {
this._asyncCallbacks.clear();
}
public add(seq: number, callback: CallbackItem<ServerResponse<R> | undefined>, isAsync: boolean) {
public add(seq: number, callback: CallbackItem<ServerResponse.Response<R> | undefined>, isAsync: boolean) {
if (isAsync) {
this._asyncCallbacks.set(seq, callback);
} else {
@@ -37,7 +37,7 @@ export class CallbackMap<R extends Proto.Response> {
}
}
public fetch(seq: number): CallbackItem<ServerResponse<R> | undefined> | undefined {
public fetch(seq: number): CallbackItem<ServerResponse.Response<R> | undefined> | undefined {
const callback = this._callbacks.get(seq) || this._asyncCallbacks.get(seq);
this.delete(seq);
return callback;

14
extensions/typescript-language-features/src/tsServer/server.ts
View File

@@ -8,7 +8,7 @@ import * as fs from 'fs';
import * as path from 'path';
import * as vscode from 'vscode';
import * as Proto from '../protocol';
import { CancelledResponse, NoContentResponse, ServerResponse } from '../typescriptService';
import { ServerResponse } from '../typescriptService';
import API from '../utils/api';
import { TsServerLogLevel, TypeScriptServiceConfiguration } from '../utils/configuration';
import { Disposable } from '../utils/dispose';
@@ -299,7 +299,7 @@ export class TypeScriptServer extends Disposable {
} finally {
const callback = this.fetchCallback(seq);
if (callback) {
callback.onSuccess(new CancelledResponse(`Cancelled request ${seq} - ${command}`));
callback.onSuccess(new ServerResponse.Cancelled(`Cancelled request ${seq} - ${command}`));
}
}
}
@@ -315,15 +315,15 @@ export class TypeScriptServer extends Disposable {
callback.onSuccess(response);
} else if (response.message === 'No content available.') {
// Special case where response itself is successful but there is not any data to return.
callback.onSuccess(NoContentResponse);
callback.onSuccess(ServerResponse.NoContent);
} else {
callback.onError(new TypeScriptServerError(this._version, response));
}
}
public executeImpl(command: string, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: false, lowPriority?: boolean }): undefined;
public executeImpl(command: string, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse<Proto.Response>>;
public executeImpl(command: string, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse<Proto.Response>> | undefined {
public executeImpl(command: string, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>>;
public executeImpl(command: string, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>> | undefined {
const request = this._requestQueue.createRequest(command, args);
const requestInfo: RequestItem = {
request,
@@ -331,9 +331,9 @@ export class TypeScriptServer extends Disposable {
isAsync: executeInfo.isAsync,
queueingType: getQueueingType(command, executeInfo.lowPriority)
};
let result: Promise<ServerResponse<Proto.Response>> | undefined;
let result: Promise<ServerResponse.Response<Proto.Response>> | undefined;
if (executeInfo.expectsResult) {
result = new Promise<ServerResponse<Proto.Response>>((resolve, reject) => {
result = new Promise<ServerResponse.Response<Proto.Response>>((resolve, reject) => {
this._callbacks.add(request.seq, { onSuccess: resolve, onError: reject, startTime: Date.now(), isAsync: executeInfo.isAsync }, executeInfo.isAsync);
if (executeInfo.token) {

27
extensions/typescript-language-features/src/typescriptService.ts
View File

@@ -11,19 +11,22 @@ import { TypeScriptServiceConfiguration } from './utils/configuration';
import Logger from './utils/logger';
import { PluginManager } from './utils/plugins';
export class CancelledResponse {
public readonly type: 'cancelled' = 'cancelled';
export namespace ServerResponse {
constructor(
public readonly reason: string
) { }
export class Cancelled {
public readonly type = 'cancelled';
constructor(
public readonly reason: string
) { }
}
export const NoContent = new class { readonly type = 'noContent'; };
export const LanguageServiceDisabled = new class { readonly type = 'languageServiceDisabled'; };
export type Response<T extends Proto.Response> = T | Cancelled | typeof NoContent | typeof LanguageServiceDisabled;
}
export const NoContentResponse = new class { readonly type = 'noContent'; };
export const LanguageServiceDisabledContentResponse = new class { readonly type = 'languageServiceDisabled'; };
export type ServerResponse<T extends Proto.Response> = T | CancelledResponse | typeof NoContentResponse | typeof LanguageServiceDisabledContentResponse;
export interface TypeScriptRequestTypes {
'applyCodeActionCommand': [Proto.ApplyCodeActionCommandRequestArgs, Proto.ApplyCodeActionCommandResponse];
'completionEntryDetails': [Proto.CompletionDetailsRequestArgs, Proto.CompletionDetailsResponse];
@@ -103,7 +106,7 @@ export interface ITypeScriptServiceClient {
args: TypeScriptRequestTypes[K][0],
token: vscode.CancellationToken,
lowPriority?: boolean
): Promise<ServerResponse<TypeScriptRequestTypes[K][1]>>;
): Promise<ServerResponse.Response<TypeScriptRequestTypes[K][1]>>;
executeWithoutWaitingForResponse(command: 'open', args: Proto.OpenRequestArgs): void;
executeWithoutWaitingForResponse(command: 'close', args: Proto.FileRequestArgs): void;
@@ -111,7 +114,7 @@ export interface ITypeScriptServiceClient {
executeWithoutWaitingForResponse(command: 'compilerOptionsForInferredProjects', args: Proto.SetCompilerOptionsForInferredProjectsArgs): void;
executeWithoutWaitingForResponse(command: 'reloadProjects', args: null): void;
executeAsync(command: 'geterr', args: Proto.GeterrRequestArgs, token: vscode.CancellationToken): Promise<ServerResponse<Proto.Response>>;
executeAsync(command: 'geterr', args: Proto.GeterrRequestArgs, token: vscode.CancellationToken): Promise<ServerResponse.Response<Proto.Response>>;
/**
* Cancel on going geterr requests and re-queue them after `f` has been evaluated.

12
extensions/typescript-language-features/src/typescriptServiceClient.ts
View File

@@ -11,7 +11,7 @@ import BufferSyncSupport from './features/bufferSyncSupport';
import { DiagnosticKind, DiagnosticsManager } from './features/diagnostics';
import * as Proto from './protocol';
import { TypeScriptServer, TypeScriptServerSpawner } from './tsServer/server';
import { ITypeScriptServiceClient, ServerResponse, LanguageServiceDisabledContentResponse } from './typescriptService';
import { ITypeScriptServiceClient, ServerResponse } from './typescriptService';
import API from './utils/api';
import { TsServerLogLevel, TypeScriptServiceConfiguration } from './utils/configuration';
import { Disposable } from './utils/dispose';
@@ -590,7 +590,7 @@ export default class TypeScriptServiceClient extends Disposable implements IType
return undefined;
}
public execute(command: string, args: any, token: vscode.CancellationToken, lowPriority?: boolean): Promise<ServerResponse<Proto.Response>> {
public execute(command: string, args: any, token: vscode.CancellationToken, lowPriority?: boolean): Promise<ServerResponse.Response<Proto.Response>> {
return this.executeImpl(command, args, {
isAsync: false,
token,
@@ -607,7 +607,7 @@ export default class TypeScriptServiceClient extends Disposable implements IType
});
}
public executeAsync(command: string, args: Proto.GeterrRequestArgs, token: vscode.CancellationToken): Promise<ServerResponse<Proto.Response>> {
public executeAsync(command: string, args: Proto.GeterrRequestArgs, token: vscode.CancellationToken): Promise<ServerResponse.Response<Proto.Response>> {
return this.executeImpl(command, args, {
isAsync: true,
token,
@@ -616,8 +616,8 @@ export default class TypeScriptServiceClient extends Disposable implements IType
}
private executeImpl(command: string, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: false, lowPriority?: boolean }): undefined;
private executeImpl(command: string, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse<Proto.Response>>;
private executeImpl(command: string, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse<Proto.Response>> | undefined {
private executeImpl(command: string, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>>;
private executeImpl(command: string, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>> | undefined {
const runningServerState = this.service();
if (!runningServerState.langaugeServiceEnabled) {
@@ -634,7 +634,7 @@ export default class TypeScriptServiceClient extends Disposable implements IType
'reloadProjects',
];
if (nonSemanticCommands.indexOf(command) === -1) {
return Promise.resolve(LanguageServiceDisabledContentResponse);
return Promise.resolve(ServerResponse.LanguageServiceDisabled);
}
}