Merge from vscode 1b314ab317fbff7d799b21754326b7d849889ceb

src/vs/workbench/services/extensions/browser/extensionService.ts

@@ -140,10 +140,9 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 				connectionData: this._remoteAuthorityResolverService.getConnectionData(remoteAgentConnection.remoteAuthority),
 				pid: remoteEnv.pid,
 				appRoot: remoteEnv.appRoot,
-				appSettingsHome: remoteEnv.appSettingsHome,
 				extensionHostLogsPath: remoteEnv.extensionHostLogsPath,
 				globalStorageHome: remoteEnv.globalStorageHome,
-				userHome: remoteEnv.userHome,
+				workspaceStorageHome: remoteEnv.workspaceStorageHome,
 				extensions: remoteEnv.extensions,
 				allExtensions: remoteEnv.extensions.concat(localExtensions)
 			};

src/vs/workbench/services/extensions/browser/extensionUrlHandler.ts

@@ -4,15 +4,14 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { localize } from 'vs/nls';
-import { Action } from 'vs/base/common/actions';
 import { IDisposable, toDisposable, combinedDisposable } from 'vs/base/common/lifecycle';
 import { URI } from 'vs/base/common/uri';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IDialogService } from 'vs/platform/dialogs/common/dialogs';
-import { IExtensionGalleryService, IExtensionIdentifier, IExtensionManagementService, ExtensionsLabel } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { IExtensionGalleryService, IExtensionIdentifier, IExtensionManagementService } from 'vs/platform/extensionManagement/common/extensionManagement';
 import { IWorkbenchExtensionEnablementService, EnablementState } from 'vs/workbench/services/extensionManagement/common/extensionManagement';
 import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
-import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { createDecorator, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
 import { INotificationService, Severity } from 'vs/platform/notification/common/notification';
 import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
 import { IURLHandler, IURLService, IOpenURLOptions } from 'vs/platform/url/common/url';
@@ -23,8 +22,7 @@ import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 import { Registry } from 'vs/platform/registry/common/platform';
 import { IWorkbenchContribution, Extensions as WorkbenchExtensions, IWorkbenchContributionsRegistry } from 'vs/workbench/common/contributions';
 import { LifecyclePhase } from 'vs/platform/lifecycle/common/lifecycle';
-import { IWorkbenchActionRegistry, Extensions as WorkbenchActionExtensions } from 'vs/workbench/common/actions';
-import { SyncActionDescriptor } from 'vs/platform/actions/common/actions';
+import { Action2, registerAction2 } from 'vs/platform/actions/common/actions';
 import { IQuickInputService, IQuickPickItem } from 'vs/platform/quickinput/common/quickInput';
 import { IProgressService, ProgressLocation } from 'vs/platform/progress/common/progress';
 
@@ -383,39 +381,37 @@ class ExtensionUrlBootstrapHandler implements IWorkbenchContribution, IURLHandle
 const workbenchRegistry = Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench);
 workbenchRegistry.registerWorkbenchContribution(ExtensionUrlBootstrapHandler, LifecyclePhase.Ready);
 
