@codingame/monaco-vscode-extensions-service-override
Version:
VSCode public API plugged on the monaco editor - extensions service-override
1,016 lines (1,015 loc) • 51 kB
JavaScript
import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
import { isFalsyOrEmpty } from 'vscode/vscode/vs/base/common/arrays';
import { VSDataTransfer, createStringDataTransferItem } from 'vscode/vscode/vs/base/common/dataTransfer';
import { CancellationError } from 'vscode/vscode/vs/base/common/errors';
import { Emitter } from 'vscode/vscode/vs/base/common/event';
import { HierarchicalKind } from 'vscode/vscode/vs/base/common/hierarchicalKind';
import { Disposable, DisposableMap, combinedDisposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
import { revive } from 'vscode/vscode/vs/base/common/marshalling';
import { mixin } from 'vscode/vscode/vs/base/common/objects';
import { URI } from 'vscode/vscode/vs/base/common/uri';
import { CompletionItemKind } from 'vscode/vscode/vs/editor/common/languages';
import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
import { ILanguageConfigurationService } from 'vscode/vscode/vs/editor/common/languages/languageConfigurationRegistry';
import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
import { decodeSemanticTokensDto } from 'vscode/vscode/vs/editor/common/services/semanticTokensDto';
import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
import { reviveWorkspaceEditDto } from './mainThreadBulkEdits.js';
import { DataTransfer } from 'vscode/vscode/vs/workbench/api/common/extHostTypeConverters';
import { DataTransferFileCache } from '../common/shared/dataTransferCache.js';
import { CallHierarchyProviderRegistry } from 'vscode/vscode/vs/workbench/contrib/callHierarchy/common/callHierarchy';
import { WorkspaceSymbolProviderRegistry } from 'vscode/vscode/vs/workbench/contrib/search/common/search';
import { TypeHierarchyProviderRegistry } from 'vscode/vscode/vs/workbench/contrib/typeHierarchy/common/typeHierarchy';
import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
import { ExtHostContext, ISuggestDataDtoField, ISuggestResultDtoField, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
var MainThreadLanguageFeatures_1;
let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThreadLanguageFeatures extends Disposable {
constructor(extHostContext, _languageService, _languageConfigurationService, _languageFeaturesService, _uriIdentService) {
super();
this._languageService = _languageService;
this._languageConfigurationService = _languageConfigurationService;
this._languageFeaturesService = _languageFeaturesService;
this._uriIdentService = _uriIdentService;
this._registrations = this._register(( new DisposableMap()));
this._pasteEditProviders = ( new Map());
this._documentOnDropEditProviders = ( new Map());
this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostLanguageFeatures));
if (this._languageService) {
const updateAllWordDefinitions = () => {
const wordDefinitionDtos = [];
for (const languageId of _languageService.getRegisteredLanguageIds()) {
const wordDefinition = this._languageConfigurationService.getLanguageConfiguration(languageId).getWordDefinition();
wordDefinitionDtos.push({
languageId: languageId,
regexSource: wordDefinition.source,
regexFlags: wordDefinition.flags
});
}
this._proxy.$setWordDefinitions(wordDefinitionDtos);
};
this._register(this._languageConfigurationService.onDidChange((e) => {
if (!e.languageId) {
updateAllWordDefinitions();
}
else {
const wordDefinition = this._languageConfigurationService.getLanguageConfiguration(e.languageId).getWordDefinition();
this._proxy.$setWordDefinitions([{
languageId: e.languageId,
regexSource: wordDefinition.source,
regexFlags: wordDefinition.flags
}]);
}
}));
updateAllWordDefinitions();
}
}
$unregister(handle) {
this._registrations.deleteAndDispose(handle);
}
static _reviveLocationDto(data) {
if (!data) {
return data;
}
else if (Array.isArray(data)) {
data.forEach(l => MainThreadLanguageFeatures_1._reviveLocationDto(l));
return data;
}
else {
data.uri = URI.revive(data.uri);
return data;
}
}
static _reviveLocationLinkDto(data) {
if (!data) {
return data;
}
else if (Array.isArray(data)) {
data.forEach(l => MainThreadLanguageFeatures_1._reviveLocationLinkDto(l));
return data;
}
else {
data.uri = URI.revive(data.uri);
return data;
}
}
static _reviveWorkspaceSymbolDto(data) {
if (!data) {
return data;
}
else if (Array.isArray(data)) {
data.forEach(MainThreadLanguageFeatures_1._reviveWorkspaceSymbolDto);
return data;
}
else {
data.location = MainThreadLanguageFeatures_1._reviveLocationDto(data.location);
return data;
}
}
static _reviveCodeActionDto(data, uriIdentService) {
data?.forEach(code => reviveWorkspaceEditDto(code.edit, uriIdentService));
return data;
}
static _reviveLinkDTO(data) {
if (data.url && typeof data.url !== 'string') {
data.url = URI.revive(data.url);
}
return data;
}
static _reviveCallHierarchyItemDto(data) {
if (data) {
data.uri = URI.revive(data.uri);
}
return data;
}
static _reviveTypeHierarchyItemDto(data) {
if (data) {
data.uri = URI.revive(data.uri);
}
return data;
}
$registerDocumentSymbolProvider(handle, selector, displayName) {
this._registrations.set(handle, this._languageFeaturesService.documentSymbolProvider.register(selector, {
displayName,
provideDocumentSymbols: (model, token) => {
return this._proxy.$provideDocumentSymbols(handle, model.uri, token);
}
}));
}
$registerCodeLensSupport(handle, selector, eventHandle) {
const provider = {
provideCodeLenses: async (model, token) => {
const listDto = await this._proxy.$provideCodeLenses(handle, model.uri, token);
if (!listDto) {
return undefined;
}
return {
lenses: listDto.lenses,
dispose: () => listDto.cacheId && this._proxy.$releaseCodeLenses(handle, listDto.cacheId)
};
},
resolveCodeLens: async (model, codeLens, token) => {
const result = await this._proxy.$resolveCodeLens(handle, codeLens, token);
if (!result) {
return undefined;
}
return {
...result,
range: model.validateRange(result.range),
};
}
};
if (typeof eventHandle === 'number') {
const emitter = ( new Emitter());
this._registrations.set(eventHandle, emitter);
provider.onDidChange = emitter.event;
}
this._registrations.set(handle, this._languageFeaturesService.codeLensProvider.register(selector, provider));
}
$emitCodeLensEvent(eventHandle, event) {
const obj = this._registrations.get(eventHandle);
if (obj instanceof Emitter) {
obj.fire(event);
}
}
$registerDefinitionSupport(handle, selector) {
this._registrations.set(handle, this._languageFeaturesService.definitionProvider.register(selector, {
provideDefinition: (model, position, token) => {
return this._proxy.$provideDefinition(handle, model.uri, position, token).then(MainThreadLanguageFeatures_1._reviveLocationLinkDto);
}
}));
}
$registerDeclarationSupport(handle, selector) {
this._registrations.set(handle, this._languageFeaturesService.declarationProvider.register(selector, {
provideDeclaration: (model, position, token) => {
return this._proxy.$provideDeclaration(handle, model.uri, position, token).then(MainThreadLanguageFeatures_1._reviveLocationLinkDto);
}
}));
}
$registerImplementationSupport(handle, selector) {
this._registrations.set(handle, this._languageFeaturesService.implementationProvider.register(selector, {
provideImplementation: (model, position, token) => {
return this._proxy.$provideImplementation(handle, model.uri, position, token).then(MainThreadLanguageFeatures_1._reviveLocationLinkDto);
}
}));
}
$registerTypeDefinitionSupport(handle, selector) {
this._registrations.set(handle, this._languageFeaturesService.typeDefinitionProvider.register(selector, {
provideTypeDefinition: (model, position, token) => {
return this._proxy.$provideTypeDefinition(handle, model.uri, position, token).then(MainThreadLanguageFeatures_1._reviveLocationLinkDto);
}
}));
}
$registerHoverProvider(handle, selector) {
this._registrations.set(handle, this._languageFeaturesService.hoverProvider.register(selector, {
provideHover: async (model, position, token, context) => {
const serializedContext = {
verbosityRequest: context?.verbosityRequest ? {
verbosityDelta: context.verbosityRequest.verbosityDelta,
previousHover: { id: context.verbosityRequest.previousHover.id }
} : undefined,
};
const hover = await this._proxy.$provideHover(handle, model.uri, position, serializedContext, token);
return hover;
}
}));
}
$registerEvaluatableExpressionProvider(handle, selector) {
this._registrations.set(handle, this._languageFeaturesService.evaluatableExpressionProvider.register(selector, {
provideEvaluatableExpression: (model, position, token) => {
return this._proxy.$provideEvaluatableExpression(handle, model.uri, position, token);
}
}));
}
$registerInlineValuesProvider(handle, selector, eventHandle) {
const provider = {
provideInlineValues: (model, viewPort, context, token) => {
return this._proxy.$provideInlineValues(handle, model.uri, viewPort, context, token);
}
};
if (typeof eventHandle === 'number') {
const emitter = ( new Emitter());
this._registrations.set(eventHandle, emitter);
provider.onDidChangeInlineValues = emitter.event;
}
this._registrations.set(handle, this._languageFeaturesService.inlineValuesProvider.register(selector, provider));
}
$emitInlineValuesEvent(eventHandle, event) {
const obj = this._registrations.get(eventHandle);
if (obj instanceof Emitter) {
obj.fire(event);
}
}
$registerDocumentHighlightProvider(handle, selector) {
this._registrations.set(handle, this._languageFeaturesService.documentHighlightProvider.register(selector, {
provideDocumentHighlights: (model, position, token) => {
return this._proxy.$provideDocumentHighlights(handle, model.uri, position, token);
}
}));
}
$registerMultiDocumentHighlightProvider(handle, selector) {
this._registrations.set(handle, this._languageFeaturesService.multiDocumentHighlightProvider.register(selector, {
selector: selector,
provideMultiDocumentHighlights: (model, position, otherModels, token) => {
return this._proxy.$provideMultiDocumentHighlights(handle, model.uri, position, ( otherModels.map(model => model.uri)), token).then(dto => {
if (isFalsyOrEmpty(dto)) {
return undefined;
}
const result = ( new ResourceMap());
dto?.forEach(value => {
const uri = URI.revive(value.uri);
if (( result.has(uri))) {
result.get(uri).push(...value.highlights);
}
else {
result.set(uri, value.highlights);
}
});
return result;
});
}
}));
}
$registerLinkedEditingRangeProvider(handle, selector) {
this._registrations.set(handle, this._languageFeaturesService.linkedEditingRangeProvider.register(selector, {
provideLinkedEditingRanges: async (model, position, token) => {
const res = await this._proxy.$provideLinkedEditingRanges(handle, model.uri, position, token);
if (res) {
return {
ranges: res.ranges,
wordPattern: res.wordPattern ? MainThreadLanguageFeatures_1._reviveRegExp(res.wordPattern) : undefined
};
}
return undefined;
}
}));
}
$registerReferenceSupport(handle, selector) {
this._registrations.set(handle, this._languageFeaturesService.referenceProvider.register(selector, {
provideReferences: (model, position, context, token) => {
return this._proxy.$provideReferences(handle, model.uri, position, context, token).then(MainThreadLanguageFeatures_1._reviveLocationDto);
}
}));
}
$registerCodeActionSupport(handle, selector, metadata, displayName, extensionId, supportsResolve) {
const provider = {
provideCodeActions: async (model, rangeOrSelection, context, token) => {
const listDto = await this._proxy.$provideCodeActions(handle, model.uri, rangeOrSelection, context, token);
if (!listDto) {
return undefined;
}
return {
actions: MainThreadLanguageFeatures_1._reviveCodeActionDto(listDto.actions, this._uriIdentService),
dispose: () => {
if (typeof listDto.cacheId === 'number') {
this._proxy.$releaseCodeActions(handle, listDto.cacheId);
}
}
};
},
providedCodeActionKinds: metadata.providedKinds,
documentation: metadata.documentation,
displayName,
extensionId,
};
if (supportsResolve) {
provider.resolveCodeAction = async (codeAction, token) => {
const resolved = await this._proxy.$resolveCodeAction(handle, codeAction.cacheId, token);
if (resolved.edit) {
codeAction.edit = reviveWorkspaceEditDto(resolved.edit, this._uriIdentService);
}
if (resolved.command) {
codeAction.command = resolved.command;
}
return codeAction;
};
}
this._registrations.set(handle, this._languageFeaturesService.codeActionProvider.register(selector, provider));
}
$registerPasteEditProvider(handle, selector, metadata) {
const provider = ( new MainThreadPasteEditProvider(handle, this._proxy, metadata, this._uriIdentService));
this._pasteEditProviders.set(handle, provider);
this._registrations.set(handle, combinedDisposable(this._languageFeaturesService.documentPasteEditProvider.register(selector, provider), toDisposable(() => this._pasteEditProviders.delete(handle))));
}
$resolvePasteFileData(handle, requestId, dataId) {
const provider = this._pasteEditProviders.get(handle);
if (!provider) {
throw ( new Error('Could not find provider'));
}
return provider.resolveFileData(requestId, dataId);
}
$registerDocumentFormattingSupport(handle, selector, extensionId, displayName) {
this._registrations.set(handle, this._languageFeaturesService.documentFormattingEditProvider.register(selector, {
extensionId,
displayName,
provideDocumentFormattingEdits: (model, options, token) => {
return this._proxy.$provideDocumentFormattingEdits(handle, model.uri, options, token);
}
}));
}
$registerRangeFormattingSupport(handle, selector, extensionId, displayName, supportsRanges) {
this._registrations.set(handle, this._languageFeaturesService.documentRangeFormattingEditProvider.register(selector, {
extensionId,
displayName,
provideDocumentRangeFormattingEdits: (model, range, options, token) => {
return this._proxy.$provideDocumentRangeFormattingEdits(handle, model.uri, range, options, token);
},
provideDocumentRangesFormattingEdits: !supportsRanges
? undefined
: (model, ranges, options, token) => {
return this._proxy.$provideDocumentRangesFormattingEdits(handle, model.uri, ranges, options, token);
},
}));
}
$registerOnTypeFormattingSupport(handle, selector, autoFormatTriggerCharacters, extensionId) {
this._registrations.set(handle, this._languageFeaturesService.onTypeFormattingEditProvider.register(selector, {
extensionId,
autoFormatTriggerCharacters,
provideOnTypeFormattingEdits: (model, position, ch, options, token) => {
return this._proxy.$provideOnTypeFormattingEdits(handle, model.uri, position, ch, options, token);
}
}));
}
$registerNavigateTypeSupport(handle, supportsResolve) {
let lastResultId;
const provider = {
provideWorkspaceSymbols: async (search, token) => {
const result = await this._proxy.$provideWorkspaceSymbols(handle, search, token);
if (lastResultId !== undefined) {
this._proxy.$releaseWorkspaceSymbols(handle, lastResultId);
}
lastResultId = result.cacheId;
return MainThreadLanguageFeatures_1._reviveWorkspaceSymbolDto(result.symbols);
}
};
if (supportsResolve) {
provider.resolveWorkspaceSymbol = async (item, token) => {
const resolvedItem = await this._proxy.$resolveWorkspaceSymbol(handle, item, token);
return resolvedItem && MainThreadLanguageFeatures_1._reviveWorkspaceSymbolDto(resolvedItem);
};
}
this._registrations.set(handle, WorkspaceSymbolProviderRegistry.register(provider));
}
$registerRenameSupport(handle, selector, supportResolveLocation) {
this._registrations.set(handle, this._languageFeaturesService.renameProvider.register(selector, {
provideRenameEdits: (model, position, newName, token) => {
return this._proxy.$provideRenameEdits(handle, model.uri, position, newName, token).then(data => reviveWorkspaceEditDto(data, this._uriIdentService));
},
resolveRenameLocation: supportResolveLocation
? (model, position, token) => this._proxy.$resolveRenameLocation(handle, model.uri, position, token)
: undefined
}));
}
$registerNewSymbolNamesProvider(handle, selector) {
this._registrations.set(handle, this._languageFeaturesService.newSymbolNamesProvider.register(selector, {
supportsAutomaticNewSymbolNamesTriggerKind: this._proxy.$supportsAutomaticNewSymbolNamesTriggerKind(handle),
provideNewSymbolNames: (model, range, triggerKind, token) => {
return this._proxy.$provideNewSymbolNames(handle, model.uri, range, triggerKind, token);
}
}));
}
$registerDocumentSemanticTokensProvider(handle, selector, legend, eventHandle) {
let event = undefined;
if (typeof eventHandle === 'number') {
const emitter = ( new Emitter());
this._registrations.set(eventHandle, emitter);
event = emitter.event;
}
this._registrations.set(handle, this._languageFeaturesService.documentSemanticTokensProvider.register(selector, ( new MainThreadDocumentSemanticTokensProvider(this._proxy, handle, legend, event))));
}
$emitDocumentSemanticTokensEvent(eventHandle) {
const obj = this._registrations.get(eventHandle);
if (obj instanceof Emitter) {
obj.fire(undefined);
}
}
$registerDocumentRangeSemanticTokensProvider(handle, selector, legend) {
this._registrations.set(handle, this._languageFeaturesService.documentRangeSemanticTokensProvider.register(selector, ( new MainThreadDocumentRangeSemanticTokensProvider(this._proxy, handle, legend))));
}
static _inflateSuggestDto(defaultRange, data, extensionId) {
const label = data[ISuggestDataDtoField.label];
const commandId = data[ISuggestDataDtoField.commandId];
const commandIdent = data[ISuggestDataDtoField.commandIdent];
const commitChars = data[ISuggestDataDtoField.commitCharacters];
return {
label,
extensionId,
kind: data[ISuggestDataDtoField.kind] ?? CompletionItemKind.Property,
tags: data[ISuggestDataDtoField.kindModifier],
detail: data[ISuggestDataDtoField.detail],
documentation: data[ISuggestDataDtoField.documentation],
sortText: data[ISuggestDataDtoField.sortText],
filterText: data[ISuggestDataDtoField.filterText],
preselect: data[ISuggestDataDtoField.preselect],
insertText: data[ISuggestDataDtoField.insertText] ?? (typeof label === 'string' ? label : label.label),
range: data[ISuggestDataDtoField.range] ?? defaultRange,
insertTextRules: data[ISuggestDataDtoField.insertTextRules],
commitCharacters: commitChars ? Array.from(commitChars) : undefined,
additionalTextEdits: data[ISuggestDataDtoField.additionalTextEdits],
command: commandId ? {
$ident: commandIdent,
id: commandId,
title: '',
arguments: commandIdent ? [commandIdent] : data[ISuggestDataDtoField.commandArguments],
} : undefined,
_id: data.x,
};
}
$registerCompletionsProvider(handle, selector, triggerCharacters, supportsResolveDetails, extensionId) {
const provider = {
triggerCharacters,
_debugDisplayName: `${extensionId.value}(${triggerCharacters.join('')})`,
provideCompletionItems: async (model, position, context, token) => {
const result = await this._proxy.$provideCompletionItems(handle, model.uri, position, context, token);
if (!result) {
return result;
}
return {
suggestions: ( result[ISuggestResultDtoField.completions].map(
d => MainThreadLanguageFeatures_1._inflateSuggestDto(result[ISuggestResultDtoField.defaultRanges], d, extensionId)
)),
incomplete: result[ISuggestResultDtoField.isIncomplete] || false,
duration: result[ISuggestResultDtoField.duration],
dispose: () => {
if (typeof result.x === 'number') {
this._proxy.$releaseCompletionItems(handle, result.x);
}
}
};
}
};
if (supportsResolveDetails) {
provider.resolveCompletionItem = (suggestion, token) => {
return this._proxy.$resolveCompletionItem(handle, suggestion._id, token).then(result => {
if (!result) {
return suggestion;
}
const newSuggestion = MainThreadLanguageFeatures_1._inflateSuggestDto(suggestion.range, result, extensionId);
return mixin(suggestion, newSuggestion, true);
});
};
}
this._registrations.set(handle, this._languageFeaturesService.completionProvider.register(selector, provider));
}
$registerInlineCompletionsSupport(handle, selector, supportsHandleEvents, extensionId, yieldsToExtensionIds) {
const provider = {
provideInlineCompletions: async (model, position, context, token) => {
return this._proxy.$provideInlineCompletions(handle, model.uri, position, context, token);
},
provideInlineEdits: async (model, range, context, token) => {
return this._proxy.$provideInlineEdits(handle, model.uri, range, context, token);
},
handleItemDidShow: async (completions, item, updatedInsertText) => {
if (supportsHandleEvents) {
await this._proxy.$handleInlineCompletionDidShow(handle, completions.pid, item.idx, updatedInsertText);
}
},
handlePartialAccept: async (completions, item, acceptedCharacters, info) => {
if (supportsHandleEvents) {
await this._proxy.$handleInlineCompletionPartialAccept(handle, completions.pid, item.idx, acceptedCharacters, info);
}
},
freeInlineCompletions: (completions) => {
this._proxy.$freeInlineCompletionsList(handle, completions.pid);
},
groupId: extensionId,
yieldsToGroupIds: yieldsToExtensionIds,
toString() {
return `InlineCompletionsProvider(${extensionId})`;
}
};
this._registrations.set(handle, this._languageFeaturesService.inlineCompletionsProvider.register(selector, provider));
}
$registerInlineEditProvider(handle, selector, extensionId) {
const provider = {
provideInlineEdit: async (model, context, token) => {
return this._proxy.$provideInlineEdit(handle, model.uri, context, token);
},
freeInlineEdit: (edit) => {
this._proxy.$freeInlineEdit(handle, edit.pid);
}
};
this._registrations.set(handle, this._languageFeaturesService.inlineEditProvider.register(selector, provider));
}
$registerSignatureHelpProvider(handle, selector, metadata) {
this._registrations.set(handle, this._languageFeaturesService.signatureHelpProvider.register(selector, {
signatureHelpTriggerCharacters: metadata.triggerCharacters,
signatureHelpRetriggerCharacters: metadata.retriggerCharacters,
provideSignatureHelp: async (model, position, token, context) => {
const result = await this._proxy.$provideSignatureHelp(handle, model.uri, position, context, token);
if (!result) {
return undefined;
}
return {
value: result,
dispose: () => {
this._proxy.$releaseSignatureHelp(handle, result.id);
}
};
}
}));
}
$registerInlayHintsProvider(handle, selector, supportsResolve, eventHandle, displayName) {
const provider = {
displayName,
provideInlayHints: async (model, range, token) => {
const result = await this._proxy.$provideInlayHints(handle, model.uri, range, token);
if (!result) {
return;
}
return {
hints: revive(result.hints),
dispose: () => {
if (result.cacheId) {
this._proxy.$releaseInlayHints(handle, result.cacheId);
}
}
};
}
};
if (supportsResolve) {
provider.resolveInlayHint = async (hint, token) => {
const dto = hint;
if (!dto.cacheId) {
return hint;
}
const result = await this._proxy.$resolveInlayHint(handle, dto.cacheId, token);
if (token.isCancellationRequested) {
throw ( new CancellationError());
}
if (!result) {
return hint;
}
return {
...hint,
tooltip: result.tooltip,
label: revive(result.label),
textEdits: result.textEdits
};
};
}
if (typeof eventHandle === 'number') {
const emitter = ( new Emitter());
this._registrations.set(eventHandle, emitter);
provider.onDidChangeInlayHints = emitter.event;
}
this._registrations.set(handle, this._languageFeaturesService.inlayHintsProvider.register(selector, provider));
}
$emitInlayHintsEvent(eventHandle) {
const obj = this._registrations.get(eventHandle);
if (obj instanceof Emitter) {
obj.fire(undefined);
}
}
$registerDocumentLinkProvider(handle, selector, supportsResolve) {
const provider = {
provideLinks: (model, token) => {
return this._proxy.$provideDocumentLinks(handle, model.uri, token).then(dto => {
if (!dto) {
return undefined;
}
return {
links: ( dto.links.map(MainThreadLanguageFeatures_1._reviveLinkDTO)),
dispose: () => {
if (typeof dto.cacheId === 'number') {
this._proxy.$releaseDocumentLinks(handle, dto.cacheId);
}
}
};
});
}
};
if (supportsResolve) {
provider.resolveLink = (link, token) => {
const dto = link;
if (!dto.cacheId) {
return link;
}
return this._proxy.$resolveDocumentLink(handle, dto.cacheId, token).then(obj => {
return obj && MainThreadLanguageFeatures_1._reviveLinkDTO(obj);
});
};
}
this._registrations.set(handle, this._languageFeaturesService.linkProvider.register(selector, provider));
}
$registerDocumentColorProvider(handle, selector) {
const proxy = this._proxy;
this._registrations.set(handle, this._languageFeaturesService.colorProvider.register(selector, {
provideDocumentColors: (model, token) => {
return proxy.$provideDocumentColors(handle, model.uri, token)
.then(documentColors => {
return ( documentColors.map(documentColor => {
const [red, green, blue, alpha] = documentColor.color;
const color = {
red: red,
green: green,
blue: blue,
alpha
};
return {
color,
range: documentColor.range
};
}));
});
},
provideColorPresentations: (model, colorInfo, token) => {
return proxy.$provideColorPresentations(handle, model.uri, {
color: [colorInfo.color.red, colorInfo.color.green, colorInfo.color.blue, colorInfo.color.alpha],
range: colorInfo.range
}, token);
}
}));
}
$registerFoldingRangeProvider(handle, selector, extensionId, eventHandle) {
const provider = {
id: extensionId.value,
provideFoldingRanges: (model, context, token) => {
return this._proxy.$provideFoldingRanges(handle, model.uri, context, token);
}
};
if (typeof eventHandle === 'number') {
const emitter = ( new Emitter());
this._registrations.set(eventHandle, emitter);
provider.onDidChange = emitter.event;
}
this._registrations.set(handle, this._languageFeaturesService.foldingRangeProvider.register(selector, provider));
}
$emitFoldingRangeEvent(eventHandle, event) {
const obj = this._registrations.get(eventHandle);
if (obj instanceof Emitter) {
obj.fire(event);
}
}
$registerSelectionRangeProvider(handle, selector) {
this._registrations.set(handle, this._languageFeaturesService.selectionRangeProvider.register(selector, {
provideSelectionRanges: (model, positions, token) => {
return this._proxy.$provideSelectionRanges(handle, model.uri, positions, token);
}
}));
}
$registerCallHierarchyProvider(handle, selector) {
this._registrations.set(handle, CallHierarchyProviderRegistry.register(selector, {
prepareCallHierarchy: async (document, position, token) => {
const items = await this._proxy.$prepareCallHierarchy(handle, document.uri, position, token);
if (!items || items.length === 0) {
return undefined;
}
return {
dispose: () => {
for (const item of items) {
this._proxy.$releaseCallHierarchy(handle, item._sessionId);
}
},
roots: ( items.map(MainThreadLanguageFeatures_1._reviveCallHierarchyItemDto))
};
},
provideOutgoingCalls: async (item, token) => {
const outgoing = await this._proxy.$provideCallHierarchyOutgoingCalls(handle, item._sessionId, item._itemId, token);
if (!outgoing) {
return outgoing;
}
outgoing.forEach(value => {
value.to = MainThreadLanguageFeatures_1._reviveCallHierarchyItemDto(value.to);
});
return outgoing;
},
provideIncomingCalls: async (item, token) => {
const incoming = await this._proxy.$provideCallHierarchyIncomingCalls(handle, item._sessionId, item._itemId, token);
if (!incoming) {
return incoming;
}
incoming.forEach(value => {
value.from = MainThreadLanguageFeatures_1._reviveCallHierarchyItemDto(value.from);
});
return incoming;
}
}));
}
static _reviveRegExp(regExp) {
return ( new RegExp(regExp.pattern, regExp.flags));
}
static _reviveIndentationRule(indentationRule) {
return {
decreaseIndentPattern: MainThreadLanguageFeatures_1._reviveRegExp(indentationRule.decreaseIndentPattern),
increaseIndentPattern: MainThreadLanguageFeatures_1._reviveRegExp(indentationRule.increaseIndentPattern),
indentNextLinePattern: indentationRule.indentNextLinePattern ? MainThreadLanguageFeatures_1._reviveRegExp(indentationRule.indentNextLinePattern) : undefined,
unIndentedLinePattern: indentationRule.unIndentedLinePattern ? MainThreadLanguageFeatures_1._reviveRegExp(indentationRule.unIndentedLinePattern) : undefined,
};
}
static _reviveOnEnterRule(onEnterRule) {
return {
beforeText: MainThreadLanguageFeatures_1._reviveRegExp(onEnterRule.beforeText),
afterText: onEnterRule.afterText ? MainThreadLanguageFeatures_1._reviveRegExp(onEnterRule.afterText) : undefined,
previousLineText: onEnterRule.previousLineText ? MainThreadLanguageFeatures_1._reviveRegExp(onEnterRule.previousLineText) : undefined,
action: onEnterRule.action
};
}
static _reviveOnEnterRules(onEnterRules) {
return ( onEnterRules.map(MainThreadLanguageFeatures_1._reviveOnEnterRule));
}
$setLanguageConfiguration(handle, languageId, _configuration) {
const configuration = {
comments: _configuration.comments,
brackets: _configuration.brackets,
wordPattern: _configuration.wordPattern ? MainThreadLanguageFeatures_1._reviveRegExp(_configuration.wordPattern) : undefined,
indentationRules: _configuration.indentationRules ? MainThreadLanguageFeatures_1._reviveIndentationRule(_configuration.indentationRules) : undefined,
onEnterRules: _configuration.onEnterRules ? MainThreadLanguageFeatures_1._reviveOnEnterRules(_configuration.onEnterRules) : undefined,
autoClosingPairs: undefined,
surroundingPairs: undefined,
__electricCharacterSupport: undefined
};
if (_configuration.autoClosingPairs) {
configuration.autoClosingPairs = _configuration.autoClosingPairs;
}
else if (_configuration.__characterPairSupport) {
configuration.autoClosingPairs = _configuration.__characterPairSupport.autoClosingPairs;
}
if (_configuration.__electricCharacterSupport && _configuration.__electricCharacterSupport.docComment) {
configuration.__electricCharacterSupport = {
docComment: {
open: _configuration.__electricCharacterSupport.docComment.open,
close: _configuration.__electricCharacterSupport.docComment.close
}
};
}
if (this._languageService.isRegisteredLanguageId(languageId)) {
this._registrations.set(handle, this._languageConfigurationService.register(languageId, configuration, 100));
}
}
$registerTypeHierarchyProvider(handle, selector) {
this._registrations.set(handle, TypeHierarchyProviderRegistry.register(selector, {
prepareTypeHierarchy: async (document, position, token) => {
const items = await this._proxy.$prepareTypeHierarchy(handle, document.uri, position, token);
if (!items) {
return undefined;
}
return {
dispose: () => {
for (const item of items) {
this._proxy.$releaseTypeHierarchy(handle, item._sessionId);
}
},
roots: ( items.map(MainThreadLanguageFeatures_1._reviveTypeHierarchyItemDto))
};
},
provideSupertypes: async (item, token) => {
const supertypes = await this._proxy.$provideTypeHierarchySupertypes(handle, item._sessionId, item._itemId, token);
if (!supertypes) {
return supertypes;
}
return ( supertypes.map(MainThreadLanguageFeatures_1._reviveTypeHierarchyItemDto));
},
provideSubtypes: async (item, token) => {
const subtypes = await this._proxy.$provideTypeHierarchySubtypes(handle, item._sessionId, item._itemId, token);
if (!subtypes) {
return subtypes;
}
return ( subtypes.map(MainThreadLanguageFeatures_1._reviveTypeHierarchyItemDto));
}
}));
}
$registerDocumentOnDropEditProvider(handle, selector, metadata) {
const provider = ( new MainThreadDocumentOnDropEditProvider(handle, this._proxy, metadata, this._uriIdentService));
this._documentOnDropEditProviders.set(handle, provider);
this._registrations.set(handle, combinedDisposable(this._languageFeaturesService.documentDropEditProvider.register(selector, provider), toDisposable(() => this._documentOnDropEditProviders.delete(handle))));
}
async $resolveDocumentOnDropFileData(handle, requestId, dataId) {
const provider = this._documentOnDropEditProviders.get(handle);
if (!provider) {
throw ( new Error('Could not find provider'));
}
return provider.resolveDocumentOnDropFileData(requestId, dataId);
}
$registerMappedEditsProvider(handle, selector, displayName) {
const provider = ( new MainThreadMappedEditsProvider(displayName, handle, this._proxy, this._uriIdentService));
this._registrations.set(handle, this._languageFeaturesService.mappedEditsProvider.register(selector, provider));
}
};
MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = __decorate([
extHostNamedCustomer(MainContext.MainThreadLanguageFeatures),
( __param(1, ILanguageService)),
( __param(2, ILanguageConfigurationService)),
( __param(3, ILanguageFeaturesService)),
( __param(4, IUriIdentityService))
], MainThreadLanguageFeatures);
let MainThreadPasteEditProvider = class MainThreadPasteEditProvider {
constructor(_handle, _proxy, metadata, _uriIdentService) {
this._handle = _handle;
this._proxy = _proxy;
this._uriIdentService = _uriIdentService;
this.dataTransfers = ( new DataTransferFileCache());
this.copyMimeTypes = metadata.copyMimeTypes;
this.pasteMimeTypes = metadata.pasteMimeTypes;
this.providedPasteEditKinds = metadata.providedPasteEditKinds?.map(kind => ( new HierarchicalKind(kind)));
if (metadata.supportsCopy) {
this.prepareDocumentPaste = async (model, selections, dataTransfer, token) => {
const dataTransferDto = await DataTransfer.from(dataTransfer);
if (token.isCancellationRequested) {
return undefined;
}
const newDataTransfer = await this._proxy.$prepareDocumentPaste(_handle, model.uri, selections, dataTransferDto, token);
if (!newDataTransfer) {
return undefined;
}
const dataTransferOut = ( new VSDataTransfer());
for (const [type, item] of newDataTransfer.items) {
dataTransferOut.replace(type, createStringDataTransferItem(item.asString));
}
return dataTransferOut;
};
}
if (metadata.supportsPaste) {
this.provideDocumentPasteEdits = async (model, selections, dataTransfer, context, token) => {
const request = this.dataTransfers.add(dataTransfer);
try {
const dataTransferDto = await DataTransfer.from(dataTransfer);
if (token.isCancellationRequested) {
return;
}
const edits = await this._proxy.$providePasteEdits(this._handle, request.id, model.uri, selections, dataTransferDto, {
only: context.only?.value,
triggerKind: context.triggerKind,
}, token);
if (!edits) {
return;
}
return {
edits: ( edits.map((edit) => {
return {
...edit,
kind: edit.kind ? ( new HierarchicalKind(edit.kind.value)) : ( new HierarchicalKind('')),
yieldTo: edit.yieldTo?.map(x => ({ kind: ( new HierarchicalKind(x)) })),
additionalEdit: edit.additionalEdit ? reviveWorkspaceEditDto(edit.additionalEdit, this._uriIdentService, dataId => this.resolveFileData(request.id, dataId)) : undefined,
};
})),
dispose: () => {
this._proxy.$releasePasteEdits(this._handle, request.id);
},
};
}
finally {
request.dispose();
}
};
}
if (metadata.supportsResolve) {
this.resolveDocumentPasteEdit = async (edit, token) => {
const resolved = await this._proxy.$resolvePasteEdit(this._handle, edit._cacheId, token);
if (resolved.additionalEdit) {
edit.additionalEdit = reviveWorkspaceEditDto(resolved.additionalEdit, this._uriIdentService);
}
return edit;
};
}
}
resolveFileData(requestId, dataId) {
return this.dataTransfers.resolveFileData(requestId, dataId);
}
};
MainThreadPasteEditProvider = ( __decorate([
( __param(3, IUriIdentityService))
], MainThreadPasteEditProvider));
let MainThreadDocumentOnDropEditProvider = class MainThreadDocumentOnDropEditProvider {
constructor(_handle, _proxy, metadata, _uriIdentService) {
this._handle = _handle;
this._proxy = _proxy;
this._uriIdentService = _uriIdentService;
this.dataTransfers = ( new DataTransferFileCache());
this.dropMimeTypes = metadata?.dropMimeTypes ?? ['*/*'];
if (metadata?.supportsResolve) {
this.resolveDocumentDropEdit = async (edit, token) => {
const resolved = await this._proxy.$resolvePasteEdit(this._handle, edit._cacheId, token);
if (resolved.additionalEdit) {
edit.additionalEdit = reviveWorkspaceEditDto(resolved.additionalEdit, this._uriIdentService);
}
return edit;
};
}
}
async provideDocumentDropEdits(model, position, dataTransfer, token) {
const request = this.dataTransfers.add(dataTransfer);
try {
const dataTransferDto = await DataTransfer.from(dataTransfer);
if (token.isCancellationRequested) {
return;
}
const edits = await this._proxy.$provideDocumentOnDropEdits(this._handle, request.id, model.uri, position, dataTransferDto, token);
if (!edits) {
return;
}
return {
edits: ( edits.map(edit => {
return {
...edit,
yieldTo: edit.yieldTo?.map(x => ({ kind: ( new HierarchicalKind(x)) })),
kind: edit.kind ? ( new HierarchicalKind(edit.kind)) : undefined,
additionalEdit: reviveWorkspaceEditDto(edit.additionalEdit, this._uriIdentService, dataId => this.resolveDocumentOnDropFileData(request.id, dataId)),
};
})),
dispose: () => {
this._proxy.$releaseDocumentOnDropEdits(this._handle, request.id);
},
};
}
finally {
request.dispose();
}
}
resolveDocumentOnDropFileData(requestId, dataId) {
return this.dataTransfers.resolveFileData(requestId, dataId);
}
};
MainThreadDocumentOnDropEditProvider = ( __decorate([
( __param(3, IUriIdentityService))
], MainThreadDocumentOnDropEditProvider));
class MainThreadDocumentSemanticTokensProvider {
constructor(_proxy, _handle, _legend, onDidChange) {
this._proxy = _proxy;
this._handle = _handle;
this._legend = _legend;
this.onDidChange = onDidChange;
}
releaseDocumentSemanticTokens(resultId) {
if (resultId) {
this._proxy.$releaseDocumentSemanticTokens(this._handle, parseInt(resultId, 10));
}
}
getLegend() {
return this._legend;
}
async provideDocumentSemanticTokens(model, lastResultId, token) {
const nLastResultId = lastResultId ? parseInt(lastResultId, 10) : 0;
const encodedDto = await this._proxy.$provideDocumentSemanticTokens(this._handle, model.uri, nLastResultId, token);
if (!encodedDto) {
return null;
}
if (token.isCancellationRequested) {
return null;
}
const dto = decodeSemanticTokensDto(encodedDto);
if (dto.type === 'full') {
return {
resultId: String(dto.id),
data: dto.data
};
}
return {
resultId: String(dto.id),
edits: dto.deltas
};
}
}
class MainThreadDocumentRangeSemanticTokensProvider {
constructor(_proxy, _handle, _legend) {
this._proxy = _proxy;
this._handle = _handle;
this._legend = _legend;
}
getLegend() {
return this._legend;
}
async provideDocumentRangeSemanticTokens(model, range, token) {
const encodedDto = await this._proxy.$provideDocumentRangeSemanticTokens(this._handle, model.uri, range, token);
if (!encodedDto) {
r