src/vs/editor/common/languages.ts
2648 LOC · 2490 covered · 158 uncovered · 29 ranges · 2653 concepts · 3 introducers · 1317 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
languages.ts ×27
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
import { VSBuffer } from '../../base/common/buffer.js';
7
>
import { CancellationToken } from '../../base/common/cancellation.js';
8
>
import { Codicon } from '../../base/common/codicons.js';
9
>
import { Color } from '../../base/common/color.js';
10
>
import { IReadonlyVSDataTransfer } from '../../base/common/dataTransfer.js';
11
>
import { Event } from '../../base/common/event.js';
12
>
import { HierarchicalKind } from '../../base/common/hierarchicalKind.js';
13
>
import { IMarkdownString } from '../../base/common/htmlContent.js';
14
>
import { IDisposable } from '../../base/common/lifecycle.js';
15
>
import { ThemeIcon } from '../../base/common/themables.js';
16
>
import { URI, UriComponents } from '../../base/common/uri.js';
17
>
import { EditOperation, ISingleEditOperation } from './core/editOperation.js';
18
>
import { IPosition, Position } from './core/position.js';
19
>
import { IRange, Range } from './core/range.js';
20
>
import { Selection } from './core/selection.js';
21
>
import { LanguageId } from './encodedTokenAttributes.js';
22
>
import { LanguageSelector } from './languageSelector.js';
23
>
import * as model from './model.js';
24
>
import { TokenizationRegistry as TokenizationRegistryImpl } from './tokenizationRegistry.js';
25
>
import { ContiguousMultilineTokens } from './tokens/contiguousMultilineTokens.js';
26
>
import { localize } from '../../nls.js';
27
>
import { ExtensionIdentifier } from '../../platform/extensions/common/extensions.js';
28
>
import { IMarkerData } from '../../platform/markers/common/markers.js';
29
>
import { EditDeltaInfo } from './textModelEditSource.js';
30
>
import { FontTokensUpdate } from './textModelEvents.js';
31
>
32
>
/**
33
>
* @internal
34
>
*/
35
>
export interface ILanguageIdCodec {
36
>
encodeLanguageId(languageId: string): LanguageId;
37
>
decodeLanguageId(languageId: LanguageId): string;
38
>
}
39
>
40
>
export class Token {
41
>
_tokenBrand: void = undefined;
42
>
43
>
constructor(
44
public readonly offset: number,
45
public readonly type: string,
46
public readonly language: string,
47
) {
48
}
50
>
public toString(): string {
51
return '(' + this.offset + ', ' + this.type + ')';
52
}
54
>
55
>
/**
56
>
* @internal
57
>
*/
58
>
export class TokenizationResult {
59
>
_tokenizationResultBrand: void = undefined;
60
>
61
>
constructor(
62
public readonly tokens: Token[],
63
public readonly endState: IState,
64
) {
65
}
67
>
68
>
/**
69
>
* @internal
70
>
*/
71
>
export interface IFontToken {
72
>
readonly startIndex: number;
73
>
readonly endIndex: number;
74
>
readonly fontFamily: string | null;
75
>
readonly fontSizeMultiplier: number | null;
76
>
readonly lineHeightMultiplier: number | null;
77
>
}
78
>
79
>
/**
80
>
* @internal
81
>
*/
82
>
export class EncodedTokenizationResult {
83
>
_encodedTokenizationResultBrand: void = undefined;
84
>
85
>
constructor(
87
>
* The tokens in binary format. Each token occupies two array indices. For token i:
88
>
* - at offset 2*i => startIndex
89
>
* - at offset 2*i + 1 => metadata
90
>
*
91
>
*/
92
>
public readonly tokens: Uint32Array,
93
>
public readonly fontInfo: IFontToken[],
94
>
public readonly endState: IState,
95
>
) {
96
>
}
98
>
99
>
export interface SyntaxNode {
100
>
startIndex: number;
101
>
endIndex: number;
102
>
startPosition: IPosition;
103
>
endPosition: IPosition;
104
>
}
105
>
106
>
export interface QueryCapture {
107
>
name: string;
108
>
text?: string;
109
>
node: SyntaxNode;
110
>
encodedLanguageId: number;
111
>
}
112
>
113
>
/**
114
>
* @internal
115
>
*/
116
>
export interface ITokenizationSupport {
117
>
/**
118
>
* If true, the background tokenizer will only be used to verify tokens against the default background tokenizer.
119
>
* Used for debugging.
120
>
*/
121
>
readonly backgroundTokenizerShouldOnlyVerifyTokens?: boolean;
122
>
123
>
getInitialState(): IState;
124
>
125
>
tokenize(line: string, hasEOL: boolean, state: IState): TokenizationResult;
126
>
127
>
tokenizeEncoded(line: string, hasEOL: boolean, state: IState): EncodedTokenizationResult;
128
>
129
>
/**
130
>
* Can be/return undefined if default background tokenization should be used.
131
>
*/
132
>
createBackgroundTokenizer?(textModel: model.ITextModel, store: IBackgroundTokenizationStore): IBackgroundTokenizer | undefined;
133
>
}
134
>
135
>
/**
136
>
* @internal
137
>
*/
138
>
export interface IBackgroundTokenizer extends IDisposable {
139
>
/**
140
>
* Instructs the background tokenizer to set the tokens for the given range again.
141
>
*
142
>
* This might be necessary if the renderer overwrote those tokens with heuristically computed ones for some viewport,
143
>
* when the change does not even propagate to that viewport.
144
>
*/
145
>
requestTokens(startLineNumber: number, endLineNumberExclusive: number): void;
146
>
147
>
reportMismatchingTokens?(lineNumber: number): void;
148
>
}
149
>
150
>
/**
151
>
* @internal
152
>
*/
153
>
export interface IBackgroundTokenizationStore {
154
>
setTokens(tokens: ContiguousMultilineTokens[]): void;
155
>
156
>
setFontInfo(changes: FontTokensUpdate): void;
157
>
158
>
setEndState(lineNumber: number, state: IState): void;
159
>
160
>
/**
161
>
* Should be called to indicate that the background tokenization has finished for now.
162
>
* (This triggers bracket pair colorization to re-parse the bracket pairs with token information)
163
>
*/
164
>
backgroundTokenizationFinished(): void;
165
>
}
166
>
167
>
/**
168
>
* The state of the tokenizer between two lines.
169
>
* It is useful to store flags such as in multiline comment, etc.
170
>
* The model will clone the previous line's state and pass it in to tokenize the next line.
171
>
*/
172
>
export interface IState {
173
>
clone(): IState;
174
>
equals(other: IState): boolean;
175
>
}
176
>
177
>
/**
178
>
* A provider result represents the values a provider, like the {@link HoverProvider},
179
>
* may return. For once this is the actual result type `T`, like `Hover`, or a thenable that resolves
180
>
* to that type `T`. In addition, `null` and `undefined` can be returned - either directly or from a
181
>
* thenable.
182
>
*/
183
>
export type ProviderResult<T> = T | undefined | null | Thenable<T | undefined | null>;
184
>
185
>
/**
186
>
* A hover represents additional information for a symbol or word. Hovers are
187
>
* rendered in a tooltip-like widget.
188
>
*/
189
>
export interface Hover {
190
>
/**
191
>
* The contents of this hover.
192
>
*/
193
>
contents: IMarkdownString[];
194
>
195
>
/**
196
>
* The range to which this hover applies. When missing, the
197
>
* editor will use the range at the current position or the
198
>
* current position itself.
199
>
*/
200
>
range?: IRange;
201
>
202
>
/**
203
>
* Can increase the verbosity of the hover
204
>
*/
205
>
canIncreaseVerbosity?: boolean;
206
>
207
>
/**
208
>
* Can decrease the verbosity of the hover
209
>
*/
210
>
canDecreaseVerbosity?: boolean;
211
>
}
212
>
213
>
/**
214
>
* The hover provider interface defines the contract between extensions and
215
>
* the [hover](https://code.visualstudio.com/docs/editor/intellisense)-feature.
216
>
*/
217
>
export interface HoverProvider<THover = Hover> {
218
>
/**
219
>
* Provide a hover for the given position, context and document. Multiple hovers at the same
220
>
* position will be merged by the editor. A hover can have a range which defaults
221
>
* to the word range at the position when omitted.
222
>
*/
223
>
provideHover(model: model.ITextModel, position: Position, token: CancellationToken, context?: HoverContext<THover>): ProviderResult<THover>;
224
>
}
225
>
226
>
export interface HoverContext<THover = Hover> {
227
>
/**
228
>
* Hover verbosity request
229
>
*/
230
>
verbosityRequest?: HoverVerbosityRequest<THover>;
231
>
}
232
>
233
>
export interface HoverVerbosityRequest<THover = Hover> {
234
>
/**
235
>
* The delta by which to increase/decrease the hover verbosity level
236
>
*/
237
>
verbosityDelta: number;
238
>
/**
239
>
* The previous hover for the same position
240
>
*/
241
>
previousHover: THover;
242
>
}
243
>
244
>
export enum HoverVerbosityAction {
245
>
/**
246
>
* Increase the verbosity of the hover
247
>
*/
248
>
Increase,
249
>
/**
250
>
* Decrease the verbosity of the hover
251
>
*/
252
>
Decrease
253
>
}
254
>
255
>
/**
256
>
* An evaluatable expression represents additional information for an expression in a document. Evaluatable expressions are
257
>
* evaluated by a debugger or runtime and their result is rendered in a tooltip-like widget.
258
>
* @internal
259
>
*/
260
>
export interface EvaluatableExpression {
261
>
/**
262
>
* The range to which this expression applies.
263
>
*/
264
>
range: IRange;
265
>
/**
266
>
* This expression overrides the expression extracted from the range.
267
>
*/
268
>
expression?: string;
269
>
}
270
>
271
>
272
>
/**
273
>
* The evaluatable expression provider interface defines the contract between extensions and
274
>
* the debug hover.
275
>
* @internal
276
>
*/
277
>
export interface EvaluatableExpressionProvider {
278
>
/**
279
>
* Provide a hover for the given position and document. Multiple hovers at the same
280
>
* position will be merged by the editor. A hover can have a range which defaults
281
>
* to the word range at the position when omitted.
282
>
*/
283
>
provideEvaluatableExpression(model: model.ITextModel, position: Position, token: CancellationToken): ProviderResult<EvaluatableExpression>;
284
>
}
285
>
286
>
/**
287
>
* A value-object that contains contextual information when requesting inline values from a InlineValuesProvider.
288
>
* @internal
289
>
*/
290
>
export interface InlineValueContext {
291
>
frameId: number;
292
>
stoppedLocation: Range;
293
>
}
294
>
295
>
/**
296
>
* Provide inline value as text.
297
>
* @internal
298
>
*/
299
>
export interface InlineValueText {
300
>
type: 'text';
301
>
range: IRange;
302
>
text: string;
303
>
}
304
>
305
>
/**
306
>
* Provide inline value through a variable lookup.
307
>
* @internal
308
>
*/
309
>
export interface InlineValueVariableLookup {
310
>
type: 'variable';
311
>
range: IRange;
312
>
variableName?: string;
313
>
caseSensitiveLookup: boolean;
314
>
}
315
>
316
>
/**
317
>
* Provide inline value through an expression evaluation.
318
>
* @internal
319
>
*/
320
>
export interface InlineValueExpression {
321
>
type: 'expression';
322
>
range: IRange;
323
>
expression?: string;
324
>
}
325
>
326
>
/**
327
>
* Inline value information can be provided by different means:
328
>
* - directly as a text value (class InlineValueText).
329
>
* - as a name to use for a variable lookup (class InlineValueVariableLookup)
330
>
* - as an evaluatable expression (class InlineValueEvaluatableExpression)
331
>
* The InlineValue types combines all inline value types into one type.
332
>
* @internal
333
>
*/
334
>
export type InlineValue = InlineValueText | InlineValueVariableLookup | InlineValueExpression;
335
>
336
>
/**
337
>
* The inline values provider interface defines the contract between extensions and
338
>
* the debugger's inline values feature.
339
>
* @internal
340
>
*/
341
>
export interface InlineValuesProvider {
342
>
/**
343
>
*/
344
>
onDidChangeInlineValues?: Event<void> | undefined;
345
>
/**
346
>
* Provide the "inline values" for the given range and document. Multiple hovers at the same
347
>
* position will be merged by the editor. A hover can have a range which defaults
348
>
* to the word range at the position when omitted.
349
>
*/
350
>
provideInlineValues(model: model.ITextModel, viewPort: Range, context: InlineValueContext, token: CancellationToken): ProviderResult<InlineValue[]>;
351
>
}
352
>
353
>
export const enum CompletionItemKind {
354
>
Method,
355
>
Function,
356
>
Constructor,
357
>
Field,
358
>
Variable,
359
>
Class,
360
>
Struct,
361
>
Interface,
362
>
Module,
363
>
Property,
364
>
Event,
365
>
Operator,
366
>
Unit,
367
>
Value,
368
>
Constant,
369
>
Enum,
370
>
EnumMember,
371
>
Keyword,
372
>
Text,
373
>
Color,
374
>
File,
375
>
Reference,
376
>
Customcolor,
377
>
Folder,
378
>
TypeParameter,
379
>
User,
380
>
Issue,
381
>
Tool,
382
>
Snippet, // <- highest value (used for compare!)
383
>
}
384
>
385
>
/**
386
>
* @internal
387
>
*/
388
>
export namespace CompletionItemKinds {
389
>
390
>
const byKind = new Map<CompletionItemKind, ThemeIcon>();
391
>
byKind.set(CompletionItemKind.Method, Codicon.symbolMethod);
392
>
byKind.set(CompletionItemKind.Function, Codicon.symbolFunction);
393
>
byKind.set(CompletionItemKind.Constructor, Codicon.symbolConstructor);
394
>
byKind.set(CompletionItemKind.Field, Codicon.symbolField);
395
>
byKind.set(CompletionItemKind.Variable, Codicon.symbolVariable);
396
>
byKind.set(CompletionItemKind.Class, Codicon.symbolClass);
397
>
byKind.set(CompletionItemKind.Struct, Codicon.symbolStruct);
398
>
byKind.set(CompletionItemKind.Interface, Codicon.symbolInterface);
399
>
byKind.set(CompletionItemKind.Module, Codicon.symbolModule);
400
>
byKind.set(CompletionItemKind.Property, Codicon.symbolProperty);
401
>
byKind.set(CompletionItemKind.Event, Codicon.symbolEvent);
402
>
byKind.set(CompletionItemKind.Operator, Codicon.symbolOperator);
403
>
byKind.set(CompletionItemKind.Unit, Codicon.symbolUnit);
404
>
byKind.set(CompletionItemKind.Value, Codicon.symbolValue);
405
>
byKind.set(CompletionItemKind.Enum, Codicon.symbolEnum);
406
>
byKind.set(CompletionItemKind.Constant, Codicon.symbolConstant);
407
>
byKind.set(CompletionItemKind.EnumMember, Codicon.symbolEnumMember);
408
>
byKind.set(CompletionItemKind.Keyword, Codicon.symbolKeyword);
409
>
byKind.set(CompletionItemKind.Snippet, Codicon.symbolSnippet);
410
>
byKind.set(CompletionItemKind.Text, Codicon.symbolText);
411
>
byKind.set(CompletionItemKind.Color, Codicon.symbolColor);
412
>
byKind.set(CompletionItemKind.File, Codicon.symbolFile);
413
>
byKind.set(CompletionItemKind.Reference, Codicon.symbolReference);
414
>
byKind.set(CompletionItemKind.Customcolor, Codicon.symbolCustomColor);
415
>
byKind.set(CompletionItemKind.Folder, Codicon.symbolFolder);
416
>
byKind.set(CompletionItemKind.TypeParameter, Codicon.symbolTypeParameter);
417
>
byKind.set(CompletionItemKind.User, Codicon.account);
418
>
byKind.set(CompletionItemKind.Issue, Codicon.issues);
419
>
byKind.set(CompletionItemKind.Tool, Codicon.tools);
420
>
421
>
/**
422
>
* @internal
423
>
*/
424
>
export function toIcon(kind: CompletionItemKind): ThemeIcon {
425
let codicon = byKind.get(kind);
426
if (!codicon) {
427
console.info('No codicon found for CompletionItemKind ' + kind);
428
codicon = Codicon.symbolProperty;
429
}
430
return codicon;
431
}
433
>
/**
434
>
* @internal
435
>
*/
436
>
export function toLabel(kind: CompletionItemKind): string {
437
switch (kind) {
438
case CompletionItemKind.Method: return localize('suggestWidget.kind.method', 'Method');
439
case CompletionItemKind.Function: return localize('suggestWidget.kind.function', 'Function');
440
case CompletionItemKind.Constructor: return localize('suggestWidget.kind.constructor', 'Constructor');
441
case CompletionItemKind.Field: return localize('suggestWidget.kind.field', 'Field');
442
case CompletionItemKind.Variable: return localize('suggestWidget.kind.variable', 'Variable');
443
case CompletionItemKind.Class: return localize('suggestWidget.kind.class', 'Class');
444
case CompletionItemKind.Struct: return localize('suggestWidget.kind.struct', 'Struct');
445
case CompletionItemKind.Interface: return localize('suggestWidget.kind.interface', 'Interface');
446
case CompletionItemKind.Module: return localize('suggestWidget.kind.module', 'Module');
447
case CompletionItemKind.Property: return localize('suggestWidget.kind.property', 'Property');
448
case CompletionItemKind.Event: return localize('suggestWidget.kind.event', 'Event');
449
case CompletionItemKind.Operator: return localize('suggestWidget.kind.operator', 'Operator');
450
case CompletionItemKind.Unit: return localize('suggestWidget.kind.unit', 'Unit');
451
case CompletionItemKind.Value: return localize('suggestWidget.kind.value', 'Value');
452
case CompletionItemKind.Constant: return localize('suggestWidget.kind.constant', 'Constant');
453
case CompletionItemKind.Enum: return localize('suggestWidget.kind.enum', 'Enum');
454
case CompletionItemKind.EnumMember: return localize('suggestWidget.kind.enumMember', 'Enum Member');
455
case CompletionItemKind.Keyword: return localize('suggestWidget.kind.keyword', 'Keyword');
456
case CompletionItemKind.Text: return localize('suggestWidget.kind.text', 'Text');
457
case CompletionItemKind.Color: return localize('suggestWidget.kind.color', 'Color');
458
case CompletionItemKind.File: return localize('suggestWidget.kind.file', 'File');
459
case CompletionItemKind.Reference: return localize('suggestWidget.kind.reference', 'Reference');
460
case CompletionItemKind.Customcolor: return localize('suggestWidget.kind.customcolor', 'Custom Color');
461
case CompletionItemKind.Folder: return localize('suggestWidget.kind.folder', 'Folder');
462
case CompletionItemKind.TypeParameter: return localize('suggestWidget.kind.typeParameter', 'Type Parameter');
463
case CompletionItemKind.User: return localize('suggestWidget.kind.user', 'User');
464
case CompletionItemKind.Issue: return localize('suggestWidget.kind.issue', 'Issue');
465
case CompletionItemKind.Tool: return localize('suggestWidget.kind.tool', 'Tool');
466
case CompletionItemKind.Snippet: return localize('suggestWidget.kind.snippet', 'Snippet');
467
default: return '';
468
}
469
}
471
>
const data = new Map<string, CompletionItemKind>();
472
>
data.set('method', CompletionItemKind.Method);
473
>
data.set('function', CompletionItemKind.Function);
474
>
data.set('constructor', CompletionItemKind.Constructor);
475
>
data.set('field', CompletionItemKind.Field);
476
>
data.set('variable', CompletionItemKind.Variable);
477
>
data.set('class', CompletionItemKind.Class);
478
>
data.set('struct', CompletionItemKind.Struct);
479
>
data.set('interface', CompletionItemKind.Interface);
480
>
data.set('module', CompletionItemKind.Module);
481
>
data.set('property', CompletionItemKind.Property);
482
>
data.set('event', CompletionItemKind.Event);
483
>
data.set('operator', CompletionItemKind.Operator);
484
>
data.set('unit', CompletionItemKind.Unit);
485
>
data.set('value', CompletionItemKind.Value);
486
>
data.set('constant', CompletionItemKind.Constant);
487
>
data.set('enum', CompletionItemKind.Enum);
488
>
data.set('enum-member', CompletionItemKind.EnumMember);
489
>
data.set('enumMember', CompletionItemKind.EnumMember);
490
>
data.set('keyword', CompletionItemKind.Keyword);
491
>
data.set('snippet', CompletionItemKind.Snippet);
492
>
data.set('text', CompletionItemKind.Text);
493
>
data.set('color', CompletionItemKind.Color);
494
>
data.set('file', CompletionItemKind.File);
495
>
data.set('reference', CompletionItemKind.Reference);
496
>
data.set('customcolor', CompletionItemKind.Customcolor);
497
>
data.set('folder', CompletionItemKind.Folder);
498
>
data.set('type-parameter', CompletionItemKind.TypeParameter);
499
>
data.set('typeParameter', CompletionItemKind.TypeParameter);
500
>
data.set('account', CompletionItemKind.User);
501
>
data.set('issue', CompletionItemKind.Issue);
502
>
data.set('tool', CompletionItemKind.Tool);
503
>
504
>
/**
505
>
* @internal
506
>
*/
507
>
export function fromString(value: string): CompletionItemKind;
508
>
/**
509
>
* @internal
510
>
*/
511
>
export function fromString(value: string, strict: true): CompletionItemKind | undefined;
512
>
/**
513
>
* @internal
514
>
*/
515
>
export function fromString(value: string, strict?: boolean): CompletionItemKind | undefined {
516
let res = data.get(value);
517
if (typeof res === 'undefined' && !strict) {
518
res = CompletionItemKind.Property;
519
}
520
return res;
521
}
523
>
524
>
export interface CompletionItemLabel {
525
>
label: string;
526
>
detail?: string;
527
>
description?: string;
528
>
}
529
>
530
>
export const enum CompletionItemTag {
531
>
Deprecated = 1
532
>
}
533
>
534
>
export const enum CompletionItemInsertTextRule {
535
>
None = 0,
536
>
537
>
/**
538
>
* Adjust whitespace/indentation of multiline insert texts to
539
>
* match the current line indentation.
540
>
*/
541
>
KeepWhitespace = 0b001,
542
>
543
>
/**
544
>
* `insertText` is a snippet.
545
>
*/
546
>
InsertAsSnippet = 0b100,
547
>
}
548
>
549
>
export interface CompletionItemRanges {
550
>
insert: IRange;
551
>
replace: IRange;
552
>
}
553
>
554
>
/**
555
>
* A completion item represents a text snippet that is
556
>
* proposed to complete text that is being typed.
557
>
*/
558
>
export interface CompletionItem {
559
>
/**
560
>
* The label of this completion item. By default
561
>
* this is also the text that is inserted when selecting
562
>
* this completion.
563
>
*/
564
>
label: string | CompletionItemLabel;
565
>
/**
566
>
* The kind of this completion item. Based on the kind
567
>
* an icon is chosen by the editor.
568
>
*/
569
>
kind: CompletionItemKind;
570
>
/**
571
>
* A modifier to the `kind` which affect how the item
572
>
* is rendered, e.g. Deprecated is rendered with a strikeout
573
>
*/
574
>
tags?: ReadonlyArray<CompletionItemTag>;
575
>
/**
576
>
* A human-readable string with additional information
577
>
* about this item, like type or symbol information.
578
>
*/
579
>
detail?: string;
580
>
/**
581
>
* A human-readable string that represents a doc-comment.
582
>
*/
583
>
documentation?: string | IMarkdownString;
584
>
/**
585
>
* A string that should be used when comparing this item
586
>
* with other items. When `falsy` the {@link CompletionItem.label label}
587
>
* is used.
588
>
*/
589
>
sortText?: string;
590
>
/**
591
>
* A string that should be used when filtering a set of
592
>
* completion items. When `falsy` the {@link CompletionItem.label label}
593
>
* is used.
594
>
*/
595
>
filterText?: string;
596
>
/**
597
>
* Select this item when showing. *Note* that only one completion item can be selected and
598
>
* that the editor decides which item that is. The rule is that the *first* item of those
599
>
* that match best is selected.
600
>
*/
601
>
preselect?: boolean;
602
>
/**
603
>
* A string or snippet that should be inserted in a document when selecting
604
>
* this completion.
605
>
*/
606
>
insertText: string;
607
>
/**
608
>
* Additional rules (as bitmask) that should be applied when inserting
609
>
* this completion.
610
>
*/
611
>
insertTextRules?: CompletionItemInsertTextRule;
612
>
/**
613
>
* A range of text that should be replaced by this completion item.
614
>
*
615
>
* *Note:* The range must be a {@link Range.isSingleLine single line} and it must
616
>
* {@link Range.contains contain} the position at which completion has been {@link CompletionItemProvider.provideCompletionItems requested}.
617
>
*/
618
>
range: IRange | CompletionItemRanges;
619
>
/**
620
>
* An optional set of characters that when pressed while this completion is active will accept it first and
621
>
* then type that character. *Note* that all commit characters should have `length=1` and that superfluous
622
>
* characters will be ignored.
623
>
*/
624
>
commitCharacters?: string[];
625
>
/**
626
>
* An optional array of additional text edits that are applied when
627
>
* selecting this completion. Edits must not overlap with the main edit
628
>
* nor with themselves.
629
>
*/
630
>
additionalTextEdits?: ISingleEditOperation[];
631
>
/**
632
>
* A command that should be run upon acceptance of this item.
633
>
*/
634
>
command?: Command;
635
>
/**
636
>
* A command that should be run upon acceptance of this item.
637
>
*/
638
>
action?: Command;
639
>
/**
640
>
* @internal
641
>
*/
642
>
extensionId?: ExtensionIdentifier;
643
>
644
>
/**
645
>
* @internal
646
>
*/
647
>
_id?: [number, number];
648
>
}
649
>
650
>
export interface CompletionList {
651
>
suggestions: CompletionItem[];
652
>
incomplete?: boolean;
653
>
dispose?(): void;
654
>
655
>
/**
656
>
* @internal
657
>
*/
658
>
duration?: number;
659
>
}
660
>
661
>
/**
662
>
* Info provided on partial acceptance.
663
>
*/
664
>
export interface PartialAcceptInfo {
665
>
kind: PartialAcceptTriggerKind;
666
>
acceptedLength: number;
667
>
}
668
>
669
>
/**
670
>
* How a partial acceptance was triggered.
671
>
*/
672
>
export const enum PartialAcceptTriggerKind {
673
>
Word = 0,
674
>
Line = 1,
675
>
Suggest = 2,
676
>
}
677
>
678
>
/**
679
>
* How a suggest provider was triggered.
680
>
*/
681
>
export const enum CompletionTriggerKind {
682
>
Invoke = 0,
683
>
TriggerCharacter = 1,
684
>
TriggerForIncompleteCompletions = 2
685
>
}
686
>
/**
687
>
* Contains additional information about the context in which
688
>
* {@link CompletionItemProvider.provideCompletionItems completion provider} is triggered.
689
>
*/
690
>
export interface CompletionContext {
691
>
/**
692
>
* How the completion was triggered.
693
>
*/
694
>
triggerKind: CompletionTriggerKind;
695
>
/**
696
>
* Character that triggered the completion item provider.
697
>
*
698
>
* `undefined` if provider was not triggered by a character.
699
>
*/
700
>
triggerCharacter?: string;
701
>
}
702
>
/**
703
>
* The completion item provider interface defines the contract between extensions and
704
>
* the [IntelliSense](https://code.visualstudio.com/docs/editor/intellisense).
705
>
*
706
>
* When computing *complete* completion items is expensive, providers can optionally implement
707
>
* the `resolveCompletionItem`-function. In that case it is enough to return completion
708
>
* items with a {@link CompletionItem.label label} from the
709
>
* {@link CompletionItemProvider.provideCompletionItems provideCompletionItems}-function. Subsequently,
710
>
* when a completion item is shown in the UI and gains focus this provider is asked to resolve
711
>
* the item, like adding {@link CompletionItem.documentation doc-comment} or {@link CompletionItem.detail details}.
712
>
*/
713
>
export interface CompletionItemProvider {
714
>
715
>
/**
716
>
* Used to identify completions in the (debug) UI and telemetry. This isn't the extension identifier because extensions
717
>
* often contribute multiple completion item providers.
718
>
*
719
>
* @internal
720
>
*/
721
>
_debugDisplayName: string;
722
>
723
>
triggerCharacters?: string[];
724
>
/**
725
>
* Provide completion items for the given position and document.
726
>
*/
727
>
provideCompletionItems(model: model.ITextModel, position: Position, context: CompletionContext, token: CancellationToken): ProviderResult<CompletionList>;
728
>
729
>
/**
730
>
* Given a completion item fill in more data, like {@link CompletionItem.documentation doc-comment}
731
>
* or {@link CompletionItem.detail details}.
732
>
*
733
>
* The editor will only resolve a completion item once.
734
>
*/
735
>
resolveCompletionItem?(item: CompletionItem, token: CancellationToken): ProviderResult<CompletionItem>;
736
>
}
737
>
738
>
/**
739
>
* How an {@link InlineCompletionsProvider inline completion provider} was triggered.
740
>
*/
741
>
export enum InlineCompletionTriggerKind {
742
>
/**
743
>
* Completion was triggered automatically while editing.
744
>
* It is sufficient to return a single completion item in this case.
745
>
*/
746
>
Automatic = 0,
747
>
748
>
/**
749
>
* Completion was triggered explicitly by a user gesture.
750
>
* Return multiple completion items to enable cycling through them.
751
>
*/
752
>
Explicit = 1,
753
>
}
754
>
755
>
/**
756
>
* Arbitrary data that the provider can pass when firing {@link InlineCompletionsProvider.onDidChangeInlineCompletions}.
757
>
* This data is passed back to the provider in {@link InlineCompletionContext.changeHint}.
758
>
*/
759
>
export interface IInlineCompletionChangeHint {
760
>
/**
761
>
* Arbitrary data that the provider can use to identify what triggered the change.
762
>
* This data must be JSON serializable.
763
>
*/
764
>
readonly data?: unknown;
765
>
}
766
>
767
>
export interface InlineCompletionContext {
768
>
769
>
/**
770
>
* How the completion was triggered.
771
>
*/
772
>
readonly triggerKind: InlineCompletionTriggerKind;
773
>
readonly selectedSuggestionInfo: SelectedSuggestionInfo | undefined;
774
>
/**
775
>
* @experimental
776
>
* @internal
777
>
*/
778
>
readonly userPrompt?: string | undefined;
779
>
/**
780
>
* @experimental
781
>
* @internal
782
>
*/
783
>
readonly requestUuid: string;
784
>
785
>
readonly includeInlineEdits: boolean;
786
>
readonly includeInlineCompletions: boolean;
787
>
readonly requestIssuedDateTime: number;
788
>
readonly earliestShownDateTime: number;
789
>
790
>
/**
791
>
* The change hint that was passed to {@link InlineCompletionsProvider.onDidChangeInlineCompletions}.
792
>
* Only set if this request was triggered by such an event.
793
>
*/
794
>
readonly changeHint?: IInlineCompletionChangeHint;
795
>
}
796
>
797
>
export interface IInlineCompletionModelInfo {
798
>
models: IInlineCompletionModel[];
799
>
currentModelId: string;
800
>
}
801
>
802
>
export interface IInlineCompletionModel {
803
>
name: string;
804
>
id: string;
805
>
}
806
>
807
>
export interface IInlineCompletionProviderOption {
808
>
readonly id: string;
809
>
readonly label: string;
810
>
readonly values: readonly IInlineCompletionProviderOptionValue[];
811
>
readonly currentValueId: string;
812
>
}
813
>
814
>
export interface IInlineCompletionProviderOptionValue {
815
>
readonly id: string;
816
>
readonly label: string;
817
>
}
818
>
819
>
export class SelectedSuggestionInfo {
820
>
constructor(
821
public readonly range: IRange,
822
public readonly text: string,
823
public readonly completionKind: CompletionItemKind,
824
public readonly isSnippetText: boolean,
825
) {
826
}
828
>
public equals(other: SelectedSuggestionInfo): boolean {
829
return Range.lift(this.range).equalsRange(other.range)
830
&& this.text === other.text
831
&& this.completionKind === other.completionKind
832
&& this.isSnippetText === other.isSnippetText;
833
}
835
>
836
>
export interface InlineCompletion {
837
>
/**
838
>
* The text to insert.
839
>
* If the text contains a line break, the range must end at the end of a line.
840
>
* If existing text should be replaced, the existing text must be a prefix of the text to insert.
841
>
*
842
>
* The text can also be a snippet. In that case, a preview with default parameters is shown.
843
>
* When accepting the suggestion, the full snippet is inserted.
844
>
*/
845
>
readonly insertText: string | { snippet: string } | undefined;
846
>
847
>
/**
848
>
* The range to replace.
849
>
* Must begin and end on the same line.
850
>
* Refers to the current document or `uri` if provided.
851
>
*/
852
>
readonly range?: IRange;
853
>
854
>
/**
855
>
* An optional array of additional text edits that are applied when
856
>
* selecting this completion. Edits must not overlap with the main edit
857
>
* nor with themselves.
858
>
* Refers to the current document or `uri` if provided.
859
>
*/
860
>
readonly additionalTextEdits?: ISingleEditOperation[];
861
>
862
>
/**
863
>
* The file for which the edit applies to.
864
>
*/
865
>
readonly uri?: UriComponents;
866
>
867
>
/**
868
>
* A command that is run upon acceptance of this item.
869
>
*/
870
>
readonly command?: Command;
871
>
872
>
readonly gutterMenuLinkAction?: Command;
873
>
874
>
/**
875
>
* Is called the first time an inline completion is shown.
876
>
* @deprecated. Use `onDidShow` of the provider instead.
877
>
*/
878
>
readonly shownCommand?: Command;
879
>
880
>
/**
881
>
* If set to `true`, unopened closing brackets are removed and unclosed opening brackets are closed.
882
>
* Defaults to `false`.
883
>
*/
884
>
readonly completeBracketPairs?: boolean;
885
>
886
>
readonly isInlineEdit?: boolean;
887
>
readonly showInlineEditMenu?: boolean;
888
>
889
>
/** Only show the inline suggestion when the cursor is in the showRange. */
890
>
readonly showRange?: IRange;
891
>
892
>
readonly warning?: InlineCompletionWarning;
893
>
894
>
readonly hint?: IInlineCompletionHint;
895
>
896
>
readonly supportsRename?: boolean;
897
>
898
>
/**
899
>
* Used for telemetry.
900
>
*/
901
>
readonly correlationId?: string | undefined;
902
>
903
>
readonly jumpToPosition?: IPosition;
904
>
905
>
readonly doNotLog?: boolean;
906
>
}
907
>
908
>
export interface InlineCompletionWarning {
909
>
message: IMarkdownString | string;
910
>
icon?: IconPath;
911
>
}
912
>
913
>
export enum InlineCompletionHintStyle {
914
>
Code = 1,
915
>
Label = 2
916
>
}
917
>
918
>
export interface IInlineCompletionHint {
919
>
/** Refers to the current document. */
920
>
range: IRange;
921
>
style: InlineCompletionHintStyle;
922
>
content: string;
923
>
}
924
>
925
>
// TODO: add `| URI | { light: URI; dark: URI }`.
926
>
export type IconPath = ThemeIcon;
927
>
928
>
export interface InlineCompletions<TItem extends InlineCompletion = InlineCompletion> {
929
>
readonly items: readonly TItem[];
930
>
/**
931
>
* A list of commands associated with the inline completions of this list.
932
>
*/
933
>
readonly commands?: InlineCompletionCommand[];
934
>
935
>
readonly suppressSuggestions?: boolean | undefined;
936
>
937
>
/**
938
>
* When set and the user types a suggestion without derivating from it, the inline suggestion is not updated.
939
>
*/
940
>
readonly enableForwardStability?: boolean | undefined;
941
>
}
942
>
943
>
export type InlineCompletionCommand = { command: Command; icon?: ThemeIcon };
944
>
945
>
export type InlineCompletionProviderGroupId = string;
946
>
947
>
export interface InlineCompletionsProvider<T extends InlineCompletions = InlineCompletions> {
948
>
provideInlineCompletions(model: model.ITextModel, position: Position, context: InlineCompletionContext, token: CancellationToken): ProviderResult<T>;
949
>
950
>
/**
951
>
* Will be called when an item is shown.
952
>
* @param updatedInsertText Is useful to understand bracket completion.
953
>
*/
954
>
handleItemDidShow?(completions: T, item: T['items'][number], updatedInsertText: string, editDeltaInfo: EditDeltaInfo): void;
955
>
956
>
/**
957
>
* Will be called when an item is partially accepted. TODO: also handle full acceptance here!
958
>
* @param acceptedCharacters Deprecated. Use `info.acceptedCharacters` instead.
959
>
*/
960
>
handlePartialAccept?(completions: T, item: T['items'][number], acceptedCharacters: number, info: PartialAcceptInfo): void;
961
>
962
>
/**
963
>
* @deprecated Use `handleEndOfLifetime` instead.
964
>
*/
965
>
handleRejection?(completions: T, item: T['items'][number]): void;
966
>
967
>
/**
968
>
* Is called when an inline completion item is no longer being used.
969
>
* Provides a reason of why it is not used anymore.
970
>
*/
971
>
handleEndOfLifetime?(completions: T, item: T['items'][number], reason: InlineCompletionEndOfLifeReason<T['items'][number]>, lifetimeSummary: LifetimeSummary): void;
972
>
973
>
/**
974
>
* Will be called when a completions list is no longer in use and can be garbage-collected.
975
>
*/
976
>
disposeInlineCompletions(completions: T, reason: InlineCompletionsDisposeReason): void;
977
>
978
>
/**
979
>
* Fired when the provider wants to trigger a new completion request.
980
>
* The event can pass a {@link IInlineCompletionChangeHint} which will be
981
>
* included in the {@link InlineCompletionContext} of the subsequent request.
982
>
*/
983
>
onDidChangeInlineCompletions?: Event<IInlineCompletionChangeHint | void>;
984
>
985
>
/**
986
>
* Only used for {@link yieldsToGroupIds}.
987
>
* Multiple providers can have the same group id.
988
>
*/
989
>
groupId?: InlineCompletionProviderGroupId;
990
>
991
>
/** @internal */
992
>
providerId?: ProviderId;
993
>
994
>
/**
995
>
* Returns a list of preferred provider {@link groupId}s.
996
>
* The current provider is only requested for completions if no provider with a preferred group id returned a result.
997
>
*/
998
>
yieldsToGroupIds?: InlineCompletionProviderGroupId[];
999
>
1000
>
excludesGroupIds?: InlineCompletionProviderGroupId[];
1001
>
1002
>
displayName?: string;
1003
>
1004
>
debounceDelayMs?: number;
1005
>
1006
>
modelInfo?: IInlineCompletionModelInfo;
1007
>
onDidModelInfoChange?: Event<void>;
1008
>
setModelId?(modelId: string): Promise<void>;
1009
>
1010
>
providerOptions?: readonly IInlineCompletionProviderOption[];
1011
>
onDidProviderOptionsChange?: Event<void>;
1012
>
setProviderOption?(optionId: string, valueId: string): Promise<void>;
1013
>
1014
>
toString?(): string;
1015
>
}
1016
>
1017
>
1018
>
/** @internal */
1019
>
export class ProviderId {
1020
>
public static fromExtensionId(extensionId: string | undefined): ProviderId {
1021
>
return new ProviderId(extensionId, undefined, undefined);
1022
>
}
1023
>
1024
>
constructor(
1025
public readonly extensionId: string | undefined,
1026
public readonly extensionVersion: string | undefined,
1027
public readonly providerId: string | undefined
1028
) {
1029
}
1031
>
toString(): string {
1032
let result = '';
1033
if (this.extensionId) {
1034
result += this.extensionId;
1035
}
1036
if (this.extensionVersion) {
1037
result += `@${this.extensionVersion}`;
1038
}
1039
if (this.providerId) {
1040
result += `:${this.providerId}`;
1041
}
1042
if (result.length === 0) {
1043
result = 'unknown';
1044
}
1045
return result;
1046
}
1048
>
toStringWithoutVersion(): string {
1049
let result = '';
1050
if (this.extensionId) {
1051
result += this.extensionId;
1052
}
1053
if (this.providerId) {
1054
result += `:${this.providerId}`;
1055
}
1056
return result;
1057
}
1059
>
1060
>
/** @internal */
1061
>
export class VersionedExtensionId {
1062
>
public static tryCreate(extensionId: string | undefined, version: string | undefined): VersionedExtensionId | undefined {
1063
>
if (!extensionId || !version) {
1064
>
return undefined;
1065
>
}
1066
>
return new VersionedExtensionId(extensionId, version);
1067
>
}
1068
>
1069
>
constructor(
1070
public readonly extensionId: string,
1071
public readonly version: string,
1072
) { }
1074
>
toString(): string {
1075
return `${this.extensionId}@${this.version}`;
1076
}
1078
>
1079
>
export type InlineCompletionsDisposeReason = { kind: 'lostRace' | 'tokenCancellation' | 'other' | 'empty' | 'notTaken' };
1080
>
1081
>
export enum InlineCompletionEndOfLifeReasonKind {
1082
>
Accepted = 0,
1083
>
Rejected = 1,
1084
>
Ignored = 2,
1085
>
}
1086
>
1087
>
export type InlineCompletionEndOfLifeReason<TInlineCompletion = InlineCompletion> = {
1088
>
kind: InlineCompletionEndOfLifeReasonKind.Accepted; // User did an explicit action to accept
1089
>
alternativeAction: boolean; // Whether the user performed an alternative action.
1090
>
} | {
1091
>
kind: InlineCompletionEndOfLifeReasonKind.Rejected; // User did an explicit action to reject
1092
>
} | {
1093
>
kind: InlineCompletionEndOfLifeReasonKind.Ignored;
1094
>
supersededBy?: TInlineCompletion;
1095
>
userTypingDisagreed: boolean;
1096
>
};
1097
>
1098
>
export type LifetimeSummary = {
1099
>
requestUuid: string;
1100
>
correlationId: string | undefined;
1101
>
partiallyAccepted: number;
1102
>
partiallyAcceptedCountSinceOriginal: number;
1103
>
partiallyAcceptedRatioSinceOriginal: number;
1104
>
partiallyAcceptedCharactersSinceOriginal: number;
1105
>
shown: boolean;
1106
>
shownDuration: number;
1107
>
shownDurationUncollapsed: number;
1108
>
timeUntilShown: number | undefined;
1109
>
timeUntilActuallyShown: number | undefined;
1110
>
timeUntilProviderRequest: number;
1111
>
timeUntilProviderResponse: number;
1112
>
notShownReason: string | undefined;
1113
>
editorType: string;
1114
>
viewKind: string | undefined;
1115
>
preceeded: boolean;
1116
>
languageId: string;
1117
>
requestReason: string;
1118
>
performanceMarkers?: string;
1119
>
cursorColumnDistance?: number;
1120
>
cursorLineDistance?: number;
1121
>
lineCountOriginal?: number;
1122
>
lineCountModified?: number;
1123
>
characterCountOriginal?: number;
1124
>
characterCountModified?: number;
1125
>
disjointReplacements?: number;
1126
>
sameShapeReplacements?: boolean;
1127
>
typingInterval: number;
1128
>
typingIntervalCharacterCount: number;
1129
>
selectedSuggestionInfo: boolean;
1130
>
availableProviders: string;
1131
>
skuPlan: string | undefined;
1132
>
skuType: string | undefined;
1133
>
renameCreated: boolean | undefined;
1134
>
renameDuration: number | undefined;
1135
>
renameTimedOut: boolean | undefined;
1136
>
renameDroppedOtherEdits: number | undefined;
1137
>
renameDroppedRenameEdits: number | undefined;
1138
>
editKind: string | undefined;
1139
>
longDistanceHintVisible?: boolean;
1140
>
longDistanceHintDistance?: number;
1141
>
isForAnotherDocument?: boolean;
1142
>
};
1143
>
1144
>
export interface CodeAction {
1145
>
title: string;
1146
>
command?: Command;
1147
>
edit?: WorkspaceEdit;
1148
>
diagnostics?: IMarkerData[];
1149
>
kind?: string;
1150
>
isPreferred?: boolean;
1151
>
isAI?: boolean;
1152
>
disabled?: string;
1153
>
ranges?: IRange[];
1154
>
}
1155
>
1156
>
export const enum CodeActionTriggerType {
1157
>
Invoke = 1,
1158
>
Auto = 2,
1159
>
}
1160
>
1161
>
/**
1162
>
* @internal
1163
>
*/
1164
>
export interface CodeActionContext {
1165
>
only?: string;
1166
>
trigger: CodeActionTriggerType;
1167
>
}
1168
>
1169
>
export interface CodeActionList extends IDisposable {
1170
>
readonly actions: ReadonlyArray<CodeAction>;
1171
>
}
1172
>
1173
>
/**
1174
>
* The code action interface defines the contract between extensions and
1175
>
* the [light bulb](https://code.visualstudio.com/docs/editor/editingevolved#_code-action) feature.
1176
>
* @internal
1177
>
*/
1178
>
export interface CodeActionProvider {
1179
>
1180
>
displayName?: string;
1181
>
1182
>
extensionId?: string;
1183
>
1184
>
/**
1185
>
* Provide commands for the given document and range.
1186
>
*/
1187
>
provideCodeActions(model: model.ITextModel, range: Range | Selection, context: CodeActionContext, token: CancellationToken): ProviderResult<CodeActionList>;
1188
>
1189
>
/**
1190
>
* Given a code action fill in the edit. Will only invoked when missing.
1191
>
*/
1192
>
resolveCodeAction?(codeAction: CodeAction, token: CancellationToken): ProviderResult<CodeAction>;
1193
>
1194
>
/**
1195
>
* Optional list of CodeActionKinds that this provider returns.
1196
>
*/
1197
>
readonly providedCodeActionKinds?: ReadonlyArray<string>;
1198
>
1199
>
readonly documentation?: ReadonlyArray<{ readonly kind: string; readonly command: Command }>;
1200
>
1201
>
/**
1202
>
* @internal
1203
>
*/
1204
>
_getAdditionalMenuItems?(context: CodeActionContext, actions: readonly CodeAction[]): Command[];
1205
>
}
1206
>
1207
>
/**
1208
>
* @internal
1209
>
*/
1210
>
export interface DocumentPasteEdit {
1211
>
readonly title: string;
1212
>
readonly kind: HierarchicalKind;
1213
>
readonly handledMimeType?: string;
1214
>
yieldTo?: readonly DropYieldTo[];
1215
>
insertText: string | { readonly snippet: string };
1216
>
additionalEdit?: WorkspaceEdit;
1217
>
}
1218
>
1219
>
/**
1220
>
* @internal
1221
>
*/
1222
>
export enum DocumentPasteTriggerKind {
1223
>
Automatic = 0,
1224
>
PasteAs = 1,
1225
>
}
1226
>
1227
>
/**
1228
>
* @internal
1229
>
*/
1230
>
export interface DocumentPasteContext {
1231
>
readonly only?: HierarchicalKind;
1232
>
readonly triggerKind: DocumentPasteTriggerKind;
1233
>
}
1234
>
1235
>
/**
1236
>
* @internal
1237
>
*/
1238
>
export interface DocumentPasteEditsSession {
1239
>
edits: readonly DocumentPasteEdit[];
1240
>
dispose(): void;
1241
>
}
1242
>
1243
>
/**
1244
>
* @internal
1245
>
*/
1246
>
export interface DocumentPasteEditProvider {
1247
>
readonly id?: string;
1248
>
readonly copyMimeTypes: readonly string[];
1249
>
readonly pasteMimeTypes: readonly string[];
1250
>
readonly providedPasteEditKinds: readonly HierarchicalKind[];
1251
>
1252
>
prepareDocumentPaste?(model: model.ITextModel, ranges: readonly IRange[], dataTransfer: IReadonlyVSDataTransfer, token: CancellationToken): Promise<undefined | IReadonlyVSDataTransfer>;
1253
>
1254
>
provideDocumentPasteEdits?(model: model.ITextModel, ranges: readonly IRange[], dataTransfer: IReadonlyVSDataTransfer, context: DocumentPasteContext, token: CancellationToken): Promise<DocumentPasteEditsSession | undefined>;
1255
>
1256
>
resolveDocumentPasteEdit?(edit: DocumentPasteEdit, token: CancellationToken): Promise<DocumentPasteEdit>;
1257
>
}
1258
>
1259
>
/**
1260
>
* Represents a parameter of a callable-signature. A parameter can
1261
>
* have a label and a doc-comment.
1262
>
*/
1263
>
export interface ParameterInformation {
1264
>
/**
1265
>
* The label of this signature. Will be shown in
1266
>
* the UI.
1267
>
*/
1268
>
label: string | [number, number];
1269
>
/**
1270
>
* The human-readable doc-comment of this signature. Will be shown
1271
>
* in the UI but can be omitted.
1272
>
*/
1273
>
documentation?: string | IMarkdownString;
1274
>
}
1275
>
/**
1276
>
* Represents the signature of something callable. A signature
1277
>
* can have a label, like a function-name, a doc-comment, and
1278
>
* a set of parameters.
1279
>
*/
1280
>
export interface SignatureInformation {
1281
>
/**
1282
>
* The label of this signature. Will be shown in
1283
>
* the UI.
1284
>
*/
1285
>
label: string;
1286
>
/**
1287
>
* The human-readable doc-comment of this signature. Will be shown
1288
>
* in the UI but can be omitted.
1289
>
*/
1290
>
documentation?: string | IMarkdownString;
1291
>
/**
1292
>
* The parameters of this signature.
1293
>
*/
1294
>
parameters: ParameterInformation[];
1295
>
/**
1296
>
* Index of the active parameter.
1297
>
*
1298
>
* If provided, this is used in place of `SignatureHelp.activeSignature`.
1299
>
*/
1300
>
activeParameter?: number;
1301
>
}
1302
>
/**
1303
>
* Signature help represents the signature of something
1304
>
* callable. There can be multiple signatures but only one
1305
>
* active and only one active parameter.
1306
>
*/
1307
>
export interface SignatureHelp {
1308
>
/**
1309
>
* One or more signatures.
1310
>
*/
1311
>
signatures: SignatureInformation[];
1312
>
/**
1313
>
* The active signature.
1314
>
*/
1315
>
activeSignature: number;
1316
>
/**
1317
>
* The active parameter of the active signature.
1318
>
*/
1319
>
activeParameter: number;
1320
>
}
1321
>
1322
>
export interface SignatureHelpResult extends IDisposable {
1323
>
value: SignatureHelp;
1324
>
}
1325
>
1326
>
export enum SignatureHelpTriggerKind {
1327
>
Invoke = 1,
1328
>
TriggerCharacter = 2,
1329
>
ContentChange = 3,
1330
>
}
1331
>
1332
>
export interface SignatureHelpContext {
1333
>
readonly triggerKind: SignatureHelpTriggerKind;
1334
>
readonly triggerCharacter?: string;
1335
>
readonly isRetrigger: boolean;
1336
>
readonly activeSignatureHelp?: SignatureHelp;
1337
>
}
1338
>
1339
>
/**
1340
>
* The signature help provider interface defines the contract between extensions and
1341
>
* the [parameter hints](https://code.visualstudio.com/docs/editor/intellisense)-feature.
1342
>
*/
1343
>
export interface SignatureHelpProvider {
1344
>
1345
>
readonly signatureHelpTriggerCharacters?: ReadonlyArray<string>;
1346
>
readonly signatureHelpRetriggerCharacters?: ReadonlyArray<string>;
1347
>
1348
>
/**
1349
>
* Provide help for the signature at the given position and document.
1350
>
*/
1351
>
provideSignatureHelp(model: model.ITextModel, position: Position, token: CancellationToken, context: SignatureHelpContext): ProviderResult<SignatureHelpResult>;
1352
>
}
1353
>
1354
>
/**
1355
>
* A document highlight kind.
1356
>
*/
1357
>
export enum DocumentHighlightKind {
1358
>
/**
1359
>
* A textual occurrence.
1360
>
*/
1361
>
Text,
1362
>
/**
1363
>
* Read-access of a symbol, like reading a variable.
1364
>
*/
1365
>
Read,
1366
>
/**
1367
>
* Write-access of a symbol, like writing to a variable.
1368
>
*/
1369
>
Write
1370
>
}
1371
>
/**
1372
>
* A document highlight is a range inside a text document which deserves
1373
>
* special attention. Usually a document highlight is visualized by changing
1374
>
* the background color of its range.
1375
>
*/
1376
>
export interface DocumentHighlight {
1377
>
/**
1378
>
* The range this highlight applies to.
1379
>
*/
1380
>
range: IRange;
1381
>
/**
1382
>
* The highlight kind, default is {@link DocumentHighlightKind.Text text}.
1383
>
*/
1384
>
kind?: DocumentHighlightKind;
1385
>
}
1386
>
1387
>
/**
1388
>
* Represents a set of document highlights for a specific URI.
1389
>
*/
1390
>
export interface MultiDocumentHighlight {
1391
>
/**
1392
>
* The URI of the document that the highlights belong to.
1393
>
*/
1394
>
uri: URI;
1395
>
1396
>
/**
1397
>
* The set of highlights for the document.
1398
>
*/
1399
>
highlights: DocumentHighlight[];
1400
>
}
1401
>
1402
>
/**
1403
>
* The document highlight provider interface defines the contract between extensions and
1404
>
* the word-highlight-feature.
1405
>
*/
1406
>
export interface DocumentHighlightProvider {
1407
>
/**
1408
>
* Provide a set of document highlights, like all occurrences of a variable or
1409
>
* all exit-points of a function.
1410
>
*/
1411
>
provideDocumentHighlights(model: model.ITextModel, position: Position, token: CancellationToken): ProviderResult<DocumentHighlight[]>;
1412
>
}
1413
>
1414
>
/**
1415
>
* A provider that can provide document highlights across multiple documents.
1416
>
*/
1417
>
export interface MultiDocumentHighlightProvider {
1418
>
readonly selector: LanguageSelector;
1419
>
1420
>
/**
1421
>
* Provide a Map of URI --> document highlights, like all occurrences of a variable or
1422
>
* all exit-points of a function.
1423
>
*
1424
>
* Used in cases such as split view, notebooks, etc. where there can be multiple documents
1425
>
* with shared symbols.
1426
>
*
1427
>
* @param primaryModel The primary text model.
1428
>
* @param position The position at which to provide document highlights.
1429
>
* @param otherModels The other text models to search for document highlights.
1430
>
* @param token A cancellation token.
1431
>
* @returns A map of URI to document highlights.
1432
>
*/
1433
>
provideMultiDocumentHighlights(primaryModel: model.ITextModel, position: Position, otherModels: model.ITextModel[], token: CancellationToken): ProviderResult<Map<URI, DocumentHighlight[]>>;
1434
>
}
1435
>
1436
>
/**
1437
>
* The linked editing range provider interface defines the contract between extensions and
1438
>
* the linked editing feature.
1439
>
*/
1440
>
export interface LinkedEditingRangeProvider {
1441
>
1442
>
/**
1443
>
* Provide a list of ranges that can be edited together.
1444
>
*/
1445
>
provideLinkedEditingRanges(model: model.ITextModel, position: Position, token: CancellationToken): ProviderResult<LinkedEditingRanges>;
1446
>
}
1447
>
1448
>
/**
1449
>
* Represents a list of ranges that can be edited together along with a word pattern to describe valid contents.
1450
>
*/
1451
>
export interface LinkedEditingRanges {
1452
>
/**
1453
>
* A list of ranges that can be edited together. The ranges must have
1454
>
* identical length and text content. The ranges cannot overlap
1455
>
*/
1456
>
ranges: IRange[];
1457
>
1458
>
/**
1459
>
* An optional word pattern that describes valid contents for the given ranges.
1460
>
* If no pattern is provided, the language configuration's word pattern will be used.
1461
>
*/
1462
>
wordPattern?: RegExp;
1463
>
}
1464
>
1465
>
/**
1466
>
* Value-object that contains additional information when
1467
>
* requesting references.
1468
>
*/
1469
>
export interface ReferenceContext {
1470
>
/**
1471
>
* Include the declaration of the current symbol.
1472
>
*/
1473
>
includeDeclaration: boolean;
1474
>
}
1475
>
/**
1476
>
* The reference provider interface defines the contract between extensions and
1477
>
* the [find references](https://code.visualstudio.com/docs/editor/editingevolved#_peek)-feature.
1478
>
*/
1479
>
export interface ReferenceProvider {
1480
>
/**
1481
>
* Provide a set of project-wide references for the given position and document.
1482
>
*/
1483
>
provideReferences(model: model.ITextModel, position: Position, context: ReferenceContext, token: CancellationToken): ProviderResult<Location[]>;
1484
>
}
1485
>
1486
>
/**
1487
>
* Represents a location inside a resource, such as a line
1488
>
* inside a text file.
1489
>
*/
1490
>
export interface Location {
1491
>
/**
1492
>
* The resource identifier of this location.
1493
>
*/
1494
>
uri: URI;
1495
>
/**
1496
>
* The document range of this locations.
1497
>
*/
1498
>
range: IRange;
1499
>
}
1500
>
1501
>
export interface LocationLink {
1502
>
/**
1503
>
* A range to select where this link originates from.
1504
>
*/
1505
>
originSelectionRange?: IRange;
1506
>
1507
>
/**
1508
>
* The target uri this link points to.
1509
>
*/
1510
>
uri: URI;
1511
>
1512
>
/**
1513
>
* The full range this link points to.
1514
>
*/
1515
>
range: IRange;
1516
>
1517
>
/**
1518
>
* A range to select this link points to. Must be contained
1519
>
* in `LocationLink.range`.
1520
>
*/
1521
>
targetSelectionRange?: IRange;
1522
>
}
1523
>
1524
>
/**
1525
>
* @internal
1526
>
*/
1527
>
export function isLocationLink(thing: unknown): thing is LocationLink {
1528
return !!thing
1529
&& URI.isUri((thing as LocationLink).uri)
1530
&& Range.isIRange((thing as LocationLink).range)
1531
&& (Range.isIRange((thing as LocationLink).originSelectionRange) || Range.isIRange((thing as LocationLink).targetSelectionRange));
1532
}
1534
>
/**
1535
>
* @internal
1536
>
*/
1537
>
export function isLocation(thing: unknown): thing is Location {
1539
>
&& URI.isUri((thing as Location).uri)
1540
>
&& Range.isIRange((thing as Location).range);
1541
>
}
1543
>
1544
>
export type Definition = Location | Location[] | LocationLink[];
1545
>
1546
>
/**
1547
>
* The definition provider interface defines the contract between extensions and
1548
>
* the [go to definition](https://code.visualstudio.com/docs/editor/editingevolved#_go-to-definition)
1549
>
* and peek definition features.
1550
>
*/
1551
>
export interface DefinitionProvider {
1552
>
/**
1553
>
* Provide the definition of the symbol at the given position and document.
1554
>
*/
1555
>
provideDefinition(model: model.ITextModel, position: Position, token: CancellationToken): ProviderResult<Definition | LocationLink[]>;
1556
>
}
1557
>
1558
>
/**
1559
>
* The definition provider interface defines the contract between extensions and
1560
>
* the [go to definition](https://code.visualstudio.com/docs/editor/editingevolved#_go-to-definition)
1561
>
* and peek definition features.
1562
>
*/
1563
>
export interface DeclarationProvider {
1564
>
/**
1565
>
* Provide the declaration of the symbol at the given position and document.
1566
>
*/
1567
>
provideDeclaration(model: model.ITextModel, position: Position, token: CancellationToken): ProviderResult<Definition | LocationLink[]>;
1568
>
}
1569
>
1570
>
/**
1571
>
* The implementation provider interface defines the contract between extensions and
1572
>
* the go to implementation feature.
1573
>
*/
1574
>
export interface ImplementationProvider {
1575
>
/**
1576
>
* Provide the implementation of the symbol at the given position and document.
1577
>
*/
1578
>
provideImplementation(model: model.ITextModel, position: Position, token: CancellationToken): ProviderResult<Definition | LocationLink[]>;
1579
>
}
1580
>
1581
>
/**
1582
>
* The type definition provider interface defines the contract between extensions and
1583
>
* the go to type definition feature.
1584
>
*/
1585
>
export interface TypeDefinitionProvider {
1586
>
/**
1587
>
* Provide the type definition of the symbol at the given position and document.
1588
>
*/
1589
>
provideTypeDefinition(model: model.ITextModel, position: Position, token: CancellationToken): ProviderResult<Definition | LocationLink[]>;
1590
>
}
1591
>
1592
>
/**
1593
>
* A symbol kind.
1594
>
*/
1595
>
export const enum SymbolKind {
1596
>
File = 0,
1597
>
Module = 1,
1598
>
Namespace = 2,
1599
>
Package = 3,
1600
>
Class = 4,
1601
>
Method = 5,
1602
>
Property = 6,
1603
>
Field = 7,
1604
>
Constructor = 8,
1605
>
Enum = 9,
1606
>
Interface = 10,
1607
>
Function = 11,
1608
>
Variable = 12,
1609
>
Constant = 13,
1610
>
String = 14,
1611
>
Number = 15,
1612
>
Boolean = 16,
1613
>
Array = 17,
1614
>
Object = 18,
1615
>
Key = 19,
1616
>
Null = 20,
1617
>
EnumMember = 21,
1618
>
Struct = 22,
1619
>
Event = 23,
1620
>
Operator = 24,
1621
>
TypeParameter = 25
1622
>
}
1623
>
1624
>
/**
1625
>
* @internal
1626
>
*/
1627
>
export const symbolKindNames: { [symbol: number]: string } = {
1628
>
[SymbolKind.Array]: localize('Array', "array"),
1629
>
[SymbolKind.Boolean]: localize('Boolean', "boolean"),
1630
>
[SymbolKind.Class]: localize('Class', "class"),
1631
>
[SymbolKind.Constant]: localize('Constant', "constant"),
1632
>
[SymbolKind.Constructor]: localize('Constructor', "constructor"),
1633
>
[SymbolKind.Enum]: localize('Enum', "enumeration"),
1634
>
[SymbolKind.EnumMember]: localize('EnumMember', "enumeration member"),
1635
>
[SymbolKind.Event]: localize('Event', "event"),
1636
>
[SymbolKind.Field]: localize('Field', "field"),
1637
>
[SymbolKind.File]: localize('File', "file"),
1638
>
[SymbolKind.Function]: localize('Function', "function"),
1639
>
[SymbolKind.Interface]: localize('Interface', "interface"),
1640
>
[SymbolKind.Key]: localize('Key', "key"),
1641
>
[SymbolKind.Method]: localize('Method', "method"),
1642
>
[SymbolKind.Module]: localize('Module', "module"),
1643
>
[SymbolKind.Namespace]: localize('Namespace', "namespace"),
1644
>
[SymbolKind.Null]: localize('Null', "null"),
1645
>
[SymbolKind.Number]: localize('Number', "number"),
1646
>
[SymbolKind.Object]: localize('Object', "object"),
1647
>
[SymbolKind.Operator]: localize('Operator', "operator"),
1648
>
[SymbolKind.Package]: localize('Package', "package"),
1649
>
[SymbolKind.Property]: localize('Property', "property"),
1650
>
[SymbolKind.String]: localize('String', "string"),
1651
>
[SymbolKind.Struct]: localize('Struct', "struct"),
1652
>
[SymbolKind.TypeParameter]: localize('TypeParameter', "type parameter"),
1653
>
[SymbolKind.Variable]: localize('Variable', "variable"),
1654
>
};
1655
>
1656
>
/**
1657
>
* @internal
1658
>
*/
1659
>
export function getAriaLabelForSymbol(symbolName: string, kind: SymbolKind): string {
1660
return localize('symbolAriaLabel', '{0} ({1})', symbolName, symbolKindNames[kind]);
1661
}
1663
>
export const enum SymbolTag {
1664
>
Deprecated = 1,
1665
>
}
1666
>
1667
>
/**
1668
>
* @internal
1669
>
*/
1670
>
export namespace SymbolKinds {
1671
>
1672
>
const byKind = new Map<SymbolKind, ThemeIcon>();
1673
>
byKind.set(SymbolKind.File, Codicon.symbolFile);
1674
>
byKind.set(SymbolKind.Module, Codicon.symbolModule);
1675
>
byKind.set(SymbolKind.Namespace, Codicon.symbolNamespace);
1676
>
byKind.set(SymbolKind.Package, Codicon.symbolPackage);
1677
>
byKind.set(SymbolKind.Class, Codicon.symbolClass);
1678
>
byKind.set(SymbolKind.Method, Codicon.symbolMethod);
1679
>
byKind.set(SymbolKind.Property, Codicon.symbolProperty);
1680
>
byKind.set(SymbolKind.Field, Codicon.symbolField);
1681
>
byKind.set(SymbolKind.Constructor, Codicon.symbolConstructor);
1682
>
byKind.set(SymbolKind.Enum, Codicon.symbolEnum);
1683
>
byKind.set(SymbolKind.Interface, Codicon.symbolInterface);
1684
>
byKind.set(SymbolKind.Function, Codicon.symbolFunction);
1685
>
byKind.set(SymbolKind.Variable, Codicon.symbolVariable);
1686
>
byKind.set(SymbolKind.Constant, Codicon.symbolConstant);
1687
>
byKind.set(SymbolKind.String, Codicon.symbolString);
1688
>
byKind.set(SymbolKind.Number, Codicon.symbolNumber);
1689
>
byKind.set(SymbolKind.Boolean, Codicon.symbolBoolean);
1690
>
byKind.set(SymbolKind.Array, Codicon.symbolArray);
1691
>
byKind.set(SymbolKind.Object, Codicon.symbolObject);
1692
>
byKind.set(SymbolKind.Key, Codicon.symbolKey);
1693
>
byKind.set(SymbolKind.Null, Codicon.symbolNull);
1694
>
byKind.set(SymbolKind.EnumMember, Codicon.symbolEnumMember);
1695
>
byKind.set(SymbolKind.Struct, Codicon.symbolStruct);
1696
>
byKind.set(SymbolKind.Event, Codicon.symbolEvent);
1697
>
byKind.set(SymbolKind.Operator, Codicon.symbolOperator);
1698
>
byKind.set(SymbolKind.TypeParameter, Codicon.symbolTypeParameter);
1699
>
/**
1700
>
* @internal
1701
>
*/
1702
>
export function toIcon(kind: SymbolKind): ThemeIcon {
1703
let icon = byKind.get(kind);
1704
if (!icon) {
1705
console.info('No codicon found for SymbolKind ' + kind);
1706
icon = Codicon.symbolProperty;
1707
}
1708
return icon;
1709
}
1711
>
const byCompletionKind = new Map<SymbolKind, CompletionItemKind>();
1712
>
byCompletionKind.set(SymbolKind.File, CompletionItemKind.File);
1713
>
byCompletionKind.set(SymbolKind.Module, CompletionItemKind.Module);
1714
>
byCompletionKind.set(SymbolKind.Namespace, CompletionItemKind.Module);
1715
>
byCompletionKind.set(SymbolKind.Package, CompletionItemKind.Module);
1716
>
byCompletionKind.set(SymbolKind.Class, CompletionItemKind.Class);
1717
>
byCompletionKind.set(SymbolKind.Method, CompletionItemKind.Method);
1718
>
byCompletionKind.set(SymbolKind.Property, CompletionItemKind.Property);
1719
>
byCompletionKind.set(SymbolKind.Field, CompletionItemKind.Field);
1720
>
byCompletionKind.set(SymbolKind.Constructor, CompletionItemKind.Constructor);
1721
>
byCompletionKind.set(SymbolKind.Enum, CompletionItemKind.Enum);
1722
>
byCompletionKind.set(SymbolKind.Interface, CompletionItemKind.Interface);
1723
>
byCompletionKind.set(SymbolKind.Function, CompletionItemKind.Function);
1724
>
byCompletionKind.set(SymbolKind.Variable, CompletionItemKind.Variable);
1725
>
byCompletionKind.set(SymbolKind.Constant, CompletionItemKind.Constant);
1726
>
byCompletionKind.set(SymbolKind.String, CompletionItemKind.Text);
1727
>
byCompletionKind.set(SymbolKind.Number, CompletionItemKind.Value);
1728
>
byCompletionKind.set(SymbolKind.Boolean, CompletionItemKind.Value);
1729
>
byCompletionKind.set(SymbolKind.Array, CompletionItemKind.Value);
1730
>
byCompletionKind.set(SymbolKind.Object, CompletionItemKind.Value);
1731
>
byCompletionKind.set(SymbolKind.Key, CompletionItemKind.Keyword);
1732
>
byCompletionKind.set(SymbolKind.Null, CompletionItemKind.Value);
1733
>
byCompletionKind.set(SymbolKind.EnumMember, CompletionItemKind.EnumMember);
1734
>
byCompletionKind.set(SymbolKind.Struct, CompletionItemKind.Struct);
1735
>
byCompletionKind.set(SymbolKind.Event, CompletionItemKind.Event);
1736
>
byCompletionKind.set(SymbolKind.Operator, CompletionItemKind.Operator);
1737
>
byCompletionKind.set(SymbolKind.TypeParameter, CompletionItemKind.TypeParameter);
1738
>
/**
1739
>
* @internal
1740
>
*/
1741
>
export function toCompletionKind(kind: SymbolKind): CompletionItemKind {
1742
let completionKind = byCompletionKind.get(kind);
1743
if (completionKind === undefined) {
1744
console.info('No completion kind found for SymbolKind ' + kind);
1745
completionKind = CompletionItemKind.File;
1746
}
1747
return completionKind;
1748
}
1750
>
1751
>
export interface DocumentSymbol {
1752
>
name: string;
1753
>
detail: string;
1754
>
kind: SymbolKind;
1755
>
tags: ReadonlyArray<SymbolTag>;
1756
>
containerName?: string;
1757
>
range: IRange;
1758
>
selectionRange: IRange;
1759
>
children?: DocumentSymbol[];
1760
>
}
1761
>
1762
>
/**
1763
>
* The document symbol provider interface defines the contract between extensions and
1764
>
* the [go to symbol](https://code.visualstudio.com/docs/editor/editingevolved#_go-to-symbol)-feature.
1765
>
*/
1766
>
export interface DocumentSymbolProvider {
1767
>
1768
>
displayName?: string;
1769
>
1770
>
/**
1771
>
* Provide symbol information for the given document.
1772
>
*/
1773
>
provideDocumentSymbols(model: model.ITextModel, token: CancellationToken): ProviderResult<DocumentSymbol[]>;
1774
>
}
1775
>
1776
>
export interface TextEdit {
1777
>
range: IRange;
1778
>
text: string;
1779
>
eol?: model.EndOfLineSequence;
1780
>
}
1781
>
1782
>
/** @internal */
1783
>
export abstract class TextEdit {
1784
>
static asEditOperation(edit: TextEdit): ISingleEditOperation {
1785
const range = Range.lift(edit.range);
1786
return range.isEmpty()
1787
? EditOperation.insert(range.getStartPosition(), edit.text) // moves marker
1788
: EditOperation.replace(range, edit.text);
1789
}
1791
const possibleTextEdit = thing as TextEdit;
1792
return typeof possibleTextEdit.text === 'string' && Range.isIRange(possibleTextEdit.range);
1793
}
1795
>
1796
>
/**
1797
>
* Interface used to format a model
1798
>
*/
1799
>
export interface FormattingOptions {
1800
>
/**
1801
>
* Size of a tab in spaces.
1802
>
*/
1803
>
tabSize: number;
1804
>
/**
1805
>
* Prefer spaces over tabs.
1806
>
*/
1807
>
insertSpaces: boolean;
1808
>
}
1809
>
/**
1810
>
* The document formatting provider interface defines the contract between extensions and
1811
>
* the formatting-feature.
1812
>
*/
1813
>
export interface DocumentFormattingEditProvider {
1814
>
1815
>
/**
1816
>
* @internal
1817
>
*/
1818
>
readonly extensionId?: ExtensionIdentifier;
1819
>
1820
>
readonly displayName?: string;
1821
>
1822
>
/**
1823
>
* Provide formatting edits for a whole document.
1824
>
*/
1825
>
provideDocumentFormattingEdits(model: model.ITextModel, options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>;
1826
>
}
1827
>
/**
1828
>
* The document formatting provider interface defines the contract between extensions and
1829
>
* the formatting-feature.
1830
>
*/
1831
>
export interface DocumentRangeFormattingEditProvider {
1832
>
/**
1833
>
* @internal
1834
>
*/
1835
>
readonly extensionId?: ExtensionIdentifier;
1836
>
1837
>
readonly displayName?: string;
1838
>
1839
>
/**
1840
>
* Provide formatting edits for a range in a document.
1841
>
*
1842
>
* The given range is a hint and providers can decide to format a smaller
1843
>
* or larger range. Often this is done by adjusting the start and end
1844
>
* of the range to full syntax nodes.
1845
>
*/
1846
>
provideDocumentRangeFormattingEdits(model: model.ITextModel, range: Range, options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>;
1847
>
1848
>
provideDocumentRangesFormattingEdits?(model: model.ITextModel, ranges: Range[], options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>;
1849
>
}
1850
>
/**
1851
>
* The document formatting provider interface defines the contract between extensions and
1852
>
* the formatting-feature.
1853
>
*/
1854
>
export interface OnTypeFormattingEditProvider {
1855
>
1856
>
1857
>
/**
1858
>
* @internal
1859
>
*/
1860
>
readonly extensionId?: ExtensionIdentifier;
1861
>
1862
>
autoFormatTriggerCharacters: string[];
1863
>
1864
>
/**
1865
>
* Provide formatting edits after a character has been typed.
1866
>
*
1867
>
* The given position and character should hint to the provider
1868
>
* what range the position to expand to, like find the matching `{`
1869
>
* when `}` has been entered.
1870
>
*/
1871
>
provideOnTypeFormattingEdits(model: model.ITextModel, position: Position, ch: string, options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>;
1872
>
}
1873
>
1874
>
/**
1875
>
* @internal
1876
>
*/
1877
>
export interface IInplaceReplaceSupportResult {
1878
>
value: string;
1879
>
range: IRange;
1880
>
}
1881
>
1882
>
/**
1883
>
* A link inside the editor.
1884
>
*/
1885
>
export interface ILink {
1886
>
range: IRange;
1887
>
url?: URI | string;
1888
>
tooltip?: string;
1889
>
}
1890
>
1891
>
export interface ILinksList {
1892
>
links: ILink[];
1893
>
dispose?(): void;
1894
>
}
1895
>
/**
1896
>
* A provider of links.
1897
>
*/
1898
>
export interface LinkProvider {
1899
>
provideLinks(model: model.ITextModel, token: CancellationToken): ProviderResult<ILinksList>;
1900
>
resolveLink?: (link: ILink, token: CancellationToken) => ProviderResult<ILink>;
1901
>
}
1902
>
1903
>
/**
1904
>
* A color in RGBA format.
1905
>
*/
1906
>
export interface IColor {
1907
>
1908
>
/**
1909
>
* The red component in the range [0-1].
1910
>
*/
1911
>
readonly red: number;
1912
>
1913
>
/**
1914
>
* The green component in the range [0-1].
1915
>
*/
1916
>
readonly green: number;
1917
>
1918
>
/**
1919
>
* The blue component in the range [0-1].
1920
>
*/
1921
>
readonly blue: number;
1922
>
1923
>
/**
1924
>
* The alpha component in the range [0-1].
1925
>
*/
1926
>
readonly alpha: number;
1927
>
}
1928
>
1929
>
/**
1930
>
* String representations for a color
1931
>
*/
1932
>
export interface IColorPresentation {
1933
>
/**
1934
>
* The label of this color presentation. It will be shown on the color
1935
>
* picker header. By default this is also the text that is inserted when selecting
1936
>
* this color presentation.
1937
>
*/
1938
>
label: string;
1939
>
/**
1940
>
* An {@link TextEdit edit} which is applied to a document when selecting
1941
>
* this presentation for the color.
1942
>
*/
1943
>
textEdit?: TextEdit;
1944
>
/**
1945
>
* An optional array of additional {@link TextEdit text edits} that are applied when
1946
>
* selecting this color presentation.
1947
>
*/
1948
>
additionalTextEdits?: TextEdit[];
1949
>
}
1950
>
1951
>
/**
1952
>
* A color range is a range in a text model which represents a color.
1953
>
*/
1954
>
export interface IColorInformation {
1955
>
1956
>
/**
1957
>
* The range within the model.
1958
>
*/
1959
>
range: IRange;
1960
>
1961
>
/**
1962
>
* The color represented in this range.
1963
>
*/
1964
>
color: IColor;
1965
>
}
1966
>
1967
>
/**
1968
>
* A provider of colors for editor models.
1969
>
*/
1970
>
export interface DocumentColorProvider {
1971
>
/**
1972
>
* Provides the color ranges for a specific model.
1973
>
*/
1974
>
provideDocumentColors(model: model.ITextModel, token: CancellationToken): ProviderResult<IColorInformation[]>;
1975
>
/**
1976
>
* Provide the string representations for a color.
1977
>
*/
1978
>
provideColorPresentations(model: model.ITextModel, colorInfo: IColorInformation, token: CancellationToken): ProviderResult<IColorPresentation[]>;
1979
>
}
1980
>
1981
>
export interface SelectionRange {
1982
>
range: IRange;
1983
>
}
1984
>
1985
>
export interface SelectionRangeProvider {
1986
>
/**
1987
>
* Provide ranges that should be selected from the given position.
1988
>
*/
1989
>
provideSelectionRanges(model: model.ITextModel, positions: Position[], token: CancellationToken): ProviderResult<SelectionRange[][]>;
1990
>
}
1991
>
1992
>
export interface FoldingContext {
1993
>
}
1994
>
/**
1995
>
* A provider of folding ranges for editor models.
1996
>
*/
1997
>
export interface FoldingRangeProvider {
1998
>
1999
>
/**
2000
>
* @internal
2001
>
*/
2002
>
readonly id?: string;
2003
>
2004
>
/**
2005
>
* An optional event to signal that the folding ranges from this provider have changed.
2006
>
*/
2007
>
onDidChange?: Event<this>;
2008
>
2009
>
/**
2010
>
* Provides the folding ranges for a specific model.
2011
>
*/
2012
>
provideFoldingRanges(model: model.ITextModel, context: FoldingContext, token: CancellationToken): ProviderResult<FoldingRange[]>;
2013
>
}
2014
>
2015
>
export interface FoldingRange {
2016
>
2017
>
/**
2018
>
* The one-based start line of the range to fold. The folded area starts after the line's last character.
2019
>
*/
2020
>
start: number;
2021
>
2022
>
/**
2023
>
* The one-based end line of the range to fold. The folded area ends with the line's last character.
2024
>
*/
2025
>
end: number;
2026
>
2027
>
/**
2028
>
* Describes the {@link FoldingRangeKind Kind} of the folding range such as {@link FoldingRangeKind.Comment Comment} or
2029
>
* {@link FoldingRangeKind.Region Region}. The kind is used to categorize folding ranges and used by commands
2030
>
* like 'Fold all comments'. See
2031
>
* {@link FoldingRangeKind} for an enumeration of standardized kinds.
2032
>
*/
2033
>
kind?: FoldingRangeKind;
2034
>
}
2035
>
export class FoldingRangeKind {
2036
>
/**
2037
>
* Kind for folding range representing a comment. The value of the kind is 'comment'.
2038
>
*/
2039
>
static readonly Comment = new FoldingRangeKind('comment');
2040
>
/**
2041
>
* Kind for folding range representing a import. The value of the kind is 'imports'.
2042
>
*/
2043
>
static readonly Imports = new FoldingRangeKind('imports');
2044
>
/**
2045
>
* Kind for folding range representing regions (for example marked by `#region`, `#endregion`).
2046
>
* The value of the kind is 'region'.
2047
>
*/
2048
>
static readonly Region = new FoldingRangeKind('region');
2049
>
2050
>
/**
2051
>
* Returns a {@link FoldingRangeKind} for the given value.
2052
>
*
2053
>
* @param value of the kind.
2054
>
*/
2055
>
static fromValue(value: string) {
2056
switch (value) {
2057
case 'comment': return FoldingRangeKind.Comment;
2058
case 'imports': return FoldingRangeKind.Imports;
2059
case 'region': return FoldingRangeKind.Region;
2060
}
2061
return new FoldingRangeKind(value);
2062
}
2064
>
/**
2065
>
* Creates a new {@link FoldingRangeKind}.
2066
>
*
2067
>
* @param value of the kind.
2068
>
*/
2069
>
public constructor(public value: string) {
2070
>
}
2071
>
}
2072
>
2073
>
2074
>
export interface WorkspaceEditMetadata {
2075
>
needsConfirmation: boolean;
2076
>
label: string;
2077
>
description?: string;
2078
>
/**
2079
>
* @internal
2080
>
*/
2081
>
iconPath?: ThemeIcon | URI | { light: URI; dark: URI };
2082
>
}
2083
>
2084
>
export interface WorkspaceFileEditOptions {
2085
>
overwrite?: boolean;
2086
>
ignoreIfNotExists?: boolean;
2087
>
ignoreIfExists?: boolean;
2088
>
recursive?: boolean;
2089
>
copy?: boolean;
2090
>
folder?: boolean;
2091
>
skipTrashBin?: boolean;
2092
>
maxSize?: number;
2093
>
2094
>
/**
2095
>
* @internal
2096
>
*/
2097
>
contents?: Promise<VSBuffer>;
2098
>
}
2099
>
2100
>
export interface IWorkspaceFileEdit {
2101
>
oldResource?: URI;
2102
>
newResource?: URI;
2103
>
options?: WorkspaceFileEditOptions;
2104
>
metadata?: WorkspaceEditMetadata;
2105
>
}
2106
>
2107
>
export interface IWorkspaceTextEdit {
2108
>
resource: URI;
2109
>
textEdit: TextEdit & { insertAsSnippet?: boolean; keepWhitespace?: boolean };
2110
>
versionId: number | undefined;
2111
>
metadata?: WorkspaceEditMetadata;
2112
>
}
2113
>
2114
>
export interface WorkspaceEdit {
2115
>
edits: Array<IWorkspaceTextEdit | IWorkspaceFileEdit | ICustomEdit>;
2116
>
}
2117
>
2118
>
export interface ICustomEdit {
2119
>
readonly resource: URI;
2120
>
readonly metadata?: WorkspaceEditMetadata;
2121
>
undo(): Promise<void> | void;
2122
>
redo(): Promise<void> | void;
2123
>
}
2124
>
2125
>
export interface Rejection {
2126
>
rejectReason?: string;
2127
>
}
2128
>
export interface RenameLocation {
2129
>
range: IRange;
2130
>
text: string;
2131
>
}
2132
>
2133
>
export interface RenameProvider {
2134
>
provideRenameEdits(model: model.ITextModel, position: Position, newName: string, token: CancellationToken): ProviderResult<WorkspaceEdit & Rejection>;
2135
>
resolveRenameLocation?(model: model.ITextModel, position: Position, token: CancellationToken): ProviderResult<RenameLocation & Rejection>;
2136
>
}
2137
>
2138
>
export enum NewSymbolNameTag {
2139
>
AIGenerated = 1
2140
>
}
2141
>
2142
>
export enum NewSymbolNameTriggerKind {
2143
>
Invoke = 0,
2144
>
Automatic = 1,
2145
>
}
2146
>
2147
>
export interface NewSymbolName {
2148
>
readonly newSymbolName: string;
2149
>
readonly tags?: readonly NewSymbolNameTag[];
2150
>
}
2151
>
2152
>
export interface NewSymbolNamesProvider {
2153
>
supportsAutomaticNewSymbolNamesTriggerKind?: Promise<boolean | undefined>;
2154
>
provideNewSymbolNames(model: model.ITextModel, range: IRange, triggerKind: NewSymbolNameTriggerKind, token: CancellationToken): ProviderResult<NewSymbolName[]>;
2155
>
}
2156
>
2157
>
export interface Command {
2158
>
id: string;
2159
>
title: string;
2160
>
tooltip?: string;
2161
>
arguments?: unknown[];
2162
>
}
2163
>
2164
>
/**
2165
>
* @internal
2166
>
*/
2167
>
export namespace Command {
2168
>
2169
>
/**
2170
>
* @internal
2171
>
*/
2172
>
export function is(obj: unknown): obj is Command {
2173
if (!obj || typeof obj !== 'object') {
2174
return false;
2175
}
2176
return typeof (<Command>obj).id === 'string' &&
2177
typeof (<Command>obj).title === 'string';
2178
}
2180
>
2181
>
/**
2182
>
* @internal
2183
>
*/
2184
>
export interface CommentThreadTemplate {
2185
>
controllerHandle: number;
2186
>
label: string;
2187
>
acceptInputCommand?: Command;
2188
>
additionalCommands?: Command[];
2189
>
deleteCommand?: Command;
2190
>
}
2191
>
2192
>
/**
2193
>
* @internal
2194
>
*/
2195
>
export interface CommentInfo<T = IRange> {
2196
>
extensionId?: string;
2197
>
threads: CommentThread<T>[];
2198
>
pendingCommentThreads?: PendingCommentThread[];
2199
>
commentingRanges: CommentingRanges;
2200
>
}
2201
>
2202
>
2203
>
/**
2204
>
* @internal
2205
>
*/
2206
>
export interface CommentingRangeResourceHint {
2207
>
schemes: readonly string[];
2208
>
}
2209
>
2210
>
/**
2211
>
* @internal
2212
>
*/
2213
>
export enum CommentThreadCollapsibleState {
2214
>
/**
2215
>
* Determines an item is collapsed
2216
>
*/
2217
>
Collapsed = 0,
2218
>
/**
2219
>
* Determines an item is expanded
2220
>
*/
2221
>
Expanded = 1
2222
>
}
2223
>
2224
>
/**
2225
>
* @internal
2226
>
*/
2227
>
export enum CommentThreadState {
2228
>
Unresolved = 0,
2229
>
Resolved = 1
2230
>
}
2231
>
2232
>
/**
2233
>
* @internal
2234
>
*/
2235
>
export enum CommentThreadApplicability {
2236
>
Current = 0,
2237
>
Outdated = 1
2238
>
}
2239
>
2240
>
/**
2241
>
* @internal
2242
>
*/
2243
>
export interface CommentWidget {
2244
>
commentThread: CommentThread;
2245
>
comment?: Comment;
2246
>
input: string;
2247
>
readonly onDidChangeInput: Event<string>;
2248
>
}
2249
>
2250
>
/**
2251
>
* @internal
2252
>
*/
2253
>
export interface CommentInput {
2254
>
value: string;
2255
>
uri: URI;
2256
>
}
2257
>
2258
>
export interface CommentThreadRevealOptions {
2259
>
preserveFocus: boolean;
2260
>
focusReply: boolean;
2261
>
}
2262
>
2263
>
/**
2264
>
* @internal
2265
>
*/
2266
>
export interface CommentThread<T = IRange> {
2267
>
isDocumentCommentThread(): this is CommentThread<IRange>;
2268
>
commentThreadHandle: number;
2269
>
controllerHandle: number;
2270
>
extensionId?: string;
2271
>
threadId: string;
2272
>
resource: string | null;
2273
>
range: T | undefined;
2274
>
label: string | undefined;
2275
>
contextValue: string | undefined;
2276
>
comments: ReadonlyArray<Comment> | undefined;
2277
>
readonly onDidChangeComments: Event<readonly Comment[] | undefined>;
2278
>
collapsibleState?: CommentThreadCollapsibleState;
2279
>
initialCollapsibleState?: CommentThreadCollapsibleState;
2280
>
readonly onDidChangeInitialCollapsibleState: Event<CommentThreadCollapsibleState | undefined>;
2281
>
state?: CommentThreadState;
2282
>
applicability?: CommentThreadApplicability;
2283
>
canReply: boolean | CommentAuthorInformation;
2284
>
input?: CommentInput;
2285
>
readonly onDidChangeInput: Event<CommentInput | undefined>;
2286
>
readonly onDidChangeLabel: Event<string | undefined>;
2287
>
readonly onDidChangeCollapsibleState: Event<CommentThreadCollapsibleState | undefined>;
2288
>
readonly onDidChangeState: Event<CommentThreadState | undefined>;
2289
>
readonly onDidChangeCanReply: Event<boolean>;
2290
>
isDisposed: boolean;
2291
>
isTemplate: boolean;
2292
>
}
2293
>
2294
>
/**
2295
>
* @internal
2296
>
*/
2297
>
export interface AddedCommentThread<T = IRange> extends CommentThread<T> {
2298
>
editorId?: string;
2299
>
}
2300
>
2301
>
/**
2302
>
* @internal
2303
>
*/
2304
>
2305
>
export interface CommentingRanges {
2306
>
readonly resource: URI;
2307
>
ranges: IRange[];
2308
>
fileComments: boolean;
2309
>
}
2310
>
2311
>
export interface CommentAuthorInformation {
2312
>
name: string;
2313
>
iconPath?: UriComponents;
2314
>
2315
>
}
2316
>
2317
>
/**
2318
>
* @internal
2319
>
*/
2320
>
export interface CommentReaction {
2321
>
readonly label?: string;
2322
>
readonly iconPath?: UriComponents;
2323
>
readonly count?: number;
2324
>
readonly hasReacted?: boolean;
2325
>
readonly canEdit?: boolean;
2326
>
readonly reactors?: readonly string[];
2327
>
}
2328
>
2329
>
/**
2330
>
* @internal
2331
>
*/
2332
>
export interface CommentOptions {
2333
>
/**
2334
>
* An optional string to show on the comment input box when it's collapsed.
2335
>
*/
2336
>
prompt?: string;
2337
>
2338
>
/**
2339
>
* An optional string to show as placeholder in the comment input box when it's focused.
2340
>
*/
2341
>
placeHolder?: string;
2342
>
}
2343
>
2344
>
/**
2345
>
* @internal
2346
>
*/
2347
>
export enum CommentMode {
2348
>
Editing = 0,
2349
>
Preview = 1
2350
>
}
2351
>
2352
>
/**
2353
>
* @internal
2354
>
*/
2355
>
export enum CommentState {
2356
>
Published = 0,
2357
>
Draft = 1
2358
>
}
2359
>
2360
>
/**
2361
>
* @internal
2362
>
*/
2363
>
export interface Comment {
2364
>
readonly uniqueIdInThread: number;
2365
>
readonly body: string | IMarkdownString;
2366
>
readonly userName: string;
2367
>
readonly userIconPath?: UriComponents;
2368
>
readonly contextValue?: string;
2369
>
readonly commentReactions?: CommentReaction[];
2370
>
readonly label?: string;
2371
>
readonly mode?: CommentMode;
2372
>
readonly state?: CommentState;
2373
>
readonly timestamp?: string;
2374
>
}
2375
>
2376
>
export interface PendingCommentThread {
2377
>
range: IRange | undefined;
2378
>
uri: URI;
2379
>
uniqueOwner: string;
2380
>
isReply: boolean;
2381
>
comment: PendingComment;
2382
>
}
2383
>
2384
>
export interface PendingComment {
2385
>
body: string;
2386
>
cursor: IPosition;
2387
>
}
2388
>
2389
>
/**
2390
>
* @internal
2391
>
*/
2392
>
export interface CommentThreadChangedEvent<T> {
2393
>
/**
2394
>
* Pending comment threads.
2395
>
*/
2396
>
readonly pending: PendingCommentThread[];
2397
>
2398
>
/**
2399
>
* Added comment threads.
2400
>
*/
2401
>
readonly added: AddedCommentThread<T>[];
2402
>
2403
>
/**
2404
>
* Removed comment threads.
2405
>
*/
2406
>
readonly removed: CommentThread<T>[];
2407
>
2408
>
/**
2409
>
* Changed comment threads.
2410
>
*/
2411
>
readonly changed: CommentThread<T>[];
2412
>
}
2413
>
2414
>
export interface CodeLens {
2415
>
range: IRange;
2416
>
id?: string;
2417
>
command?: Command;
2418
>
}
2419
>
2420
>
export interface CodeLensList {
2421
>
readonly lenses: readonly CodeLens[];
2422
>
dispose?(): void;
2423
>
}
2424
>
2425
>
export interface CodeLensProvider {
2426
>
onDidChange?: Event<this>;
2427
>
provideCodeLenses(model: model.ITextModel, token: CancellationToken): ProviderResult<CodeLensList>;
2428
>
resolveCodeLens?(model: model.ITextModel, codeLens: CodeLens, token: CancellationToken): ProviderResult<CodeLens>;
2429
>
}
2430
>
2431
>
2432
>
export enum InlayHintKind {
2433
>
Type = 1,
2434
>
Parameter = 2,
2435
>
}
2436
>
2437
>
export interface InlayHintLabelPart {
2438
>
label: string;
2439
>
tooltip?: string | IMarkdownString;
2440
>
// collapsible?: boolean;
2441
>
command?: Command;
2442
>
location?: Location;
2443
>
}
2444
>
2445
>
export interface InlayHint {
2446
>
label: string | InlayHintLabelPart[];
2447
>
tooltip?: string | IMarkdownString;
2448
>
textEdits?: TextEdit[];
2449
>
position: IPosition;
2450
>
kind?: InlayHintKind;
2451
>
paddingLeft?: boolean;
2452
>
paddingRight?: boolean;
2453
>
}
2454
>
2455
>
export interface InlayHintList {
2456
>
hints: InlayHint[];
2457
>
dispose(): void;
2458
>
}
2459
>
2460
>
export interface InlayHintsProvider {
2461
>
displayName?: string;
2462
>
onDidChangeInlayHints?: Event<void>;
2463
>
provideInlayHints(model: model.ITextModel, range: Range, token: CancellationToken): ProviderResult<InlayHintList>;
2464
>
resolveInlayHint?(hint: InlayHint, token: CancellationToken): ProviderResult<InlayHint>;
2465
>
}
2466
>
2467
>
export interface SemanticTokensLegend {
2468
>
readonly tokenTypes: string[];
2469
>
readonly tokenModifiers: string[];
2470
>
}
2471
>
2472
>
export interface SemanticTokens {
2473
>
readonly resultId?: string;
2474
>
readonly data: Uint32Array;
2475
>
}
2476
>
2477
>
export interface SemanticTokensEdit {
2478
>
readonly start: number;
2479
>
readonly deleteCount: number;
2480
>
readonly data?: Uint32Array;
2481
>
}
2482
>
2483
>
export interface SemanticTokensEdits {
2484
>
readonly resultId?: string;
2485
>
readonly edits: SemanticTokensEdit[];
2486
>
}
2487
>
2488
>
export interface DocumentSemanticTokensProvider {
2489
>
readonly onDidChange?: Event<void>;
2490
>
getLegend(): SemanticTokensLegend;
2491
>
provideDocumentSemanticTokens(model: model.ITextModel, lastResultId: string | null, token: CancellationToken): ProviderResult<SemanticTokens | SemanticTokensEdits>;
2492
>
releaseDocumentSemanticTokens(resultId: string | undefined): void;
2493
>
}
2494
>
2495
>
export interface DocumentRangeSemanticTokensProvider {
2496
>
readonly onDidChange?: Event<void>;
2497
>
getLegend(): SemanticTokensLegend;
2498
>
provideDocumentRangeSemanticTokens(model: model.ITextModel, range: Range, token: CancellationToken): ProviderResult<SemanticTokens>;
2499
>
}
2500
>
2501
>
/**
2502
>
* @internal
2503
>
*/
2504
>
export interface ITokenizationSupportChangedEvent {
2505
>
changedLanguages: string[];
2506
>
changedColorMap: boolean;
2507
>
}
2508
>
2509
>
/**
2510
>
* @internal
2511
>
*/
2512
>
export interface ILazyTokenizationSupport<TSupport> {
2513
>
get tokenizationSupport(): Promise<TSupport | null>;
2514
>
}
2515
>
2516
>
/**
2517
>
* @internal
2518
>
*/
2519
>
export class LazyTokenizationSupport<TSupport = ITokenizationSupport> implements IDisposable, ILazyTokenizationSupport<TSupport> {
2520
>
private _tokenizationSupport: Promise<TSupport & IDisposable | null> | null = null;
2521
>
2522
>
constructor(private readonly createSupport: () => Promise<TSupport & IDisposable | null>) {
2523
}
2525
>
dispose(): void {
2526
if (this._tokenizationSupport) {
2527
this._tokenizationSupport.then((support) => {
2528
if (support) {
2529
support.dispose();
2530
}
2531
});
2532
}
2533
}
2535
>
get tokenizationSupport(): Promise<TSupport | null> {
2536
if (!this._tokenizationSupport) {
2537
this._tokenizationSupport = this.createSupport();
2538
}
2539
return this._tokenizationSupport;
2540
}
2542
>
2543
>
/**
2544
>
* @internal
2545
>
*/
2546
>
export interface ITokenizationRegistry<TSupport> {
2547
>
2548
>
/**
2549
>
* An event triggered when:
2550
>
* - a tokenization support is registered, unregistered or changed.
2551
>
* - the color map is changed.
2552
>
*/
2553
>
readonly onDidChange: Event<ITokenizationSupportChangedEvent>;
2554
>
2555
>
/**
2556
>
* Fire a change event for a language.
2557
>
* This is useful for languages that embed other languages.
2558
>
*/
2559
>
handleChange(languageIds: string[]): void;
2560
>
2561
>
/**
2562
>
* Register a tokenization support.
2563
>
*/
2564
>
register(languageId: string, support: TSupport): IDisposable;
2565
>
2566
>
/**
2567
>
* Register a tokenization support factory.
2568
>
*/
2569
>
registerFactory(languageId: string, factory: ILazyTokenizationSupport<TSupport>): IDisposable;
2570
>
2571
>
/**
2572
>
* Get or create the tokenization support for a language.
2573
>
* Returns `null` if not found.
2574
>
*/
2575
>
getOrCreate(languageId: string): Promise<TSupport | null>;
2576
>
2577
>
/**
2578
>
* Get the tokenization support for a language.
2579
>
* Returns `null` if not found.
2580
>
*/
2581
>
get(languageId: string): TSupport | null;
2582
>
2583
>
/**
2584
>
* Returns false if a factory is still pending.
2585
>
*/
2586
>
isResolved(languageId: string): boolean;
2587
>
2588
>
/**
2589
>
* Set the new color map that all tokens will use in their ColorId binary encoded bits for foreground and background.
2590
>
*/
2591
>
setColorMap(colorMap: Color[]): void;
2592
>
2593
>
getColorMap(): Color[] | null;
2594
>
2595
>
getDefaultBackground(): Color | null;
2596
>
}
2597
>
2598
>
/**
2599
>
* @internal
2600
>
*/
2601
>
export const TokenizationRegistry: ITokenizationRegistry<ITokenizationSupport> = new TokenizationRegistryImpl();
2602
>
2603
>
/**
2604
>
* @internal
2605
>
*/
2606
>
export enum ExternalUriOpenerPriority {
2607
>
None = 0,
2608
>
Option = 1,
2609
>
Default = 2,
2610
>
Preferred = 3,
2611
>
}
2612
>
2613
>
/**
2614
>
* @internal
2615
>
*/
2616
>
export type DropYieldTo = { readonly kind: HierarchicalKind } | { readonly mimeType: string };
2617
>
2618
>
/**
2619
>
* @internal
2620
>
*/
2621
>
export interface DocumentDropEdit {
2622
>
readonly title: string;
2623
>
readonly kind: HierarchicalKind | undefined;
2624
>
readonly handledMimeType?: string;
2625
>
readonly yieldTo?: readonly DropYieldTo[];
2626
>
insertText: string | { readonly snippet: string };
2627
>
additionalEdit?: WorkspaceEdit;
2628
>
}
2629
>
2630
>
/**
2631
>
* @internal
2632
>
*/
2633
>
export interface DocumentDropEditsSession {
2634
>
edits: readonly DocumentDropEdit[];
2635
>
dispose(): void;
2636
>
}
2637
>
2638
>
/**
2639
>
* @internal
2640
>
*/
2641
>
export interface DocumentDropEditProvider {
2642
>
readonly id?: string;
2643
>
readonly dropMimeTypes?: readonly string[];
2644
>
readonly providedDropEditKinds?: readonly HierarchicalKind[];
2645
>
2646
>
provideDocumentDropEdits(model: model.ITextModel, position: IPosition, dataTransfer: IReadonlyVSDataTransfer, token: CancellationToken): ProviderResult<DocumentDropEditsSession>;
2647
>
resolveDocumentDropEdit?(edit: DocumentDropEdit, token: CancellationToken): Promise<DocumentDropEdit>;
2648
>
}