maxmustermann/vscode
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Work towards allowing enhanced syntax server commands to be run against any file

Browse source 
We currently restrict the TS server to working with a small set of file schemes. This is done because the TS server itself cannot read files from on of VS Code's virtual file system providers (and will crash if it tries to do so)

However we can enable single file commands for these other file schemes, so long as they are treated as in-memory files. This change works towards supporting that by changing when certain providers are enabled/disabled
This commit is contained in:
Matt Bierner 2020-07-20 16:08:06 -07:00
parent 8bf2ae16a0
commit e41c195051
34 changed files with 276 additions and 158 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
extensions/typescript-language-features/src/features/callHierarchy.ts
View file

@ -7,9 +7,10 @@ import * as path from 'path';
import * as vscode from 'vscode';
import type * as Proto from '../protocol';
import * as PConst from '../protocol.const';
import { ITypeScriptServiceClient } from '../typescriptService';
import { ClientCapability, ITypeScriptServiceClient } from '../typescriptService';
import API from '../utils/api';
import { conditionalRegistration, requireMinVersion } from '../utils/dependentRegistration';
import { conditionalRegistration, requireSomeCapability, requireMinVersion } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import { parseKindModifier } from '../utils/modifiers';
import * as typeConverters from '../utils/typeConverters';
@ -117,13 +118,14 @@ function fromProtocolCallHierchyOutgoingCall(item: Proto.CallHierarchyOutgoingCa
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient
) {
return conditionalRegistration([
requireMinVersion(client, TypeScriptCallHierarchySupport.minVersion),
requireSomeCapability(client, ClientCapability.EnhancedSyntax, ClientCapability.Semantic),
], () => {
return vscode.languages.registerCallHierarchyProvider(selector,
return vscode.languages.registerCallHierarchyProvider(selector.syntax,
new TypeScriptCallHierarchySupport(client));
});
}

10
extensions/typescript-language-features/src/features/completions.ts
View file

@ -7,12 +7,13 @@ import * as vscode from 'vscode';
import * as nls from 'vscode-nls';
import type * as Proto from '../protocol';
import * as PConst from '../protocol.const';
import { ITypeScriptServiceClient, ServerResponse } from '../typescriptService';
import { ClientCapability, ITypeScriptServiceClient, ServerResponse } from '../typescriptService';
import API from '../utils/api';
import { nulToken } from '../utils/cancellation';
import { applyCodeAction } from '../utils/codeAction';
import { Command, CommandManager } from '../utils/commandManager';
import { conditionalRegistration, requireConfiguration } from '../utils/dependentRegistration';
import { conditionalRegistration, requireSomeCapability, requireConfiguration } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import { parseKindModifier } from '../utils/modifiers';
import * as Previewer from '../utils/previewer';
import { snippetForFunctionCall } from '../utils/snippetForFunctionCall';
@ -795,7 +796,7 @@ function shouldExcludeCompletionEntry(
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
modeId: string,
client: ITypeScriptServiceClient,
typingsStatus: TypingsStatus,
@ -806,8 +807,9 @@ export function register(
) {
return conditionalRegistration([
requireConfiguration(modeId, 'suggest.enabled'),
requireSomeCapability(client, ClientCapability.EnhancedSyntax, ClientCapability.Semantic),
], () => {
return vscode.languages.registerCompletionItemProvider(selector,
return vscode.languages.registerCompletionItemProvider(selector.syntax,
new TypeScriptCompletionItemProvider(client, modeId, typingsStatus, fileConfigurationManager, commandManager, telemetryReporter, onCompletionAccepted),
...TypeScriptCompletionItemProvider.triggerCharacters);
});

14
extensions/typescript-language-features/src/features/definitions.ts
View file

@ -4,8 +4,10 @@
*--------------------------------------------------------------------------------------------*/
import * as vscode from 'vscode';
import { ITypeScriptServiceClient } from '../typescriptService';
import { ClientCapability, ITypeScriptServiceClient } from '../typescriptService';
import API from '../utils/api';
import { conditionalRegistration, requireSomeCapability } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import * as typeConverters from '../utils/typeConverters';
import DefinitionProviderBase from './definitionProviderBase';
@ -58,9 +60,13 @@ export default class TypeScriptDefinitionProvider extends DefinitionProviderBase
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient,
) {
return vscode.languages.registerDefinitionProvider(selector,
new TypeScriptDefinitionProvider(client));
return conditionalRegistration([
requireSomeCapability(client, ClientCapability.EnhancedSyntax, ClientCapability.Semantic),
], () => {
return vscode.languages.registerDefinitionProvider(selector.syntax,
new TypeScriptDefinitionProvider(client));
});
}

5
extensions/typescript-language-features/src/features/directiveCommentCompletions.ts
View file

@ -7,6 +7,7 @@ import * as vscode from 'vscode';
import * as nls from 'vscode-nls';
import { ITypeScriptServiceClient } from '../typescriptService';
import API from '../utils/api';
import { DocumentSelector } from '../utils/documentSelector';
const localize = nls.loadMessageBundle();
@ -80,10 +81,10 @@ class DirectiveCommentCompletionProvider implements vscode.CompletionItemProvide
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient,
) {
return vscode.languages.registerCompletionItemProvider(selector,
return vscode.languages.registerCompletionItemProvider(selector.syntax,
new DirectiveCommentCompletionProvider(client),
'@');
}

5
extensions/typescript-language-features/src/features/documentHighlight.ts
View file

@ -7,6 +7,7 @@ import * as vscode from 'vscode';
import type * as Proto from '../protocol';
import { ITypeScriptServiceClient } from '../typescriptService';
import { flatten } from '../utils/arrays';
import { DocumentSelector } from '../utils/documentSelector';
import * as typeConverters from '../utils/typeConverters';
class TypeScriptDocumentHighlightProvider implements vscode.DocumentHighlightProvider {
@ -48,9 +49,9 @@ function convertDocumentHighlight(highlight: Proto.DocumentHighlightsItem): Read
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient,
) {
return vscode.languages.registerDocumentHighlightProvider(selector,
return vscode.languages.registerDocumentHighlightProvider(selector.syntax,
new TypeScriptDocumentHighlightProvider(client));
}

9
extensions/typescript-language-features/src/features/documentSymbol.ts
View file

@ -6,10 +6,11 @@
import * as vscode from 'vscode';
import type * as Proto from '../protocol';
import * as PConst from '../protocol.const';
import { ITypeScriptServiceClient } from '../typescriptService';
import * as typeConverters from '../utils/typeConverters';
import { CachedResponse } from '../tsServer/cachedResponse';
import { ITypeScriptServiceClient } from '../typescriptService';
import { DocumentSelector } from '../utils/documentSelector';
import { parseKindModifier } from '../utils/modifiers';
import * as typeConverters from '../utils/typeConverters';
const getSymbolKind = (kind: string): vscode.SymbolKind => {
switch (kind) {
@ -111,10 +112,10 @@ class TypeScriptDocumentSymbolProvider implements vscode.DocumentSymbolProvider
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient,
cachedResponse: CachedResponse<Proto.NavTreeResponse>,
) {
return vscode.languages.registerDocumentSymbolProvider(selector,
return vscode.languages.registerDocumentSymbolProvider(selector.syntax,
new TypeScriptDocumentSymbolProvider(client, cachedResponse), { label: 'TypeScript' });
}

12
extensions/typescript-language-features/src/features/fixAll.ts
View file

@ -6,9 +6,10 @@
import * as vscode from 'vscode';
import * as nls from 'vscode-nls';
import type * as Proto from '../protocol';
import { ITypeScriptServiceClient } from '../typescriptService';
import { ClientCapability, ITypeScriptServiceClient } from '../typescriptService';
import API from '../utils/api';
import { conditionalRegistration, requireMinVersion } from '../utils/dependentRegistration';
import { conditionalRegistration, requireSomeCapability, requireMinVersion } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import * as errorCodes from '../utils/errorCodes';
import * as fixNames from '../utils/fixNames';
import * as typeConverters from '../utils/typeConverters';
@ -249,15 +250,16 @@ class TypeScriptAutoFixProvider implements vscode.CodeActionProvider {
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient,
fileConfigurationManager: FileConfigurationManager,
diagnosticsManager: DiagnosticsManager,
) {
return conditionalRegistration([
requireMinVersion(client, API.v300)
requireMinVersion(client, API.v300),
requireSomeCapability(client, ClientCapability.Semantic),
], () => {
const provider = new TypeScriptAutoFixProvider(client, fileConfigurationManager, diagnosticsManager);
return vscode.languages.registerCodeActionsProvider(selector, provider, provider.metadata);
return vscode.languages.registerCodeActionsProvider(selector.semantic, provider, provider.metadata);
});
}

5
extensions/typescript-language-features/src/features/folding.ts
View file

@ -9,6 +9,7 @@ import { ITypeScriptServiceClient } from '../typescriptService';
import API from '../utils/api';
import { coalesce } from '../utils/arrays';
import { conditionalRegistration, requireMinVersion } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import * as typeConverters from '../utils/typeConverters';
class TypeScriptFoldingProvider implements vscode.FoldingRangeProvider {
@ -73,13 +74,13 @@ class TypeScriptFoldingProvider implements vscode.FoldingRangeProvider {
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient,
): vscode.Disposable {
return conditionalRegistration([
requireMinVersion(client, TypeScriptFoldingProvider.minVersion),
], () => {
return vscode.languages.registerFoldingRangeProvider(selector,
return vscode.languages.registerFoldingRangeProvider(selector.syntax,
new TypeScriptFoldingProvider(client));
});
}

7
extensions/typescript-language-features/src/features/formatting.ts
View file

@ -7,6 +7,7 @@ import * as vscode from 'vscode';
import type * as Proto from '../protocol';
import { ITypeScriptServiceClient } from '../typescriptService';
import { conditionalRegistration, requireConfiguration } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import * as typeConverters from '../utils/typeConverters';
import FileConfigurationManager from './fileConfigurationManager';
@ -84,7 +85,7 @@ class TypeScriptFormattingProvider implements vscode.DocumentRangeFormattingEdit
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
modeId: string,
client: ITypeScriptServiceClient,
fileConfigurationManager: FileConfigurationManager
@ -94,8 +95,8 @@ export function register(
], () => {
const formattingProvider = new TypeScriptFormattingProvider(client, fileConfigurationManager);
return vscode.Disposable.from(
vscode.languages.registerOnTypeFormattingEditProvider(selector, formattingProvider, ';', '}', '\n'),
vscode.languages.registerDocumentRangeFormattingEditProvider(selector, formattingProvider),
vscode.languages.registerOnTypeFormattingEditProvider(selector.syntax, formattingProvider, ';', '}', '\n'),
vscode.languages.registerDocumentRangeFormattingEditProvider(selector.syntax, formattingProvider),
);
});
}

14
extensions/typescript-language-features/src/features/hover.ts
View file

@ -5,7 +5,9 @@
import * as vscode from 'vscode';
import type * as Proto from '../protocol';
import { ITypeScriptServiceClient } from '../typescriptService';
import { ClientCapability, ITypeScriptServiceClient } from '../typescriptService';
import { conditionalRegistration, requireSomeCapability } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import { markdownDocumentation } from '../utils/previewer';
import * as typeConverters from '../utils/typeConverters';
@ -51,9 +53,13 @@ class TypeScriptHoverProvider implements vscode.HoverProvider {
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient
): vscode.Disposable {
return vscode.languages.registerHoverProvider(selector,
new TypeScriptHoverProvider(client));
return conditionalRegistration([
requireSomeCapability(client, ClientCapability.EnhancedSyntax, ClientCapability.Semantic),
], () => {
return vscode.languages.registerHoverProvider(selector.syntax,
new TypeScriptHoverProvider(client));
});
}

14
extensions/typescript-language-features/src/features/implementations.ts
View file

@ -4,7 +4,9 @@
*--------------------------------------------------------------------------------------------*/
import * as vscode from 'vscode';
import { ITypeScriptServiceClient } from '../typescriptService';
import { ClientCapability, ITypeScriptServiceClient } from '../typescriptService';
import { conditionalRegistration, requireSomeCapability } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import DefinitionProviderBase from './definitionProviderBase';
class TypeScriptImplementationProvider extends DefinitionProviderBase implements vscode.ImplementationProvider {
@ -14,9 +16,13 @@ class TypeScriptImplementationProvider extends DefinitionProviderBase implements
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient,
) {
return vscode.languages.registerImplementationProvider(selector,
new TypeScriptImplementationProvider(client));
return conditionalRegistration([
requireSomeCapability(client, ClientCapability.Semantic),
], () => {
return vscode.languages.registerImplementationProvider(selector.semantic,
new TypeScriptImplementationProvider(client));
});
}

9
extensions/typescript-language-features/src/features/implementationsCodeLens.ts
View file

@ -9,7 +9,8 @@ import type * as Proto from '../protocol';
import * as PConst from '../protocol.const';
import { CachedResponse } from '../tsServer/cachedResponse';
import { ClientCapability, ITypeScriptServiceClient } from '../typescriptService';
import { conditionalRegistration, requireCapability, requireConfiguration } from '../utils/dependentRegistration';
import { conditionalRegistration, requireSomeCapability, requireConfiguration } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import * as typeConverters from '../utils/typeConverters';
import { getSymbolRange, ReferencesCodeLens, TypeScriptBaseCodeLensProvider } from './baseCodeLensProvider';
@ -89,16 +90,16 @@ export default class TypeScriptImplementationsCodeLensProvider extends TypeScrip
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
modeId: string,
client: ITypeScriptServiceClient,
cachedResponse: CachedResponse<Proto.NavTreeResponse>,
) {
return conditionalRegistration([
requireConfiguration(modeId, 'implementationsCodeLens.enabled'),
requireCapability(client, ClientCapability.Semantic),
requireSomeCapability(client, ClientCapability.Semantic),
], () => {
return vscode.languages.registerCodeLensProvider(selector,
return vscode.languages.registerCodeLensProvider(selector.semantic,
new TypeScriptImplementationsCodeLensProvider(client, cachedResponse));
});
}

5
extensions/typescript-language-features/src/features/jsDocCompletions.ts
View file

@ -7,6 +7,7 @@ import * as vscode from 'vscode';
import * as nls from 'vscode-nls';
import { ITypeScriptServiceClient } from '../typescriptService';
import { conditionalRegistration, requireConfiguration } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import * as typeConverters from '../utils/typeConverters';
@ -110,14 +111,14 @@ export function templateToSnippet(template: string): vscode.SnippetString {
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
modeId: string,
client: ITypeScriptServiceClient,
): vscode.Disposable {
return conditionalRegistration([
requireConfiguration(modeId, 'suggest.completeJSDocs')
], () => {
return vscode.languages.registerCompletionItemProvider(selector,
return vscode.languages.registerCompletionItemProvider(selector.syntax,
new JsDocCompletionProvider(client),
'*');
});

5
extensions/typescript-language-features/src/features/organizeImports.ts
View file

@ -11,6 +11,7 @@ import API from '../utils/api';
import { nulToken } from '../utils/cancellation';
import { Command, CommandManager } from '../utils/commandManager';
import { conditionalRegistration, requireMinVersion } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import { TelemetryReporter } from '../utils/telemetry';
import * as typeconverts from '../utils/typeConverters';
import FileConfigurationManager from './fileConfigurationManager';
@ -99,7 +100,7 @@ export class OrganizeImportsCodeActionProvider implements vscode.CodeActionProvi
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient,
commandManager: CommandManager,
fileConfigurationManager: FileConfigurationManager,
@ -109,7 +110,7 @@ export function register(
requireMinVersion(client, OrganizeImportsCodeActionProvider.minVersion)
], () => {
const organizeImportsProvider = new OrganizeImportsCodeActionProvider(client, commandManager, fileConfigurationManager, telemetryReporter);
return vscode.languages.registerCodeActionsProvider(selector,
return vscode.languages.registerCodeActionsProvider(selector.syntax,
organizeImportsProvider,
organizeImportsProvider.metadata);
});

9
extensions/typescript-language-features/src/features/quickFix.ts
View file

@ -18,7 +18,8 @@ import * as typeConverters from '../utils/typeConverters';
import { DiagnosticsManager } from './diagnostics';
import FileConfigurationManager from './fileConfigurationManager';
import { equals } from '../utils/objects';
import { conditionalRegistration, requireCapability } from '../utils/dependentRegistration';
import { conditionalRegistration, requireSomeCapability } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
const localize = nls.loadMessageBundle();
@ -403,7 +404,7 @@ function isPreferredFix(
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient,
fileConfigurationManager: FileConfigurationManager,
commandManager: CommandManager,
@ -411,9 +412,9 @@ export function register(
telemetryReporter: TelemetryReporter
) {
return conditionalRegistration([
requireCapability(client, ClientCapability.Semantic),
requireSomeCapability(client, ClientCapability.Semantic),
], () => {
return vscode.languages.registerCodeActionsProvider(selector,
return vscode.languages.registerCodeActionsProvider(selector.semantic,
new TypeScriptQuickFixProvider(client, fileConfigurationManager, commandManager, diagnosticsManager, telemetryReporter),
TypeScriptQuickFixProvider.metadata);
});

9
extensions/typescript-language-features/src/features/refactor.ts
View file

@ -11,7 +11,8 @@ import { ClientCapability, ITypeScriptServiceClient } from '../typescriptService
import API from '../utils/api';
import { nulToken } from '../utils/cancellation';
import { Command, CommandManager } from '../utils/commandManager';
import { conditionalRegistration, requireCapability, requireMinVersion } from '../utils/dependentRegistration';
import { conditionalRegistration, requireSomeCapability, requireMinVersion } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import * as fileSchemes from '../utils/fileSchemes';
import { TelemetryReporter } from '../utils/telemetry';
import * as typeConverters from '../utils/typeConverters';
@ -396,7 +397,7 @@ class TypeScriptRefactorProvider implements vscode.CodeActionProvider {
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient,
formattingOptionsManager: FormattingOptionsManager,
commandManager: CommandManager,
@ -404,9 +405,9 @@ export function register(
) {
return conditionalRegistration([
requireMinVersion(client, TypeScriptRefactorProvider.minVersion),
requireCapability(client, ClientCapability.Semantic),
requireSomeCapability(client, ClientCapability.Semantic),
], () => {
return vscode.languages.registerCodeActionsProvider(selector,
return vscode.languages.registerCodeActionsProvider(selector.semantic,
new TypeScriptRefactorProvider(client, formattingOptionsManager, commandManager, telemetryReporter),
TypeScriptRefactorProvider.metadata);
});

14
extensions/typescript-language-features/src/features/references.ts
View file

@ -4,7 +4,9 @@
*--------------------------------------------------------------------------------------------*/
import * as vscode from 'vscode';
import { ITypeScriptServiceClient } from '../typescriptService';
import { ClientCapability, ITypeScriptServiceClient } from '../typescriptService';
import { conditionalRegistration, requireSomeCapability } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import * as typeConverters from '../utils/typeConverters';
class TypeScriptReferenceSupport implements vscode.ReferenceProvider {
@ -42,9 +44,13 @@ class TypeScriptReferenceSupport implements vscode.ReferenceProvider {
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient
) {
return vscode.languages.registerReferenceProvider(selector,
new TypeScriptReferenceSupport(client));
return conditionalRegistration([
requireSomeCapability(client, ClientCapability.EnhancedSyntax, ClientCapability.Semantic),
], () => {
return vscode.languages.registerReferenceProvider(selector.syntax,
new TypeScriptReferenceSupport(client));
});
}

18
extensions/typescript-language-features/src/features/referencesCodeLens.ts
View file

@ -8,8 +8,10 @@ import * as nls from 'vscode-nls';
import type * as Proto from '../protocol';
import * as PConst from '../protocol.const';
import { CachedResponse } from '../tsServer/cachedResponse';
import { ITypeScriptServiceClient, ClientCapability } from '../typescriptService';
import { conditionalRegistration, requireConfiguration, requireCapability } from '../utils/dependentRegistration';
import { ExectuionTarget } from '../tsServer/server';
import { ClientCapability, ITypeScriptServiceClient } from '../typescriptService';
import { conditionalRegistration, requireConfiguration, requireSomeCapability } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import * as typeConverters from '../utils/typeConverters';
import { getSymbolRange, ReferencesCodeLens, TypeScriptBaseCodeLensProvider } from './baseCodeLensProvider';
@ -27,7 +29,11 @@ export class TypeScriptReferencesCodeLensProvider extends TypeScriptBaseCodeLens
public async resolveCodeLens(inputCodeLens: vscode.CodeLens, token: vscode.CancellationToken): Promise<vscode.CodeLens> {
const codeLens = inputCodeLens as ReferencesCodeLens;
const args = typeConverters.Position.toFileLocationRequestArgs(codeLens.file, codeLens.range.start);
const response = await this.client.execute('references', args, token, { lowPriority: true, cancelOnResourceChange: codeLens.document });
const response = await this.client.execute('references', args, token, {
lowPriority: true,
executionTarget: ExectuionTarget.Semantic,
cancelOnResourceChange: codeLens.document,
});
if (response.type !== 'response' || !response.body) {
codeLens.command = response.type === 'cancelled'
? TypeScriptBaseCodeLensProvider.cancelledCommand
@ -122,16 +128,16 @@ export class TypeScriptReferencesCodeLensProvider extends TypeScriptBaseCodeLens
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
modeId: string,
client: ITypeScriptServiceClient,
cachedResponse: CachedResponse<Proto.NavTreeResponse>,
) {
return conditionalRegistration([
requireConfiguration(modeId, 'referencesCodeLens.enabled'),
requireCapability(client, ClientCapability.Semantic),
requireSomeCapability(client, ClientCapability.Semantic),
], () => {
return vscode.languages.registerCodeLensProvider(selector,
return vscode.languages.registerCodeLensProvider(selector.semantic,
new TypeScriptReferencesCodeLensProvider(client, cachedResponse, modeId));
});
}

9
extensions/typescript-language-features/src/features/rename.ts
View file

@ -9,7 +9,8 @@ import * as nls from 'vscode-nls';
import type * as Proto from '../protocol';
import { ClientCapability, ITypeScriptServiceClient, ServerResponse } from '../typescriptService';
import API from '../utils/api';
import { conditionalRegistration, requireCapability } from '../utils/dependentRegistration';
import { conditionalRegistration, requireSomeCapability } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import * as typeConverters from '../utils/typeConverters';
import FileConfigurationManager from './fileConfigurationManager';
@ -138,14 +139,14 @@ class TypeScriptRenameProvider implements vscode.RenameProvider {
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient,
fileConfigurationManager: FileConfigurationManager,
) {
return conditionalRegistration([
requireCapability(client, ClientCapability.Semantic),
requireSomeCapability(client, ClientCapability.Semantic),
], () => {
return vscode.languages.registerRenameProvider(selector,
return vscode.languages.registerRenameProvider(selector.semantic,
new TypeScriptRenameProvider(client, fileConfigurationManager));
});
}

12
extensions/typescript-language-features/src/features/semanticTokens.ts
View file

@ -9,7 +9,8 @@ import * as vscode from 'vscode';
import * as Proto from '../protocol';
import { ClientCapability, ExecConfig, ITypeScriptServiceClient, ServerResponse } from '../typescriptService';
import API from '../utils/api';
import { conditionalRegistration, requireCapability, requireMinVersion } from '../utils/dependentRegistration';
import { conditionalRegistration, requireSomeCapability, requireMinVersion } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
const minTypeScriptVersion = API.fromVersionString(`${VersionRequirement.major}.${VersionRequirement.minor}`);
@ -17,15 +18,18 @@ const minTypeScriptVersion = API.fromVersionString(`${VersionRequirement.major}.
// as we don't do deltas, for performance reasons, don't compute semantic tokens for documents above that limit
const CONTENT_LENGTH_LIMIT = 100000;
export function register(selector: vscode.DocumentSelector, client: ITypeScriptServiceClient) {
export function register(
selector: DocumentSelector,
client: ITypeScriptServiceClient,
) {
return conditionalRegistration([
requireMinVersion(client, minTypeScriptVersion),
requireCapability(client, ClientCapability.Semantic),
requireSomeCapability(client, ClientCapability.Semantic),
], () => {
const provider = new DocumentSemanticTokensProvider(client);
return vscode.Disposable.from(
// register only as a range provider
vscode.languages.registerDocumentRangeSemanticTokensProvider(selector, provider, provider.getLegend()),
vscode.languages.registerDocumentRangeSemanticTokensProvider(selector.semantic, provider, provider.getLegend()),
);
});
}

18
extensions/typescript-language-features/src/features/signatureHelp.ts
View file

@ -5,7 +5,9 @@
import * as vscode from 'vscode';
import type * as Proto from '../protocol';
import { ITypeScriptServiceClient } from '../typescriptService';
import { ClientCapability, ITypeScriptServiceClient } from '../typescriptService';
import { conditionalRegistration, requireSomeCapability } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import * as Previewer from '../utils/previewer';
import * as typeConverters from '../utils/typeConverters';
@ -120,12 +122,16 @@ function toTsTriggerReason(context: vscode.SignatureHelpContext): Proto.Signatur
}
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient,
) {
return vscode.languages.registerSignatureHelpProvider(selector,
new TypeScriptSignatureHelpProvider(client), {
triggerCharacters: TypeScriptSignatureHelpProvider.triggerCharacters,
retriggerCharacters: TypeScriptSignatureHelpProvider.retriggerCharacters
return conditionalRegistration([
requireSomeCapability(client, ClientCapability.EnhancedSyntax, ClientCapability.Semantic),
], () => {
return vscode.languages.registerSignatureHelpProvider(selector.syntax,
new TypeScriptSignatureHelpProvider(client), {
triggerCharacters: TypeScriptSignatureHelpProvider.triggerCharacters,
retriggerCharacters: TypeScriptSignatureHelpProvider.retriggerCharacters
});
});
}

5
extensions/typescript-language-features/src/features/smartSelect.ts
View file

@ -8,6 +8,7 @@ import type * as Proto from '../protocol';
import { ITypeScriptServiceClient } from '../typescriptService';
import API from '../utils/api';
import { conditionalRegistration, requireMinVersion } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import * as typeConverters from '../utils/typeConverters';
class SmartSelection implements vscode.SelectionRangeProvider {
@ -49,12 +50,12 @@ class SmartSelection implements vscode.SelectionRangeProvider {
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient,
) {
return conditionalRegistration([
requireMinVersion(client, SmartSelection.minVersion),
], () => {
return vscode.languages.registerSelectionRangeProvider(selector, new SmartSelection(client));
return vscode.languages.registerSelectionRangeProvider(selector.syntax, new SmartSelection(client));
});
}

5
extensions/typescript-language-features/src/features/tagClosing.ts
View file

@ -9,6 +9,7 @@ import { ITypeScriptServiceClient } from '../typescriptService';
import API from '../utils/api';
import { conditionalRegistration, requireMinVersion, requireConfiguration, Condition } from '../utils/dependentRegistration';
import { Disposable } from '../utils/dispose';
import { DocumentSelector } from '../utils/documentSelector';
import * as typeConverters from '../utils/typeConverters';
class TagClosing extends Disposable {
@ -151,13 +152,13 @@ function requireActiveDocument(
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
modeId: string,
client: ITypeScriptServiceClient,
) {
return conditionalRegistration([
requireMinVersion(client, TagClosing.minVersion),
requireConfiguration(modeId, 'autoClosingTags'),
requireActiveDocument(selector)
requireActiveDocument(selector.syntax)
], () => new TagClosing(client));
}

14
extensions/typescript-language-features/src/features/typeDefinitions.ts
View file

@ -4,7 +4,9 @@
*--------------------------------------------------------------------------------------------*/
import * as vscode from 'vscode';
import { ITypeScriptServiceClient } from '../typescriptService';
import { ClientCapability, ITypeScriptServiceClient } from '../typescriptService';
import { conditionalRegistration, requireSomeCapability } from '../utils/dependentRegistration';
import { DocumentSelector } from '../utils/documentSelector';
import DefinitionProviderBase from './definitionProviderBase';
export default class TypeScriptTypeDefinitionProvider extends DefinitionProviderBase implements vscode.TypeDefinitionProvider {
@ -14,9 +16,13 @@ export default class TypeScriptTypeDefinitionProvider extends DefinitionProvider
}
export function register(
selector: vscode.DocumentSelector,
selector: DocumentSelector,
client: ITypeScriptServiceClient,
) {
return vscode.languages.registerTypeDefinitionProvider(selector,
new TypeScriptTypeDefinitionProvider(client));
return conditionalRegistration([
requireSomeCapability(client, ClientCapability.EnhancedSyntax, ClientCapability.Semantic),
], () => {
return vscode.languages.registerTypeDefinitionProvider(selector.syntax,
new TypeScriptTypeDefinitionProvider(client));
});
}

4
extensions/typescript-language-features/src/features/updatePathsOnRename.ts
View file

@ -11,7 +11,7 @@ import { ClientCapability, ITypeScriptServiceClient } from '../typescriptService
import API from '../utils/api';
import { Delayer } from '../utils/async';
import { nulToken } from '../utils/cancellation';
import { conditionalRegistration, requireCapability, requireMinVersion } from '../utils/dependentRegistration';
import { conditionalRegistration, requireSomeCapability, requireMinVersion } from '../utils/dependentRegistration';
import { Disposable } from '../utils/dispose';
import * as fileSchemes from '../utils/fileSchemes';
import { doesResourceLookLikeATypeScriptFile } from '../utils/languageDescription';
@ -296,7 +296,7 @@ export function register(
) {
return conditionalRegistration([
requireMinVersion(client, UpdateImportsOnFileRenameHandler.minVersion),
requireCapability(client, ClientCapability.Semantic),
requireSomeCapability(client, ClientCapability.Semantic),
], () => {
return new UpdateImportsOnFileRenameHandler(client, fileConfigurationManager, handles);
});

24
extensions/typescript-language-features/src/languageProvider.ts
View file

@ -5,15 +5,16 @@
import { basename } from 'path';
import * as vscode from 'vscode';
import { CachedResponse } from './tsServer/cachedResponse';
import { DiagnosticKind } from './features/diagnostics';
import FileConfigurationManager from './features/fileConfigurationManager';
import { CachedResponse } from './tsServer/cachedResponse';
import { ClientCapability } from './typescriptService';
import TypeScriptServiceClient from './typescriptServiceClient';
import { CommandManager } from './utils/commandManager';
import { Disposable } from './utils/dispose';
import { DocumentSelector } from './utils/documentSelector';
import * as fileSchemes from './utils/fileSchemes';
import { LanguageDescription } from './utils/languageDescription';
import { memoize } from './utils/memoize';
import { TelemetryReporter } from './utils/telemetry';
import TypingsStatus from './utils/typingsStatus';
@ -39,15 +40,22 @@ export default class LanguageProvider extends Disposable {
client.onReady(() => this.registerProviders());
}
@memoize
private get documentSelector(): vscode.DocumentFilter[] {
const documentSelector = [];
private get documentSelector(): DocumentSelector {
const semantic: vscode.DocumentFilter[] = [];
const syntax: vscode.DocumentFilter[] = [];
for (const language of this.description.modeIds) {
for (const scheme of fileSchemes.supportedSchemes) {
documentSelector.push({ language, scheme });
syntax.push({ language });
for (const scheme of fileSchemes.semanticSupportedSchemes) {
semantic.push({ language, scheme });
}
}
return documentSelector;
if (this.client.capabilities.has(ClientCapability.EnhancedSyntax)) {
return { semantic, syntax };
}
// If we don't have a
return { semantic, syntax: semantic };
}
private async registerProviders(): Promise<void> {

10
extensions/typescript-language-features/src/lazyClientHost.ts
View file

@ -5,14 +5,13 @@
import * as vscode from 'vscode';
import { OngoingRequestCancellerFactory } from './tsServer/cancellation';
import { ILogDirectoryProvider } from './tsServer/logDirectoryProvider';
import TypeScriptServiceClientHost from './typeScriptServiceClientHost';
import { flatten } from './utils/arrays';
import { CommandManager } from './utils/commandManager';
import * as fileSchemes from './utils/fileSchemes';
import { standardLanguageDescriptions } from './utils/languageDescription';
import * as ProjectStatus from './utils/largeProjectStatus';
import { lazy, Lazy } from './utils/lazy';
import { ILogDirectoryProvider } from './tsServer/logDirectoryProvider';
import ManagedFileContextManager from './utils/managedFileContext';
import { PluginManager } from './utils/plugins';
@ -87,11 +86,8 @@ export function lazilyActivateClient(
}
function isSupportedDocument(
supportedLanguage: string[],
supportedLanguage: readonly string[],
document: vscode.TextDocument
): boolean {
if (supportedLanguage.indexOf(document.languageId) < 0) {
return false;
}
return fileSchemes.isSupportedScheme(document.uri.scheme);
return supportedLanguage.indexOf(document.languageId) >= 0;
}

56
extensions/typescript-language-features/src/tsServer/server.ts
View file

@ -16,6 +16,10 @@ import { TelemetryReporter } from '../utils/telemetry';
import Tracer from '../utils/tracer';
import { TypeScriptVersion } from '../utils/versionProvider';
export enum ExectuionTarget {
Semantic,
Syntax
}
export interface ITypeScriptServer {
readonly onEvent: vscode.Event<Proto.Event>;
@ -26,9 +30,9 @@ export interface ITypeScriptServer {
kill(): void;
executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: false, lowPriority?: boolean }): undefined;
executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>>;
executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>> | undefined;
executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: false, lowPriority?: boolean, executionTarget?: ExectuionTarget }): undefined;
executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean, executionTarget?: ExectuionTarget }): Promise<ServerResponse.Response<Proto.Response>>;
executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean, executionTarget?: ExectuionTarget }): Promise<ServerResponse.Response<Proto.Response>> | undefined;
dispose(): void;
}
@ -172,9 +176,9 @@ export class ProcessBasedTsServer extends Disposable implements ITypeScriptServe
}
}
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: false, lowPriority?: boolean }): undefined;
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>>;
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>> | undefined {
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: false, lowPriority?: boolean, executionTarget?: ExectuionTarget }): undefined;
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean, executionTarget?: ExectuionTarget }): Promise<ServerResponse.Response<Proto.Response>>;
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean, executionTarget?: ExectuionTarget }): Promise<ServerResponse.Response<Proto.Response>> | undefined {
const request = this._requestQueue.createRequest(command, args);
const requestInfo: RequestItem = {
request,
@ -272,6 +276,14 @@ export class ProcessBasedTsServer extends Disposable implements ITypeScriptServe
}
interface ExecuteInfo {
readonly isAsync: boolean;
readonly token?: vscode.CancellationToken;
readonly expectsResult: boolean;
readonly lowPriority?: boolean;
readonly executionTarget?: ExectuionTarget;
}
class RequestRouter {
private static readonly sharedCommands = new Set<keyof TypeScriptRequests>([
@ -284,13 +296,16 @@ class RequestRouter {
]);
constructor(
private readonly servers: ReadonlyArray<{ readonly server: ITypeScriptServer, canRun?(command: keyof TypeScriptRequests): void }>,
private readonly servers: ReadonlyArray<{
readonly server: ITypeScriptServer;
canRun?(command: keyof TypeScriptRequests, executeInfo: ExecuteInfo): void;
}>,
private readonly delegate: TsServerDelegate,
) { }
public execute(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>> | undefined {
if (RequestRouter.sharedCommands.has(command)) {
// Dispatch shared commands to all server but only return from first one one
public execute(command: keyof TypeScriptRequests, args: any, executeInfo: ExecuteInfo): Promise<ServerResponse.Response<Proto.Response>> | undefined {
if (RequestRouter.sharedCommands.has(command) && typeof executeInfo.executionTarget === 'undefined') {
// Dispatch shared commands to all servers but only return from first one
const requestStates: RequestState.State[] = this.servers.map(() => RequestState.Unresolved);
@ -344,7 +359,7 @@ class RequestRouter {
}
for (const { canRun, server } of this.servers) {
if (!canRun || canRun(command)) {
if (!canRun || canRun(command, executeInfo)) {
return server.executeImpl(command, args, executeInfo);
}
}
@ -420,9 +435,9 @@ export class GetErrRoutingTsServer extends Disposable implements ITypeScriptServ
this.mainServer.kill();
}
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: false, lowPriority?: boolean }): undefined;
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>>;
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>> | undefined {
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: false, lowPriority?: boolean, executionTarget?: ExectuionTarget }): undefined;
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean, executionTarget?: ExectuionTarget }): Promise<ServerResponse.Response<Proto.Response>>;
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean, executionTarget?: ExectuionTarget }): Promise<ServerResponse.Response<Proto.Response>> | undefined {
return this.router.execute(command, args, executeInfo);
}
}
@ -490,7 +505,12 @@ export class SyntaxRoutingTsServer extends Disposable implements ITypeScriptServ
[
{
server: this.syntaxServer,
canRun: (command) => {
canRun: (command, execInfo) => {
switch (execInfo.executionTarget) {
case ExectuionTarget.Semantic: return false;
case ExectuionTarget.Syntax: return true;
}
if (SyntaxRoutingTsServer.syntaxAlwaysCommands.has(command)) {
return true;
}
@ -556,9 +576,9 @@ export class SyntaxRoutingTsServer extends Disposable implements ITypeScriptServ
this.semanticServer.kill();
}
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: false, lowPriority?: boolean }): undefined;
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>>;
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>> | undefined {
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: false, lowPriority?: boolean, executionTarget?: ExectuionTarget }): undefined;
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean, executionTarget?: ExectuionTarget }): Promise<ServerResponse.Response<Proto.Response>>;
public executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean, executionTarget?: ExectuionTarget }): Promise<ServerResponse.Response<Proto.Response>> | undefined {
return this.router.execute(command, args, executeInfo);
}
}

18
extensions/typescript-language-features/src/typescriptService.ts
View file

@ -6,6 +6,7 @@
import * as vscode from 'vscode';
import BufferSyncSupport from './features/bufferSyncSupport';
import * as Proto from './protocol';
import { ExectuionTarget } from './tsServer/server';
import API from './utils/api';
import { TypeScriptServiceConfiguration } from './utils/configuration';
import { PluginManager } from './utils/plugins';
@ -82,11 +83,24 @@ export type TypeScriptRequests = StandardTsServerRequests & NoResponseTsServerRe
export type ExecConfig = {
readonly lowPriority?: boolean;
readonly nonRecoverable?: boolean;
readonly cancelOnResourceChange?: vscode.Uri
readonly cancelOnResourceChange?: vscode.Uri;
readonly executionTarget?: ExectuionTarget;
};
export enum ClientCapability {
/**
* Basic syntax server. All clients should support this.
*/
Syntax,
/**
* Advanced syntax server that can provide single file IntelliSense.
*/
EnhancedSyntax,
/**
* Complete, multi-file semantic server
*/
Semantic,
}
@ -138,7 +152,7 @@ export interface ITypeScriptServiceClient {
readonly onTypesInstallerInitializationFailed: vscode.Event<Proto.TypesInstallerInitializationFailedEventBody>;
readonly capabilities: ClientCapabilities;
readonly onDidChangeCapabilities: vscode.Event<ClientCapabilities>;
readonly onDidChangeCapabilities: vscode.Event<void>;
onReady(f: () => void): Promise<void>;

53
extensions/typescript-language-features/src/typescriptServiceClient.ts
View file

@ -207,13 +207,18 @@ export default class TypeScriptServiceClient extends Disposable implements IType
}
public get capabilities() {
if (this.apiVersion.gte(API.v400)) {
return new ClientCapabilities(
ClientCapability.Syntax,
ClientCapability.EnhancedSyntax,
ClientCapability.Semantic);
}
return new ClientCapabilities(
ClientCapability.Semantic,
ClientCapability.Syntax,
);
ClientCapability.Semantic);
}
private readonly _onDidChangeCapabilities = this._register(new vscode.EventEmitter<ClientCapabilities>());
private readonly _onDidChangeCapabilities = this._register(new vscode.EventEmitter<void>());
readonly onDidChangeCapabilities = this._onDidChangeCapabilities.event;
private cancelInflightRequestsForResource(resource: vscode.Uri): void {
@ -437,7 +442,7 @@ export default class TypeScriptServiceClient extends Disposable implements IType
this._onReady!.resolve();
this._onTsServerStarted.fire({ version: version, usedApiVersion: apiVersion });
this._onDidChangeCapabilities.fire();
return this.serverState;
}
@ -608,27 +613,23 @@ export default class TypeScriptServiceClient extends Disposable implements IType
}
public normalizedPath(resource: vscode.Uri): string | undefined {
if (resource.scheme === fileSchemes.walkThroughSnippet || resource.scheme === fileSchemes.untitled) {
const dirName = path.dirname(resource.path);
const fileName = this.inMemoryResourcePrefix + path.basename(resource.path);
return resource.with({ path: path.posix.join(dirName, fileName), query: '' }).toString(true);
}
switch (resource.scheme) {
case fileSchemes.file:
{
let result = resource.fsPath;
if (!result) {
return undefined;
}
result = path.normalize(result);
if (resource.scheme !== fileSchemes.file) {
return undefined;
// Both \ and / must be escaped in regular expressions
return result.replace(new RegExp('\\' + this.pathSeparator, 'g'), '/');
}
default:
{
return this.inMemoryResourcePrefix + resource.toString(true);
}
}
let result = resource.fsPath;
if (!result) {
return undefined;
}
if (resource.scheme === fileSchemes.file) {
result = path.normalize(result);
}
// Both \ and / must be escaped in regular expressions
return result.replace(new RegExp('\\' + this.pathSeparator, 'g'), '/');
}
public toPath(resource: vscode.Uri): string | undefined {
@ -735,9 +736,9 @@ export default class TypeScriptServiceClient extends Disposable implements IType
});
}
private executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: false, lowPriority?: boolean }): undefined;
private executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>>;
private executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean }): Promise<ServerResponse.Response<Proto.Response>> | undefined {
private executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: false, lowPriority?: boolean, requireSemantic?: boolean }): undefined;
private executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean, requireSemantic?: boolean }): Promise<ServerResponse.Response<Proto.Response>>;
private executeImpl(command: keyof TypeScriptRequests, args: any, executeInfo: { isAsync: boolean, token?: vscode.CancellationToken, expectsResult: boolean, lowPriority?: boolean, requireSemantic?: boolean }): Promise<ServerResponse.Response<Proto.Response>> | undefined {
this.bufferSyncSupport.beforeCommand(command);
const runningServerState = this.service();
return runningServerState.server.executeImpl(command, args, executeInfo);

6
extensions/typescript-language-features/src/utils/dependentRegistration.ts
View file

@ -96,12 +96,12 @@ export function requireConfiguration(
);
}
export function requireCapability(
export function requireSomeCapability(
client: ITypeScriptServiceClient,
requiredCapability: ClientCapability,
...capabilities: readonly ClientCapability[]
) {
return new Condition(
() => client.capabilities.has(requiredCapability),
() => capabilities.some(requiredCapability => client.capabilities.has(requiredCapability)),
client.onDidChangeCapabilities
);
}

18
extensions/typescript-language-features/src/utils/documentSelector.ts Normal file
View file

@ -0,0 +1,18 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as vscode from 'vscode';
export interface DocumentSelector {
/**
* Selector for files which only require a basic syntax server.
*/
readonly syntax: vscode.DocumentFilter[];
/**
* Selector for files which require semantic server support.
*/
readonly semantic: vscode.DocumentFilter[];
}

7
extensions/typescript-language-features/src/utils/fileSchemes.ts
View file

@ -8,12 +8,7 @@ export const untitled = 'untitled';
export const git = 'git';
export const walkThroughSnippet = 'walkThroughSnippet';
export const supportedSchemes = [
export const semanticSupportedSchemes = [
file,
untitled,
walkThroughSnippet
];
export function isSupportedScheme(scheme: string): boolean {
return supportedSchemes.indexOf(scheme) >= 0;
}

1
src/vs/base/common/json.ts
View file

@ -72,6 +72,7 @@ export interface JSONScanner {
}
export interface ParseError {
error: ParseErrorCode;
offset: number;