chore(vscode): update to 1.55.2

This commit is contained in:
Akash Satheesan
2021-04-09 11:32:27 +05:30
1102 changed files with 39988 additions and 23544 deletions

View File

@@ -3,59 +3,40 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
/* eslint-disable code-no-standalone-editor */
/* eslint-disable code-import-patterns */
import { ISignService } from 'vs/platform/sign/common/sign';
import { URI } from 'vs/base/common/uri';
import { InMemoryFileSystemProvider } from 'vs/platform/files/common/inMemoryFilesystemProvider';
import { Event } from 'vs/base/common/event';
import { IAddressProvider } from 'vs/platform/remote/common/remoteAgentConnection';
import { ITelemetryData, ITelemetryInfo, ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
import { IExtension } from 'vs/platform/extensions/common/extensions';
import { SimpleConfigurationService as BaseSimpleConfigurationService } from 'vs/editor/standalone/browser/simpleServices';
import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
import { IBackupFileService, IResolvedBackup } from 'vs/workbench/services/backup/common/backup';
import { ITextSnapshot } from 'vs/editor/common/model';
import { IExtensionService, NullExtensionService } from 'vs/workbench/services/extensions/common/extensions';
import { ClassifiedEvent, GDPRClassification, StrictPropertyChecker } from 'vs/platform/telemetry/common/gdprTypings';
import { IKeyboardLayoutService } from 'vs/platform/keyboardLayout/common/keyboardLayout';
import { isWindows } from 'vs/base/common/platform';
import { IWebviewService, WebviewContentOptions, WebviewElement, WebviewExtensionDescription, WebviewIcons, WebviewOptions, WebviewOverlay } from 'vs/workbench/contrib/webview/browser/webview';
import { ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
import { AbstractTextFileService } from 'vs/workbench/services/textfile/browser/textFileService';
import { IExtensionManagementServer, IExtensionManagementServerService } from 'vs/workbench/services/extensionManagement/common/extensionManagement';
import { IWebviewService, WebviewContentOptions, WebviewElement, WebviewExtensionDescription, WebviewOptions, WebviewOverlay } from 'vs/workbench/contrib/webview/browser/webview';
import { ITunnelProvider, ITunnelService, RemoteTunnel, TunnelProviderFeatures } from 'vs/platform/remote/common/tunnel';
import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
import { IManualSyncTask, IResourcePreview, ISyncResourceHandle, ISyncTask, IUserDataAutoSyncService, IUserDataSyncService, IUserDataSyncStore, IUserDataSyncStoreManagementService, SyncResource, SyncStatus, UserDataSyncStoreType } from 'vs/platform/userDataSync/common/userDataSync';
import { IUserDataSyncAccount, IUserDataSyncAccountService } from 'vs/platform/userDataSync/common/userDataSyncAccount';
import { ISingleFolderWorkspaceIdentifier, IWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
import { ITaskProvider, ITaskService, ITaskSummary, ProblemMatcherRunOptions, Task, TaskFilter, TaskTerminateResponse, WorkspaceFolderTaskResult } from 'vs/workbench/contrib/tasks/common/taskService';
import { Action } from 'vs/base/common/actions';
import { LinkedMap } from 'vs/base/common/map';
import { IWorkspace, IWorkspaceContextService, IWorkspaceFolder, WorkbenchState, WorkspaceFolder } from 'vs/platform/workspace/common/workspace';
import { IWorkspace, IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
import { CustomTask, ContributedTask, InMemoryTask, TaskRunSource, ConfiguringTask, TaskIdentifier, TaskSorter } from 'vs/workbench/contrib/tasks/common/tasks';
import { TaskSystemInfo } from 'vs/workbench/contrib/tasks/common/taskSystem';
import { IExtensionTipsService, IConfigBasedExtensionTip, IExecutableBasedExtensionTip, IWorkspaceTips } from 'vs/platform/extensionManagement/common/extensionManagement';
import { IWorkspaceTagsService, Tags } from 'vs/workbench/contrib/tags/common/workspaceTags';
import { AbstractOutputChannelModelService, IOutputChannelModelService } from 'vs/workbench/contrib/output/common/outputChannelModel';
import { joinPath } from 'vs/base/common/resources';
import { VSBuffer } from 'vs/base/common/buffer';
import { IIntegrityService, IntegrityTestResult } from 'vs/workbench/services/integrity/common/integrity';
import { INativeWorkbenchConfiguration, INativeWorkbenchEnvironmentService } from 'vs/workbench/services/environment/electron-sandbox/environmentService';
import { NativeParsedArgs } from 'vs/platform/environment/common/argv';
import { IExtensionHostDebugParams } from 'vs/platform/environment/common/environment';
import type { IWorkbenchConstructionOptions } from 'vs/workbench/workbench.web.api';
import { Schemas } from 'vs/base/common/network';
import { BrowserKeyboardLayoutService } from 'vs/workbench/services/keybinding/browser/keyboardLayoutService';
import { TerminalInstanceService } from 'vs/workbench/contrib/terminal/browser/terminalInstanceService';
import { ITerminalInstanceService } from 'vs/workbench/contrib/terminal/browser/terminal';
import { IWorkbenchConfigurationService } from 'vs/workbench/services/configuration/common/configuration';
import { ConsoleLogger, LogService } from 'vs/platform/log/common/log';
import { SearchService } from 'vs/workbench/services/search/common/searchService';
import { ISearchService } from 'vs/workbench/services/search/common/search';
import { IModelService } from 'vs/editor/common/services/modelService';
import { IFileService } from 'vs/platform/files/common/files';
import { ILogService } from 'vs/platform/log/common/log';
import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
import { IUriIdentityService } from 'vs/workbench/services/uriIdentity/common/uriIdentity';
//#region Environment
<<<<<<< HEAD
export class SimpleNativeWorkbenchEnvironmentService implements INativeWorkbenchEnvironmentService {
declare readonly _serviceBrand: undefined;
@@ -137,103 +118,60 @@ export class SimpleNativeWorkbenchEnvironmentService implements INativeWorkbench
//#endregion
=======
export const simpleHomeDir = URI.file(isWindows ? '\\sandbox-home-dir' : '/sandbox-home-dir');
export const simpleTmpDir = URI.file(isWindows ? '\\sandbox-tmp-dir' : '/sandbox-tmp-dir');
export const simpleUserDataDir = URI.file(isWindows ? '\\sandbox-user-data-dir' : '/sandbox-user-data-dir');
>>>>>>> 801aed93200dc0ccf325a09089c911e8e2b612d0
//#region Workspace
export const workspaceResource = URI.file(isWindows ? '\\simpleWorkspace' : '/simpleWorkspace');
export class SimpleWorkspaceService implements IWorkspaceContextService {
declare readonly _serviceBrand: undefined;
readonly onDidChangeWorkspaceName = Event.None;
readonly onDidChangeWorkspaceFolders = Event.None;
readonly onDidChangeWorkbenchState = Event.None;
private readonly workspace: IWorkspace;
constructor() {
this.workspace = { id: '4064f6ec-cb38-4ad0-af64-ee6467e63c82', folders: [new WorkspaceFolder({ uri: workspaceResource, name: '', index: 0 })] };
}
async getCompleteWorkspace(): Promise<IWorkspace> { return this.getWorkspace(); }
getWorkspace(): IWorkspace { return this.workspace; }
getWorkbenchState(): WorkbenchState {
if (this.workspace) {
if (this.workspace.configuration) {
return WorkbenchState.WORKSPACE;
}
return WorkbenchState.FOLDER;
}
return WorkbenchState.EMPTY;
}
getWorkspaceFolder(resource: URI): IWorkspaceFolder | null { return resource && resource.scheme === workspaceResource.scheme ? this.workspace.folders[0] : null; }
isInsideWorkspace(resource: URI): boolean { return resource && resource.scheme === workspaceResource.scheme; }
isCurrentWorkspace(workspaceIdOrFolder: IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | URI): boolean { return true; }
}
export const simpleWorkspaceDir = URI.file(isWindows ? '\\simpleWorkspace' : '/simpleWorkspace');
//#endregion
//#region Configuration
export class SimpleConfigurationService extends BaseSimpleConfigurationService implements IWorkbenchConfigurationService {
async whenRemoteConfigurationLoaded() { }
}
//#endregion
//#region Signing
export class SimpleSignService implements ISignService {
declare readonly _serviceBrand: undefined;
async sign(value: string): Promise<string> { return value; }
}
//#endregion
//#region Logger
export class SimpleLogService extends LogService {
constructor() {
super(new ConsoleLogger());
}
}
//#region Files
class SimpleFileSystemProvider extends InMemoryFileSystemProvider { }
export const simpleFileSystemProvider = new SimpleFileSystemProvider();
function createFile(parent: string, name: string, content: string = ''): void {
simpleFileSystemProvider.writeFile(joinPath(workspaceResource, parent, name), VSBuffer.fromString(content).buffer, { create: true, overwrite: true });
simpleFileSystemProvider.mkdir(simpleHomeDir);
simpleFileSystemProvider.mkdir(simpleTmpDir);
simpleFileSystemProvider.mkdir(simpleUserDataDir);
simpleFileSystemProvider.mkdir(joinPath(simpleUserDataDir, 'User'));
simpleFileSystemProvider.writeFile(joinPath(simpleUserDataDir, 'User', 'settings.json'), VSBuffer.fromString(JSON.stringify({
'window.zoomLevel': 1,
'workbench.colorTheme': 'Default Light+',
}, undefined, '\t')).buffer, { create: true, overwrite: true, unlock: false });
simpleFileSystemProvider.writeFile(joinPath(simpleUserDataDir, 'User', 'keybindings.json'), VSBuffer.fromString(JSON.stringify([
{
'key': 'f12',
'command': 'workbench.action.toggleDevTools'
}
], undefined, '\t')).buffer, { create: true, overwrite: true, unlock: false });
function createWorkspaceFile(parent: string, name: string, content: string = ''): void {
simpleFileSystemProvider.writeFile(joinPath(simpleWorkspaceDir, parent, name), VSBuffer.fromString(content).buffer, { create: true, overwrite: true, unlock: false });
}
function createFolder(name: string): void {
simpleFileSystemProvider.mkdir(joinPath(workspaceResource, name));
function createWorkspaceFolder(name: string): void {
simpleFileSystemProvider.mkdir(joinPath(simpleWorkspaceDir, name));
}
createFolder('');
createFolder('src');
createFolder('test');
createWorkspaceFolder('');
createWorkspaceFolder('src');
createWorkspaceFolder('test');
createFile('', '.gitignore', `out
createWorkspaceFile('', '.gitignore', `out
node_modules
.vscode-test/
*.vsix
`);
createFile('', '.vscodeignore', `.vscode/**
createWorkspaceFile('', '.vscodeignore', `.vscode/**
.vscode-test/**
out/test/**
src/**
@@ -244,14 +182,14 @@ vsc-extension-quickstart.md
**/*.map
**/*.ts`);
createFile('', 'CHANGELOG.md', `# Change Log
createWorkspaceFile('', 'CHANGELOG.md', `# Change Log
All notable changes to the "test-ts" extension will be documented in this file.
Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
## [Unreleased]
- Initial release`);
createFile('', 'package.json', `{
createWorkspaceFile('', 'package.json', `{
"name": "test-ts",
"displayName": "test-ts",
"description": "",
@@ -291,7 +229,7 @@ createFile('', 'package.json', `{
}
`);
createFile('', 'tsconfig.json', `{
createWorkspaceFile('', 'tsconfig.json', `{
"compilerOptions": {
"module": "commonjs",
"target": "es6",
@@ -314,7 +252,7 @@ createFile('', 'tsconfig.json', `{
}
`);
createFile('', 'tslint.json', `{
createWorkspaceFile('', 'tslint.json', `{
"rules": {
"no-string-throw": true,
"no-unused-expression": true,
@@ -331,7 +269,7 @@ createFile('', 'tslint.json', `{
}
`);
createFile('src', 'extension.ts', `// The module 'vscode' contains the VS Code extensibility API
createWorkspaceFile('src', 'extension.ts', `// The module 'vscode' contains the VS Code extensibility API
// Import the module and reference it with the alias vscode in your code below
import * as vscode from 'vscode';
@@ -360,7 +298,7 @@ export function activate(context: vscode.ExtensionContext) {
export function deactivate() {}
`);
createFile('test', 'extension.test.ts', `//
createWorkspaceFile('test', 'extension.test.ts', `//
// Note: This example test is leveraging the Mocha test framework.
// Please refer to their documentation on https://mochajs.org/ for help.
//
@@ -383,7 +321,7 @@ suite("Extension Tests", function () {
});
});`);
createFile('test', 'index.ts', `//
createWorkspaceFile('test', 'index.ts', `//
// PLEASE DO NOT MODIFY / DELETE UNLESS YOU KNOW WHAT YOU ARE DOING
//
// This file is providing the test runner to use when running extension tests.
@@ -410,29 +348,6 @@ module.exports = testRunner;`);
//#endregion
//#region Backup File
class SimpleBackupFileService implements IBackupFileService {
declare readonly _serviceBrand: undefined;
async hasBackups(): Promise<boolean> { return false; }
async discardResourceBackup(resource: URI): Promise<void> { }
async discardAllWorkspaceBackups(): Promise<void> { }
toBackupResource(resource: URI): URI { return resource; }
hasBackupSync(resource: URI, versionId?: number): boolean { return false; }
async getBackups(): Promise<URI[]> { return []; }
async resolve<T extends object>(resource: URI): Promise<IResolvedBackup<T> | undefined> { return undefined; }
async backup<T extends object>(resource: URI, content?: ITextSnapshot, versionId?: number, meta?: T): Promise<void> { }
async discardBackup(resource: URI): Promise<void> { }
async discardBackups(): Promise<void> { }
}
registerSingleton(IBackupFileService, SimpleBackupFileService);
//#endregion
//#region Extensions
class SimpleExtensionService extends NullExtensionService { }
@@ -442,45 +357,6 @@ registerSingleton(IExtensionService, SimpleExtensionService);
//#endregion
//#region Telemetry
class SimpleTelemetryService implements ITelemetryService {
declare readonly _serviceBrand: undefined;
readonly sendErrorTelemetry = false;
readonly isOptedIn = false;
async publicLog(eventName: string, data?: ITelemetryData, anonymizeFilePaths?: boolean): Promise<void> { }
async publicLog2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyChecker<E, ClassifiedEvent<T>, 'Type of classified event does not match event properties'>, anonymizeFilePaths?: boolean): Promise<void> { }
async publicLogError(errorEventName: string, data?: ITelemetryData): Promise<void> { }
async publicLogError2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyChecker<E, ClassifiedEvent<T>, 'Type of classified event does not match event properties'>): Promise<void> { }
setEnabled(value: boolean): void { }
setExperimentProperty(name: string, value: string): void { }
async getTelemetryInfo(): Promise<ITelemetryInfo> {
return {
instanceId: 'someValue.instanceId',
sessionId: 'someValue.sessionId',
machineId: 'someValue.machineId',
firstSessionDate: 'someValue.firstSessionDate'
};
}
}
registerSingleton(ITelemetryService, SimpleTelemetryService);
//#endregion
//#region Keymap Service (borrowed from browser for now to enable keyboard access)
class SimpleKeyboardLayoutService extends BrowserKeyboardLayoutService { }
registerSingleton(IKeyboardLayoutService, SimpleKeyboardLayoutService);
//#endregion
//#region Webview
class SimpleWebviewService implements IWebviewService {
@@ -490,7 +366,6 @@ class SimpleWebviewService implements IWebviewService {
createWebviewElement(id: string, options: WebviewOptions, contentOptions: WebviewContentOptions, extension: WebviewExtensionDescription | undefined): WebviewElement { throw new Error('Method not implemented.'); }
createWebviewOverlay(id: string, options: WebviewOptions, contentOptions: WebviewContentOptions, extension: WebviewExtensionDescription | undefined): WebviewOverlay { throw new Error('Method not implemented.'); }
setIcons(id: string, value: WebviewIcons | undefined): void { }
}
registerSingleton(IWebviewService, SimpleWebviewService);
@@ -498,35 +373,6 @@ registerSingleton(IWebviewService, SimpleWebviewService);
//#endregion
//#region Textfiles
class SimpleTextFileService extends AbstractTextFileService {
declare readonly _serviceBrand: undefined;
}
registerSingleton(ITextFileService, SimpleTextFileService);
//#endregion
//#region extensions management
class SimpleExtensionManagementServerService implements IExtensionManagementServerService {
declare readonly _serviceBrand: undefined;
readonly localExtensionManagementServer = null;
readonly remoteExtensionManagementServer = null;
readonly webExtensionManagementServer = null;
getExtensionManagementServer(extension: IExtension): IExtensionManagementServer | null { return null; }
}
registerSingleton(IExtensionManagementServerService, SimpleExtensionManagementServerService);
//#endregion
//#region Tunnel
class SimpleTunnelService implements ITunnelService {
@@ -551,105 +397,6 @@ registerSingleton(ITunnelService, SimpleTunnelService);
//#endregion
//#region User Data Sync
class SimpleUserDataSyncService implements IUserDataSyncService {
declare readonly _serviceBrand: undefined;
onDidChangeStatus = Event.None;
onDidChangeConflicts = Event.None;
onDidChangeLocal = Event.None;
onSyncErrors = Event.None;
onDidChangeLastSyncTime = Event.None;
onDidResetRemote = Event.None;
onDidResetLocal = Event.None;
status: SyncStatus = SyncStatus.Idle;
conflicts: [SyncResource, IResourcePreview[]][] = [];
lastSyncTime = undefined;
createSyncTask(): Promise<ISyncTask> { throw new Error('Method not implemented.'); }
createManualSyncTask(): Promise<IManualSyncTask> { throw new Error('Method not implemented.'); }
async replace(uri: URI): Promise<void> { }
async reset(): Promise<void> { }
async resetRemote(): Promise<void> { }
async resetLocal(): Promise<void> { }
async hasLocalData(): Promise<boolean> { return false; }
async hasPreviouslySynced(): Promise<boolean> { return false; }
async resolveContent(resource: URI): Promise<string | null> { return null; }
async accept(resource: SyncResource, conflictResource: URI, content: string | null | undefined, apply: boolean): Promise<void> { }
async getLocalSyncResourceHandles(resource: SyncResource): Promise<ISyncResourceHandle[]> { return []; }
async getRemoteSyncResourceHandles(resource: SyncResource): Promise<ISyncResourceHandle[]> { return []; }
async getAssociatedResources(resource: SyncResource, syncResourceHandle: ISyncResourceHandle): Promise<{ resource: URI; comparableResource: URI; }[]> { return []; }
async getMachineId(resource: SyncResource, syncResourceHandle: ISyncResourceHandle): Promise<string | undefined> { return undefined; }
}
registerSingleton(IUserDataSyncService, SimpleUserDataSyncService);
//#endregion
//#region User Data Sync Account
class SimpleUserDataSyncAccountService implements IUserDataSyncAccountService {
declare readonly _serviceBrand: undefined;
onTokenFailed = Event.None;
onDidChangeAccount = Event.None;
account: IUserDataSyncAccount | undefined = undefined;
async updateAccount(account: IUserDataSyncAccount | undefined): Promise<void> { }
}
registerSingleton(IUserDataSyncAccountService, SimpleUserDataSyncAccountService);
//#endregion
//#region User Data Auto Sync Account
class SimpleUserDataAutoSyncAccountService implements IUserDataAutoSyncService {
declare readonly _serviceBrand: undefined;
onError = Event.None;
onDidChangeEnablement = Event.None;
isEnabled(): boolean { return false; }
canToggleEnablement(): boolean { return false; }
async turnOn(): Promise<void> { }
async turnOff(everywhere: boolean): Promise<void> { }
async triggerSync(sources: string[], hasToLimitSync: boolean, disableCache: boolean): Promise<void> { }
}
registerSingleton(IUserDataAutoSyncService, SimpleUserDataAutoSyncAccountService);
//#endregion
//#region User Data Sync Store Management
class SimpleUserDataSyncStoreManagementService implements IUserDataSyncStoreManagementService {
declare readonly _serviceBrand: undefined;
onDidChangeUserDataSyncStore = Event.None;
userDataSyncStore: IUserDataSyncStore | undefined = undefined;
async switch(type: UserDataSyncStoreType): Promise<void> { }
async getPreviousUserDataSyncStore(): Promise<IUserDataSyncStore | undefined> { return undefined; }
}
registerSingleton(IUserDataSyncStoreManagementService, SimpleUserDataSyncStoreManagementService);
//#endregion
//#region Task
class SimpleTaskService implements ITaskService {
@@ -697,69 +444,31 @@ registerSingleton(ITaskService, SimpleTaskService);
//#endregion
//#region Extension Tips
class SimpleExtensionTipsService implements IExtensionTipsService {
declare readonly _serviceBrand: undefined;
onRecommendationChange = Event.None;
async getConfigBasedTips(folder: URI): Promise<IConfigBasedExtensionTip[]> { return []; }
async getImportantExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]> { return []; }
async getOtherExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]> { return []; }
async getAllWorkspacesTips(): Promise<IWorkspaceTips[]> { return []; }
}
registerSingleton(IExtensionTipsService, SimpleExtensionTipsService);
//#endregion
//#region Workspace Tags
class SimpleWorkspaceTagsService implements IWorkspaceTagsService {
declare readonly _serviceBrand: undefined;
async getTags(): Promise<Tags> { return Object.create(null); }
async getTelemetryWorkspaceId(workspace: IWorkspace, state: WorkbenchState): Promise<string | undefined> { return undefined; }
async getHashedRemotesFromUri(workspaceUri: URI, stripEndingDotGit?: boolean): Promise<string[]> { return []; }
}
registerSingleton(IWorkspaceTagsService, SimpleWorkspaceTagsService);
//#endregion
//#region Output Channel
class SimpleOutputChannelModelService extends AbstractOutputChannelModelService {
declare readonly _serviceBrand: undefined;
}
registerSingleton(IOutputChannelModelService, SimpleOutputChannelModelService);
//#endregion
//#region Integrity
class SimpleIntegrityService implements IIntegrityService {
declare readonly _serviceBrand: undefined;
async isPure(): Promise<IntegrityTestResult> {
return { isPure: true, proof: [] };
}
}
registerSingleton(IIntegrityService, SimpleIntegrityService);
//#endregion
//#region Terminal Instance
class SimpleTerminalInstanceService extends TerminalInstanceService { }
registerSingleton(ITerminalInstanceService, SimpleTerminalInstanceService);
//#endregion
//#region Search Service
class SimpleSearchService extends SearchService {
constructor(
@IModelService modelService: IModelService,
@IEditorService editorService: IEditorService,
@ITelemetryService telemetryService: ITelemetryService,
@ILogService logService: ILogService,
@IExtensionService extensionService: IExtensionService,
@IFileService fileService: IFileService,
@IUriIdentityService uriIdentityService: IUriIdentityService,
) {
super(modelService, editorService, telemetryService, logService, extensionService, fileService, uriIdentityService);
}
}
registerSingleton(ISearchService, SimpleSearchService);
//#endregion