Update to VS Code 1.52.1

This commit is contained in:
Asher
2021-02-09 16:08:37 +00:00
1351 changed files with 56560 additions and 38990 deletions

View File

@@ -223,6 +223,13 @@ declare module 'vscode' {
}
export interface TunnelCreationOptions {
/**
* True when the local operating system will require elevation to use the requested local port.
*/
elevationRequired?: boolean;
}
export type ResolverResult = ResolvedAuthority & ResolvedOptions & TunnelInformation;
export class RemoteAuthorityResolverError extends Error {
@@ -238,8 +245,11 @@ declare module 'vscode' {
* Can be optionally implemented if the extension can forward ports better than the core.
* When not implemented, the core will use its default forwarding logic.
* When implemented, the core will use this to forward ports.
*
* To enable the "Change Local Port" action on forwarded ports, make sure to set the `localAddress` of
* the returned `Tunnel` to a `{ port: number, host: string; }` and not a string.
*/
tunnelFactory?: (tunnelOptions: TunnelOptions) => Thenable<Tunnel> | undefined;
tunnelFactory?: (tunnelOptions: TunnelOptions, tunnelCreationOptions: TunnelCreationOptions) => Thenable<Tunnel> | undefined;
/**
* Provides filtering for candidate ports.
@@ -741,71 +751,6 @@ declare module 'vscode' {
//#endregion
//#region file-decorations: https://github.com/microsoft/vscode/issues/54938
export class FileDecoration {
/**
* A very short string that represents this decoration.
*/
badge?: string;
/**
* A human-readable tooltip for this decoration.
*/
tooltip?: string;
/**
* The color of this decoration.
*/
color?: ThemeColor;
/**
* A flag expressing that this decoration should be
* propagated to its parents.
*/
propagate?: boolean;
/**
* Creates a new decoration.
*
* @param badge A letter that represents the decoration.
* @param tooltip The tooltip of the decoration.
* @param color The color of the decoration.
*/
constructor(badge?: string, tooltip?: string, color?: ThemeColor);
}
/**
* The decoration provider interfaces defines the contract between extensions and
* file decorations.
*/
export interface FileDecorationProvider {
/**
* An event to signal decorations for one or many files have changed.
*
* @see [EventEmitter](#EventEmitter
*/
onDidChange: Event<undefined | Uri | Uri[]>;
/**
* Provide decorations for a given uri.
*
* @param uri The uri of the file to provide a decoration for.
* @param token A cancellation token.
* @returns A decoration or a thenable that resolves to such.
*/
provideFileDecoration(uri: Uri, token: CancellationToken): ProviderResult<FileDecoration>;
}
export namespace window {
export function registerDecorationProvider(provider: FileDecorationProvider): Disposable;
}
//#endregion
//#region debug
/**
@@ -824,46 +769,9 @@ declare module 'vscode' {
// Properties: see details [here](https://microsoft.github.io/debug-adapter-protocol/specification#Base_Protocol_Variable).
}
// deprecated debug API
export interface DebugConfigurationProvider {
/**
* Deprecated, use DebugAdapterDescriptorFactory.provideDebugAdapter instead.
* @deprecated Use DebugAdapterDescriptorFactory.createDebugAdapterDescriptor instead
*/
debugAdapterExecutable?(folder: WorkspaceFolder | undefined, token?: CancellationToken): ProviderResult<DebugAdapterExecutable>;
}
//#endregion
//#region LogLevel: https://github.com/microsoft/vscode/issues/85992
/**
* @deprecated DO NOT USE, will be removed
*/
export enum LogLevel {
Trace = 1,
Debug = 2,
Info = 3,
Warning = 4,
Error = 5,
Critical = 6,
Off = 7
}
export namespace env {
/**
* @deprecated DO NOT USE, will be removed
*/
export const logLevel: LogLevel;
/**
* @deprecated DO NOT USE, will be removed
*/
export const onDidChangeLogLevel: Event<LogLevel>;
}
//#endregion
//#region @joaomoreno: SCM validation
@@ -1008,45 +916,8 @@ declare module 'vscode' {
//#endregion
//#region Tree View: https://github.com/microsoft/vscode/issues/61313
/**
* Label describing the [Tree item](#TreeItem)
*/
export interface TreeItemLabel {
/**
* A human-readable string describing the [Tree item](#TreeItem).
*/
label: string;
/**
* Ranges in the label to highlight. A range is defined as a tuple of two number where the
* first is the inclusive start index and the second the exclusive end index
*/
highlights?: [number, number][];
}
// https://github.com/microsoft/vscode/issues/100741
export interface TreeDataProvider<T> {
resolveTreeItem?(element: T, item: TreeItem2): TreeItem2 | Thenable<TreeItem2>;
}
export class TreeItem2 extends TreeItem {
/**
* Label describing this item. When `falsy`, it is derived from [resourceUri](#TreeItem.resourceUri).
*/
label?: string | TreeItemLabel | /* for compilation */ any;
/**
* Content to be shown when you hover over the tree item.
*/
tooltip?: string | MarkdownString | /* for compilation */ any;
/**
* @param label Label describing this item
* @param collapsibleState [TreeItemCollapsibleState](#TreeItemCollapsibleState) of the tree item. Default is [TreeItemCollapsibleState.None](#TreeItemCollapsibleState.None)
*/
constructor(label: TreeItemLabel, collapsibleState?: TreeItemCollapsibleState);
export interface TreeView<T> extends Disposable {
reveal(element: T | undefined, options?: { select?: boolean, focus?: boolean, expand?: boolean | number }): Thenable<void>;
}
//#endregion
@@ -1112,45 +983,6 @@ declare module 'vscode' {
//#endregion
//#region OnTypeRename: https://github.com/microsoft/vscode/issues/88424
/**
* The rename provider interface defines the contract between extensions and
* the live-rename feature.
*/
export interface OnTypeRenameProvider {
/**
* Provide a list of ranges that can be live renamed together.
*
* @param document The document in which the command was invoked.
* @param position The position at which the command was invoked.
* @param token A cancellation token.
* @return A list of ranges that can be live-renamed togehter. The ranges must have
* identical length and contain identical text content. The ranges cannot overlap. Optional a word pattern
* that overrides the word pattern defined when registering the provider. Live rename stops as soon as the renamed content
* no longer matches the word pattern.
*/
provideOnTypeRenameRanges(document: TextDocument, position: Position, token: CancellationToken): ProviderResult<{ ranges: Range[]; wordPattern?: RegExp; }>;
}
namespace languages {
/**
* Register a rename provider that works on type.
*
* Multiple providers can be registered for a language. In that case providers are sorted
* by their [score](#languages.match) and the best-matching provider is used. Failure
* of the selected provider will cause a failure of the whole operation.
*
* @param selector A selector that defines the documents this provider is applicable to.
* @param provider An on type rename provider.
* @param wordPattern Word pattern for this provider.
* @return A [disposable](#Disposable) that unregisters this provider when being disposed.
*/
export function registerOnTypeRenameProvider(selector: DocumentSelector, provider: OnTypeRenameProvider, wordPattern?: RegExp): Disposable;
}
//#endregion
//#region Custom editor move https://github.com/microsoft/vscode/issues/86146
// TODO: Also for custom editor
@@ -1403,6 +1235,12 @@ declare module 'vscode' {
* The document's current run state
*/
runState?: NotebookRunState;
/**
* Whether the document is trusted, default to true
* When false, insecure outputs like HTML, JavaScript, SVG will not be rendered.
*/
trusted?: boolean;
}
export interface NotebookDocumentContentOptions {
@@ -1824,6 +1662,13 @@ declare module 'vscode' {
dispose(): void;
}
export interface NotebookDocumentShowOptions {
viewColumn?: ViewColumn;
preserveFocus?: boolean;
preview?: boolean;
selection?: NotebookCellRange;
}
export namespace notebook {
export function registerNotebookContentProvider(
@@ -1891,6 +1736,7 @@ declare module 'vscode' {
export const onDidChangeActiveNotebookEditor: Event<NotebookEditor | undefined>;
export const onDidChangeNotebookEditorSelection: Event<NotebookEditorSelectionChangeEvent>;
export const onDidChangeNotebookEditorVisibleRanges: Event<NotebookEditorVisibleRangesChangeEvent>;
export function showNotebookDocument(document: NotebookDocument, options?: NotebookDocumentShowOptions): Promise<NotebookEditor>;
}
//#endregion
@@ -2138,36 +1984,338 @@ declare module 'vscode' {
}
//#endregion
//#region https://github.com/microsoft/vscode/issues/91697
export interface FileSystem {
//#region https://github.com/microsoft/vscode/issues/107467
/*
General activation events:
- `onLanguage:*` most test extensions will want to activate when their
language is opened to provide code lenses.
- `onTests:*` new activation event very simiular to `workspaceContains`,
but only fired when the user wants to run tests or opens the test explorer.
*/
export namespace test {
/**
* Check if a given file system supports writing files.
*
* Keep in mind that just because a file system supports writing, that does
* not mean that writes will always succeed. There may be permissions issues
* or other errors that prevent writing a file.
*
* @param scheme The scheme of the filesystem, for example `file` or `git`.
*
* @return `true` if the file system supports writing, `false` if it does not
* support writing (i.e. it is readonly), and `undefined` if VS Code does not
* know about the filesystem.
* Registers a provider that discovers tests for the given document
* selectors. It is activated when either tests need to be enumerated, or
* a document matching the selector is opened.
*/
isWritableFileSystem(scheme: string): boolean | undefined;
export function registerTestProvider<T extends TestItem>(testProvider: TestProvider<T>): Disposable;
/**
* Runs tests with the given options. If no options are given, then
* all tests are run. Returns the resulting test run.
*/
export function runTests<T extends TestItem>(options: TestRunOptions<T>): Thenable<void>;
/**
* Returns an observer that retrieves tests in the given workspace folder.
*/
export function createWorkspaceTestObserver(workspaceFolder: WorkspaceFolder): TestObserver;
/**
* Returns an observer that retrieves tests in the given text document.
*/
export function createDocumentTestObserver(document: TextDocument): TestObserver;
}
export interface TestObserver {
/**
* List of tests returned by test provider for files in the workspace.
*/
readonly tests: ReadonlyArray<TestItem>;
/**
* An event that fires when an existing test in the collection changes, or
* null if a top-level test was added or removed. When fired, the consumer
* should check the test item and all its children for changes.
*/
readonly onDidChangeTest: Event<TestChangeEvent>;
/**
* An event the fires when all test providers have signalled that the tests
* the observer references have been discovered. Providers may continue to
* watch for changes and cause {@link onDidChangeTest} to fire as files
* change, until the observer is disposed.
*
* @todo as below
*/
readonly onDidDiscoverInitialTests: Event<void>;
/**
* Dispose of the observer, allowing VS Code to eventually tell test
* providers that they no longer need to update tests.
*/
dispose(): void;
}
export interface TestChangeEvent {
/**
* List of all tests that are newly added.
*/
readonly added: ReadonlyArray<TestItem>;
/**
* List of existing tests that have updated.
*/
readonly updated: ReadonlyArray<TestItem>;
/**
* List of existing tests that have been removed.
*/
readonly removed: ReadonlyArray<TestItem>;
/**
* Highest node in the test tree under which changes were made. This can
* be easily plugged into events like the TreeDataProvider update event.
*/
readonly commonChangeAncestor: TestItem | null;
}
/**
* Tree of tests returned from the provide methods in the {@link TestProvider}.
*/
export interface TestHierarchy<T extends TestItem> {
/**
* Root node for tests. The `testRoot` instance must not be replaced over
* the lifespan of the TestHierarchy, since you will need to reference it
* in `onDidChangeTest` when a test is added or removed.
*/
readonly root: T;
/**
* An event that fires when an existing test under the `root` changes.
* This can be a result of a state change in a test run, a property update,
* or an update to its children. Changes made to tests will not be visible
* to {@link TestObserver} instances until this event is fired.
*
* This will signal a change recursively to all children of the given node.
* For example, firing the event with the {@link testRoot} will refresh
* all tests.
*/
readonly onDidChangeTest: Event<T>;
/**
* An event that should be fired when all tests that are currently defined
* have been discovered. The provider should continue to watch for changes
* and fire `onDidChangeTest` until the hierarchy is disposed.
*
* @todo can this be covered by existing progress apis? Or return a promise
*/
readonly onDidDiscoverInitialTests: Event<void>;
/**
* Dispose will be called when there are no longer observers interested
* in the hierarchy.
*/
dispose(): void;
}
/**
* Discovers and provides tests. It's expected that the TestProvider will
* ambiently listen to {@link vscode.window.onDidChangeVisibleTextEditors} to
* provide test information about the open files for use in code lenses and
* other file-specific UI.
*
* Additionally, the UI may request it to discover tests for the workspace
* via `addWorkspaceTests`.
*
* @todo rename from provider
*/
export interface TestProvider<T extends TestItem = TestItem> {
/**
* Requests that tests be provided for the given workspace. This will
* generally be called when tests need to be enumerated for the
* workspace.
*
* It's guaranteed that this method will not be called again while
* there is a previous undisposed watcher for the given workspace folder.
*/
createWorkspaceTestHierarchy?(workspace: WorkspaceFolder): TestHierarchy<T>;
/**
* Requests that tests be provided for the given document. This will
* be called when tests need to be enumerated for a single open file,
* for instance by code lens UI.
*/
createDocumentTestHierarchy?(document: TextDocument): TestHierarchy<T>;
/**
* Starts a test run. This should cause {@link onDidChangeTest} to
* fire with update test states during the run.
* @todo this will eventually need to be able to return a summary report, coverage for example.
*/
runTests?(options: TestRunOptions<T>, cancellationToken: CancellationToken): ProviderResult<void>;
}
/**
* Options given to `TestProvider.runTests`
*/
export interface TestRunOptions<T extends TestItem = TestItem> {
/**
* Array of specific tests to run. The {@link TestProvider.testRoot} may
* be provided as an indication to run all tests.
*/
tests: T[];
/**
* Whether or not tests in this run should be debugged.
*/
debug: boolean;
}
/**
* A test item is an item shown in the "test explorer" view. It encompasses
* both a suite and a test, since they have almost or identical capabilities.
*/
export interface TestItem {
/**
* Display name describing the test case.
*/
label: string;
/**
* Optional description that appears next to the label.
*/
description?: string;
/**
* Whether this test item can be run individually, defaults to `true`
* if not provided.
*
* In some cases, like Go's tests, test can have children but these
* children cannot be run independently.
*/
runnable?: boolean;
/**
* Whether this test item can be debugged. Defaults to `false` if not provided.
*/
debuggable?: boolean;
/**
* VS Code location.
*/
location?: Location;
/**
* Optional list of nested tests for this item.
*/
children?: TestItem[];
/**
* Test run state. Will generally be {@link TestRunState.Unset} by
* default.
*/
state: TestState;
}
export enum TestRunState {
// Initial state
Unset = 0,
// Test is currently running
Running = 1,
// Test run has passed
Passed = 2,
// Test run has failed (on an assertion)
Failed = 3,
// Test run has been skipped
Skipped = 4,
// Test run failed for some other reason (compilation error, timeout, etc)
Errored = 5
}
/**
* TestState includes a test and its run state. This is included in the
* {@link TestItem} and is immutable; it should be replaced in th TestItem
* in order to update it. This allows consumers to quickly and easily check
* for changes via object identity.
*/
export class TestState {
/**
* Current state of the test.
*/
readonly runState: TestRunState;
/**
* Optional duration of the test run, in milliseconds.
*/
readonly duration?: number;
/**
* Associated test run message. Can, for example, contain assertion
* failure information if the test fails.
*/
readonly messages: ReadonlyArray<Readonly<TestMessage>>;
/**
* @param state Run state to hold in the test state
* @param messages List of associated messages for the test
* @param duration Length of time the test run took, if appropriate.
*/
constructor(runState: TestRunState, messages?: TestMessage[], duration?: number);
}
/**
* Represents the severity of test messages.
*/
export enum TestMessageSeverity {
Error = 0,
Warning = 1,
Information = 2,
Hint = 3
}
/**
* Message associated with the test state. Can be linked to a specific
* source range -- useful for assertion failures, for example.
*/
export interface TestMessage {
/**
* Human-readable message text to display.
*/
message: string | MarkdownString;
/**
* Message severity. Defaults to "Error", if not provided.
*/
severity?: TestMessageSeverity;
/**
* Expected test output. If given with `actual`, a diff view will be shown.
*/
expectedOutput?: string;
/**
* Actual test output. If given with `actual`, a diff view will be shown.
*/
actualOutput?: string;
/**
* Associated file location.
*/
location?: Location;
}
//#endregion
//#region https://github.com/microsoft/vscode/issues/108929 FoldingRangeProvider.onDidChangeFoldingRanges @aeschli
export interface FoldingRangeProvider2 extends FoldingRangeProvider {
//#region Statusbar Item Background Color (https://github.com/microsoft/vscode/issues/110214)
/**
* A status bar item is a status bar contribution that can
* show text and icons and run a command on click.
*/
export interface StatusBarItem {
/**
* An optional event to signal that the folding ranges from this provider have changed.
* The background color for this entry.
*
* Note: only `new ThemeColor('statusBarItem.errorBackground')` is
* supported for now. More background colors may be supported in the
* future.
*
* Note: when a background color is set, the statusbar may override
* the `color` choice to ensure the entry is readable in all themes.
*/
onDidChangeFoldingRanges?: Event<void>;
backgroundColor: ThemeColor | undefined;
}
//#endregion
}