-export class ManageAuthorizedExtensionURIsAction extends Action {
+class ManageAuthorizedExtensionURIsAction extends Action2 {
 
-	static readonly ID = 'workbench.extensions.action.manageAuthorizedExtensionURIs';
-	static readonly LABEL = localize('manage', "Manage Authorized Extension URIs...");
-
-	private storage: ConfirmedExtensionIdStorage;
-
-	constructor(
-		id = ManageAuthorizedExtensionURIsAction.ID,
-		label = ManageAuthorizedExtensionURIsAction.LABEL,
-		@IStorageService readonly storageService: IStorageService,
-		@IQuickInputService private readonly quickInputService: IQuickInputService
-	) {
-		super(id, label, undefined, true);
-		this.storage = new ConfirmedExtensionIdStorage(storageService);
+	constructor() {
+		super({
+			id: 'workbench.extensions.action.manageAuthorizedExtensionURIs',
+			title: { value: localize('manage', "Manage Authorized Extension URIs..."), original: 'Manage Authorized Extension URIs...' },
+			category: { value: localize('extensions', "Extensions"), original: 'Extensions' },
+			f1: true
+		});
 	}
 
-	async run(): Promise<void> {
-		const items = this.storage.extensions.map(label => ({ label, picked: true } as IQuickPickItem));
+	async run(accessor: ServicesAccessor): Promise<void> {
+		const storageService = accessor.get(IStorageService);
+		const quickInputService = accessor.get(IQuickInputService);
+
+		const storage = new ConfirmedExtensionIdStorage(storageService);
+
+		const items = storage.extensions.map(label => ({ label, picked: true } as IQuickPickItem));
 
 		if (items.length === 0) {
 			return;
 		}
 
-		const result = await this.quickInputService.pick(items, { canPickMany: true });
+		const result = await quickInputService.pick(items, { canPickMany: true });
 
 		if (!result) {
 			return;
 		}
 
-		this.storage.set(result.map(item => item.label));
+		storage.set(result.map(item => item.label));
 	}
 }
 
-const actionRegistry = Registry.as<IWorkbenchActionRegistry>(WorkbenchActionExtensions.WorkbenchActions);
-actionRegistry.registerWorkbenchAction(SyncActionDescriptor.from(ManageAuthorizedExtensionURIsAction), `Extensions: Manage Authorized Extension URIs...`, ExtensionsLabel);
+registerAction2(ManageAuthorizedExtensionURIsAction);

src/vs/workbench/services/extensions/browser/webWorkerExtensionHost.ts

@@ -147,14 +147,14 @@ export class WebWorkerExtensionHost implements IExtensionHost {
 			vscodeVersion: this._productService.vscodeVersion, // {{SQL CARBON EDIT}} add vscode version
 			parentPid: -1,
 			environment: {
-				isExtensionDevelopmentDebug: false,
+				isExtensionDevelopmentDebug: false, //todo@jrieken web
 				appName: this._productService.nameLong,
 				appUriScheme: this._productService.urlProtocol,
 				appLanguage: platform.language,
 				extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
 				extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,
-				globalStorageHome: URI.parse('fake:globalStorageHome'), //todo@joh URI.file(this._environmentService.globalStorageHome),
-				userHome: URI.parse('fake:userHome'), //todo@joh URI.file(this._environmentService.userHome),
+				globalStorageHome: this._environmentService.globalStorageHome,
+				workspaceStorageHome: this._environmentService.workspaceStorageHome,
 				webviewResourceRoot: this._environmentService.webviewResourceRoot,
 				webviewCspSource: this._environmentService.webviewCspSource,
 			},

src/vs/workbench/services/extensions/browser/webWorkerFileSystemProvider.ts

@@ -7,7 +7,7 @@ import { FileSystemProviderCapabilities, IStat, FileType, FileDeleteOptions, Fil
 import { Event } from 'vs/base/common/event';
 import { IDisposable, Disposable } from 'vs/base/common/lifecycle';
 import { URI } from 'vs/base/common/uri';
-import { NotImplementedError } from 'vs/base/common/errors';
+import { NotSupportedError } from 'vs/base/common/errors';
 
 export class FetchFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
 
@@ -44,18 +44,18 @@ export class FetchFileSystemProvider implements IFileSystemProviderWithFileReadW
 
 	// error implementations
 	writeFile(_resource: URI, _content: Uint8Array, _opts: FileWriteOptions): Promise<void> {
-		throw new NotImplementedError();
+		throw new NotSupportedError();
 	}
 	readdir(_resource: URI): Promise<[string, FileType][]> {
-		throw new NotImplementedError();
+		throw new NotSupportedError();
 	}
 	mkdir(_resource: URI): Promise<void> {
-		throw new NotImplementedError();
+		throw new NotSupportedError();
 	}
 	delete(_resource: URI, _opts: FileDeleteOptions): Promise<void> {
-		throw new NotImplementedError();
+		throw new NotSupportedError();
 	}
 	rename(_from: URI, _to: URI, _opts: FileOverwriteOptions): Promise<void> {
-		throw new NotImplementedError();
+		throw new NotSupportedError();
 	}
 }

src/vs/workbench/services/extensions/common/extensionHostMain.ts

@@ -132,14 +132,13 @@ export class ExtensionHostMain {
 	private static _transform(initData: IInitData, rpcProtocol: RPCProtocol): IInitData {
 		initData.extensions.forEach((ext) => (<any>ext).extensionLocation = URI.revive(rpcProtocol.transformIncomingURIs(ext.extensionLocation)));
 		initData.environment.appRoot = URI.revive(rpcProtocol.transformIncomingURIs(initData.environment.appRoot));
-		initData.environment.appSettingsHome = URI.revive(rpcProtocol.transformIncomingURIs(initData.environment.appSettingsHome));
 		const extDevLocs = initData.environment.extensionDevelopmentLocationURI;
 		if (extDevLocs) {
 			initData.environment.extensionDevelopmentLocationURI = extDevLocs.map(url => URI.revive(rpcProtocol.transformIncomingURIs(url)));
 		}
 		initData.environment.extensionTestsLocationURI = URI.revive(rpcProtocol.transformIncomingURIs(initData.environment.extensionTestsLocationURI));
 		initData.environment.globalStorageHome = URI.revive(rpcProtocol.transformIncomingURIs(initData.environment.globalStorageHome));
-		initData.environment.userHome = URI.revive(rpcProtocol.transformIncomingURIs(initData.environment.userHome));
+		initData.environment.workspaceStorageHome = URI.revive(rpcProtocol.transformIncomingURIs(initData.environment.workspaceStorageHome));
 		initData.logsLocation = URI.revive(rpcProtocol.transformIncomingURIs(initData.logsLocation));
 		initData.logFile = URI.revive(rpcProtocol.transformIncomingURIs(initData.logFile));
 		initData.workspace = rpcProtocol.transformIncomingURIs(initData.workspace);

src/vs/workbench/services/extensions/common/extensionHostManager.ts

@@ -395,7 +395,7 @@ registerAction2(class MeasureExtHostLatencyAction extends Action2 {
 				value: nls.localize('measureExtHostLatency', "Measure Extension Host Latency"),
 				original: 'Measure Extension Host Latency'
 			},
-			category: nls.localize({ key: 'developer', comment: ['A developer on Code itself or someone diagnosing issues in Code'] }, "Developer"),
+			category: { value: nls.localize({ key: 'developer', comment: ['A developer on Code itself or someone diagnosing issues in Code'] }, "Developer"), original: 'Developer' },
 			f1: true
 		});
 	}

src/vs/workbench/services/extensions/common/extensionsRegistry.ts

@@ -12,7 +12,7 @@ import { Extensions, IJSONContributionRegistry } from 'vs/platform/jsonschemas/c
 import { Registry } from 'vs/platform/registry/common/platform';
 import { IMessage } from 'vs/workbench/services/extensions/common/extensions';
 import { ExtensionIdentifier, IExtensionDescription, EXTENSION_CATEGORIES } from 'vs/platform/extensions/common/extensions';
-import { values } from 'vs/base/common/map';
+import { toArray } from 'vs/base/common/arrays';
 
 const schemaRegistry = Registry.as<IJSONContributionRegistry>(Extensions.JSONContribution);
 export type ExtensionKind = 'workspace' | 'ui' | undefined;
@@ -444,7 +444,7 @@ export class ExtensionsRegistryImpl {
 	}
 
 	public getExtensionPoints(): ExtensionPoint<any>[] {
-		return values(this._extensionPoints);
+		return toArray(this._extensionPoints.values());
 	}
 }
 

src/vs/workbench/services/extensions/common/remoteExtensionHost.ts

@@ -36,10 +36,9 @@ export interface IRemoteExtensionHostInitData {
 	readonly connectionData: IRemoteConnectionData | null;
 	readonly pid: number;
 	readonly appRoot: URI;
-	readonly appSettingsHome: URI;
 	readonly extensionHostLogsPath: URI;
 	readonly globalStorageHome: URI;
-	readonly userHome: URI;
+	readonly workspaceStorageHome: URI;
 	readonly extensions: IExtensionDescription[];
 	readonly allExtensions: IExtensionDescription[];
 }
@@ -216,14 +215,13 @@ export class RemoteExtensionHost extends Disposable implements IExtensionHost {
 			environment: {
 				isExtensionDevelopmentDebug,
 				appRoot: remoteInitData.appRoot,
-				appSettingsHome: remoteInitData.appSettingsHome,
 				appName: this._productService.nameLong,
 				appUriScheme: this._productService.urlProtocol,
 				appLanguage: platform.language,
 				extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
 				extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,
 				globalStorageHome: remoteInitData.globalStorageHome,
-				userHome: remoteInitData.userHome,
+				workspaceStorageHome: remoteInitData.workspaceStorageHome,
 				webviewResourceRoot: this._environmentService.webviewResourceRoot,
 				webviewCspSource: this._environmentService.webviewCspSource,
 			},

src/vs/workbench/services/extensions/electron-browser/extensionService.ts

@@ -17,7 +17,7 @@ import { IRemoteExtensionHostDataProvider, RemoteExtensionHost, IRemoteExtension
 import { IRemoteAgentService } from 'vs/workbench/services/remote/common/remoteAgentService';
 import { IRemoteAuthorityResolverService, RemoteAuthorityResolverError, ResolverResult } from 'vs/platform/remote/common/remoteAuthorityResolver';
 import { getExtensionKind } from 'vs/workbench/services/extensions/common/extensionsUtil';
-import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
 import { ILifecycleService, LifecyclePhase } from 'vs/platform/lifecycle/common/lifecycle';
 import { INotificationService, Severity } from 'vs/platform/notification/common/notification';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
@@ -34,13 +34,13 @@ import { flatten } from 'vs/base/common/arrays';
 import { IElectronService } from 'vs/platform/electron/electron-sandbox/electron';
 import { INativeWorkbenchEnvironmentService } from 'vs/workbench/services/environment/electron-browser/environmentService';
 import { IRemoteExplorerService } from 'vs/workbench/services/remote/common/remoteExplorerService';
-import { Action } from 'vs/base/common/actions';
-import { SyncActionDescriptor } from 'vs/platform/actions/common/actions';
-import { Registry } from 'vs/platform/registry/common/platform';
-import { Extensions as ActionExtensions, IWorkbenchActionRegistry } from 'vs/workbench/common/actions';
+import { Action2, registerAction2 } from 'vs/platform/actions/common/actions';
 import { getRemoteName } from 'vs/platform/remote/common/remoteHosts';
 import { IRemoteAgentEnvironment } from 'vs/platform/remote/common/remoteAgentEnvironment';
 import { WebWorkerExtensionHost } from 'vs/workbench/services/extensions/browser/webWorkerExtensionHost';
+import { IExtensionActivationHost as IWorkspaceContainsActivationHost, checkGlobFileExists, checkActivateWorkspaceContainsExtension } from 'vs/workbench/api/common/shared/workspaceContains';
+import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
+import { exists } from 'vs/base/node/pfs';
 
 class DeltaExtensionsQueueItem {
 	constructor(
@@ -75,6 +75,7 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 		@IHostService private readonly _hostService: IHostService,
 		@IRemoteExplorerService private readonly _remoteExplorerService: IRemoteExplorerService,
 		@IExtensionGalleryService private readonly _extensionGalleryService: IExtensionGalleryService,
+		@IWorkspaceContextService private readonly _contextService: IWorkspaceContextService,
 	) {
 		super(
 			instantiationService,
@@ -313,6 +314,7 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 
 		let shouldActivate = false;
 		let shouldActivateReason: string | null = null;
+		let hasWorkspaceContains = false;
 		if (Array.isArray(extensionDescription.activationEvents)) {
 			for (let activationEvent of extensionDescription.activationEvents) {
 				// TODO@joao: there's no easy way to contribute this
@@ -334,10 +336,7 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 				}
 
 				if (/^workspaceContains/.test(activationEvent)) {
-					// do not trigger a search, just activate in this case...
-					shouldActivate = true;
-					shouldActivateReason = activationEvent;
-					break;
+					hasWorkspaceContains = true;
 				}
 
 				if (activationEvent === 'onStartupFinished') {
@@ -352,6 +351,24 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 			await Promise.all(
 				this._extensionHostManagers.map(extHostManager => extHostManager.activate(extensionDescription.identifier, { startup: false, extensionId: extensionDescription.identifier, activationEvent: shouldActivateReason! }))
 			).then(() => { });
+		} else if (hasWorkspaceContains) {
+			const workspace = await this._contextService.getCompleteWorkspace();
+			const forceUsingSearch = !!this._environmentService.configuration.remoteAuthority;
+			const host: IWorkspaceContainsActivationHost = {
+				folders: workspace.folders.map(folder => folder.uri),
+				forceUsingSearch: forceUsingSearch,
+				exists: (path) => exists(path),
+				checkExists: (folders, includes, token) => this._instantiationService.invokeFunction((accessor) => checkGlobFileExists(accessor, folders, includes, token))
+			};
+
+			const result = await checkActivateWorkspaceContainsExtension(host, extensionDescription);
+			if (!result) {
+				return;
+			}
+
+			await Promise.all(
+				this._extensionHostManagers.map(extHostManager => extHostManager.activate(extensionDescription.identifier, { startup: false, extensionId: extensionDescription.identifier, activationEvent: result.activationEvent }))
+			).then(() => { });
 		}
 	}
 
@@ -560,10 +577,9 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 				connectionData: this._remoteAuthorityResolverService.getConnectionData(remoteAuthority),
 				pid: remoteEnv.pid,
 				appRoot: remoteEnv.appRoot,
-				appSettingsHome: remoteEnv.appSettingsHome,
 				extensionHostLogsPath: remoteEnv.extensionHostLogsPath,
 				globalStorageHome: remoteEnv.globalStorageHome,
-				userHome: remoteEnv.userHome,
+				workspaceStorageHome: remoteEnv.workspaceStorageHome,
 				extensions: remoteExtensions,
 				allExtensions: this._registry.getAllExtensionDescriptions(),
 			});
@@ -715,23 +731,20 @@ function filterByRunningLocation(extensions: IExtensionDescription[], runningLoc
 
 registerSingleton(IExtensionService, ExtensionService);
 
-class RestartExtensionHostAction extends Action {
+class RestartExtensionHostAction extends Action2 {
 
-	public static readonly ID = 'workbench.action.restartExtensionHost';
-	public static readonly LABEL = nls.localize('restartExtensionHost', "Restart Extension Host");
-
-	constructor(
-		id: string,
-		label: string,
-		@IExtensionService private readonly _extensionService: IExtensionService
-	) {
-		super(id, label);
+	constructor() {
+		super({
+			id: 'workbench.action.restartExtensionHost',
+			title: { value: nls.localize('restartExtensionHost', "Restart Extension Host"), original: 'Restart Extension Host' },
+			category: { value: nls.localize({ key: 'developer', comment: ['A developer on Code itself or someone diagnosing issues in Code'] }, "Developer"), original: 'Developer' },
+			f1: true
+		});
 	}
 
-	public async run() {
-		this._extensionService.restartExtensionHost();
+	run(accessor: ServicesAccessor): void {
+		accessor.get(IExtensionService).restartExtensionHost();
 	}
 }
 
-const registry = Registry.as<IWorkbenchActionRegistry>(ActionExtensions.WorkbenchActions);
-registry.registerWorkbenchAction(SyncActionDescriptor.from(RestartExtensionHostAction), 'Developer: Restart Extension Host', nls.localize({ key: 'developer', comment: ['A developer on Code itself or someone diagnosing issues in Code'] }, "Developer"));
+registerAction2(RestartExtensionHostAction);

src/vs/workbench/services/extensions/electron-browser/localProcessExtensionHost.ts

@@ -431,14 +431,13 @@ export class LocalProcessExtensionHost implements IExtensionHost {
 			environment: {
 				isExtensionDevelopmentDebug: this._isExtensionDevDebug,
 				appRoot: this._environmentService.appRoot ? URI.file(this._environmentService.appRoot) : undefined,
-				appSettingsHome: this._environmentService.appSettingsHome ? this._environmentService.appSettingsHome : undefined,
 				appName: this._productService.nameLong,
 				appUriScheme: this._productService.urlProtocol,
 				appLanguage: platform.language,
 				extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
 				extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,
-				globalStorageHome: URI.file(this._environmentService.globalStorageHome),
-				userHome: this._environmentService.userHome,
+				globalStorageHome: this._environmentService.globalStorageHome,
+				workspaceStorageHome: this._environmentService.workspaceStorageHome,
 				webviewResourceRoot: this._environmentService.webviewResourceRoot,
 				webviewCspSource: this._environmentService.webviewCspSource,
 			},

src/vs/workbench/services/extensions/electron-browser/remoteExtensionManagementIpc.ts

@@ -12,8 +12,7 @@ import { areSameExtensions } from 'vs/platform/extensionManagement/common/extens
 import { ILogService } from 'vs/platform/log/common/log';
 import { toErrorMessage } from 'vs/base/common/errorMessage';
 import { prefersExecuteOnUI } from 'vs/workbench/services/extensions/common/extensionsUtil';
-import { isNonEmptyArray } from 'vs/base/common/arrays';
-import { values } from 'vs/base/common/map';
+import { isNonEmptyArray, toArray } from 'vs/base/common/arrays';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { localize } from 'vs/nls';
 import { IProductService } from 'vs/platform/product/common/productService';
@@ -102,14 +101,14 @@ export class RemoteExtensionManagementChannelClient extends ExtensionManagementC
 		const result = new Map<string, IGalleryExtension>();
 		const extensions = [...(manifest.extensionPack || []), ...(manifest.extensionDependencies || [])];
 		await this.getDependenciesAndPackedExtensionsRecursively(extensions, result, true, token);
-		return values(result);
+		return toArray(result.values());
 	}
 
 	private async getAllWorkspaceDependenciesAndPackedExtensions(manifest: IExtensionManifest, token: CancellationToken): Promise<IGalleryExtension[]> {
 		const result = new Map<string, IGalleryExtension>();
 		const extensions = [...(manifest.extensionPack || []), ...(manifest.extensionDependencies || [])];
 		await this.getDependenciesAndPackedExtensionsRecursively(extensions, result, false, token);
-		return values(result);
+		return toArray(result.values());
 	}
 
 	private async getDependenciesAndPackedExtensionsRecursively(toGet: string[], result: Map<string, IGalleryExtension>, uiExtension: boolean, token: CancellationToken): Promise<void> {

src/vs/workbench/services/extensions/node/extensionHostProcessSetup.ts

@@ -20,9 +20,11 @@ import { IURITransformer, URITransformer, IRawURITransformer } from 'vs/base/com
 import { exists } from 'vs/base/node/pfs';
 import { realpath } from 'vs/base/node/extpath';
 import { IHostUtils } from 'vs/workbench/api/common/extHostExtensionService';
-import 'vs/workbench/api/node/extHost.services';
 import { RunOnceScheduler } from 'vs/base/common/async';
 
+import 'vs/workbench/api/common/extHost.common.services';
+import 'vs/workbench/api/node/extHost.node.services';
+
 interface ParsedExtHostArgs {
 	uriTransformerPath?: string;
 	useHostProxy?: string;

src/vs/workbench/services/extensions/worker/extHost.services.ts

@@ -1,46 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
-import { IExtHostOutputService, ExtHostOutputService } from 'vs/workbench/api/common/extHostOutput';
-import { IExtHostWorkspace, ExtHostWorkspace } from 'vs/workbench/api/common/extHostWorkspace';
-import { IExtHostDecorations, ExtHostDecorations } from 'vs/workbench/api/common/extHostDecorations';
-import { IExtHostConfiguration, ExtHostConfiguration } from 'vs/workbench/api/common/extHostConfiguration';
-import { IExtHostCommands, ExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
-import { IExtHostDocumentsAndEditors, ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
-import { IExtHostTerminalService, WorkerExtHostTerminalService } from 'vs/workbench/api/common/extHostTerminalService';
-// import { IExtHostTask, WorkerExtHostTask } from 'vs/workbench/api/common/extHostTask';
-// import { IExtHostDebugService, WorkerExtHostDebugService } from 'vs/workbench/api/common/extHostDebugService';
-import { IExtHostSearch, ExtHostSearch } from 'vs/workbench/api/common/extHostSearch';
-import { IExtensionStoragePaths } from 'vs/workbench/api/common/extHostStoragePaths';
-import { IExtHostExtensionService } from 'vs/workbench/api/common/extHostExtensionService';
-import { IExtHostStorage, ExtHostStorage } from 'vs/workbench/api/common/extHostStorage';
-import { ExtHostExtensionService } from 'vs/workbench/api/worker/extHostExtensionService';
-import { ILogService } from 'vs/platform/log/common/log';
-import { ExtHostLogService } from 'vs/workbench/api/worker/extHostLogService';
-import { IExtHostTunnelService, ExtHostTunnelService } from 'vs/workbench/api/common/extHostTunnelService';
-import { IExtHostApiDeprecationService, ExtHostApiDeprecationService, } from 'vs/workbench/api/common/extHostApiDeprecationService';
-import { IExtHostWindow, ExtHostWindow } from 'vs/workbench/api/common/extHostWindow';
-import { NotImplementedProxy } from 'vs/base/common/types';
-
-// register singleton services
-registerSingleton(ILogService, ExtHostLogService);
-registerSingleton(IExtHostApiDeprecationService, ExtHostApiDeprecationService);
-registerSingleton(IExtHostOutputService, ExtHostOutputService);
-registerSingleton(IExtHostWorkspace, ExtHostWorkspace);
-registerSingleton(IExtHostWindow, ExtHostWindow);
-registerSingleton(IExtHostDecorations, ExtHostDecorations);
-registerSingleton(IExtHostConfiguration, ExtHostConfiguration);
-registerSingleton(IExtHostCommands, ExtHostCommands);
-registerSingleton(IExtHostDocumentsAndEditors, ExtHostDocumentsAndEditors);
-registerSingleton(IExtHostStorage, ExtHostStorage);
-registerSingleton(IExtHostExtensionService, ExtHostExtensionService);
-registerSingleton(IExtHostSearch, ExtHostSearch);
-registerSingleton(IExtHostTunnelService, ExtHostTunnelService);
-
-registerSingleton(IExtHostTerminalService, WorkerExtHostTerminalService);
-// registerSingleton(IExtHostTask, WorkerExtHostTask); {{SQL CARBON EDIT}} disable
-// registerSingleton(IExtHostDebugService, WorkerExtHostDebugService); {{SQL CARBON EDIT}} disable
-registerSingleton(IExtensionStoragePaths, class extends NotImplementedProxy<IExtensionStoragePaths>(String(IExtensionStoragePaths)) { whenReady = Promise.resolve(); });

src/vs/workbench/services/extensions/worker/extensionHostWorker.ts

@@ -10,7 +10,9 @@ import { isMessageOfType, MessageType, createMessageOfType } from 'vs/workbench/
 import { IInitData } from 'vs/workbench/api/common/extHost.protocol';
 import { ExtensionHostMain } from 'vs/workbench/services/extensions/common/extensionHostMain';
 import { IHostUtils } from 'vs/workbench/api/common/extHostExtensionService';
-import 'vs/workbench/services/extensions/worker/extHost.services';
+
+import 'vs/workbench/api/common/extHost.common.services';
+import 'vs/workbench/api/worker/extHost.worker.services';
 
 //#region --- Define, capture, and override some globals