Merge from vscode 4d91d96e5e121b38d33508cdef17868bab255eae

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

@@ -28,6 +28,7 @@ import { Schemas } from 'vs/base/common/network';
 import { DisposableStore } from 'vs/base/common/lifecycle';
 import { IStaticExtensionsService } from 'vs/workbench/services/extensions/common/staticExtensions';
 import { DeltaExtensionsResult } from 'vs/workbench/services/extensions/common/extensionDescriptionRegistry';
+import { IRemoteAuthorityResolverService } from 'vs/platform/remote/common/remoteAuthorityResolver';
 
 export class ExtensionService extends AbstractExtensionService implements IExtensionService {
 
@@ -42,6 +43,7 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 		@IWorkbenchExtensionEnablementService extensionEnablementService: IWorkbenchExtensionEnablementService,
 		@IFileService fileService: IFileService,
 		@IProductService productService: IProductService,
+		@IRemoteAuthorityResolverService private readonly _remoteAuthorityResolverService: IRemoteAuthorityResolverService,
 		@IRemoteAgentService private readonly _remoteAgentService: IRemoteAgentService,
 		@IConfigurationService private readonly _configService: IConfigurationService,
 		@IStaticExtensionsService private readonly _staticExtensions: IStaticExtensionsService,
@@ -74,10 +76,11 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 	private _createProvider(remoteAuthority: string): IInitDataProvider {
 		return {
 			remoteAuthority: remoteAuthority,
-			getInitData: () => {
-				return this.whenInstalledExtensionsRegistered().then(() => {
-					return this._remoteExtensionsEnvironmentData!;
-				});
+			getInitData: async () => {
+				await this.whenInstalledExtensionsRegistered();
+				const connectionData = this._remoteAuthorityResolverService.getConnectionData(remoteAuthority);
+				const remoteEnvironment = this._remoteExtensionsEnvironmentData!;
+				return { connectionData, remoteEnvironment };
 			}
 		};
 	}

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

@@ -161,6 +161,7 @@ export class WebWorkerExtensionHostStarter implements IExtensionHostStarter {
 			autoStart: this._autoStart,
 			remote: {
 				authority: this._environmentService.configuration.remoteAuthority,
+				connectionData: null,
 				isRemote: false
 			},
 			uiKind: platform.isWeb ? UIKind.Web : UIKind.Desktop

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

@@ -131,7 +131,7 @@ export interface IResponsiveStateChangeEvent {
 }
 
 export interface IExtensionService {
-	_serviceBrand: undefined;
+	readonly _serviceBrand: undefined;
 
 	/**
 	 * An event emitted when extensions are registered after their extension points got handled.
@@ -259,7 +259,7 @@ export function toExtension(extensionDescription: IExtensionDescription): IExten
 
 
 export class NullExtensionService implements IExtensionService {
-	_serviceBrand: undefined;
+	declare readonly _serviceBrand: undefined;
 	onDidRegisterExtensions: Event<void> = Event.None;
 	onDidChangeExtensionsStatus: Event<ExtensionIdentifier[]> = Event.None;
 	onDidChangeExtensions: Event<void> = Event.None;

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

@@ -269,6 +269,11 @@ export const schema: IJSONSchema = {
 						description: nls.localize('vscode.extension.activationEvents.workspaceContains', 'An activation event emitted whenever a folder is opened that contains at least a file matching the specified glob pattern.'),
 						body: 'workspaceContains:${4:filePattern}'
 					},
+					{
+						label: 'onStartupFinished',
+						description: nls.localize('vscode.extension.activationEvents.onStartupFinished', 'An activation event emitted after the start-up finished (after all eager activated extensions have finished activating).'),
+						body: 'onStartupFinished'
+					},
 					{
 						label: 'onFileSystem',
 						description: nls.localize('vscode.extension.activationEvents.onFileSystem', 'An activation event emitted whenever a file or folder is accessed with the given scheme.'),

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

@@ -16,7 +16,7 @@ import { MessageType, createMessageOfType, isMessageOfType } from 'vs/workbench/
 import { IExtensionHostStarter, ExtensionHostLogFileName } from 'vs/workbench/services/extensions/common/extensions';
 import { parseExtensionDevOptions } from 'vs/workbench/services/extensions/common/extensionDevOptions';
 import { IRemoteAgentEnvironment } from 'vs/platform/remote/common/remoteAgentEnvironment';
-import { IRemoteAuthorityResolverService } from 'vs/platform/remote/common/remoteAuthorityResolver';
+import { IRemoteAuthorityResolverService, IRemoteConnectionData } from 'vs/platform/remote/common/remoteAuthorityResolver';
 import * as platform from 'vs/base/common/platform';
 import { Schemas } from 'vs/base/common/network';
 import { Disposable } from 'vs/base/common/lifecycle';
@@ -33,9 +33,14 @@ import { Registry } from 'vs/platform/registry/common/platform';
 import { IOutputChannelRegistry, Extensions } from 'vs/workbench/services/output/common/output';
 import { localize } from 'vs/nls';
 
+export interface IRemoteInitData {
+	readonly connectionData: IRemoteConnectionData | null;
+	readonly remoteEnvironment: IRemoteAgentEnvironment;
+}
+
 export interface IInitDataProvider {
 	readonly remoteAuthority: string;
-	getInitData(): Promise<IRemoteAgentEnvironment>;
+	getInitData(): Promise<IRemoteInitData>;
 }
 
 export class RemoteExtensionHostClient extends Disposable implements IExtensionHostStarter {
@@ -190,27 +195,28 @@ export class RemoteExtensionHostClient extends Disposable implements IExtensionH
 	}
 
 	private _createExtHostInitData(isExtensionDevelopmentDebug: boolean): Promise<IInitData> {
-		return Promise.all([this._allExtensions, this._telemetryService.getTelemetryInfo(), this._initDataProvider.getInitData()]).then(([allExtensions, telemetryInfo, remoteExtensionHostData]) => {
+		return Promise.all([this._allExtensions, this._telemetryService.getTelemetryInfo(), this._initDataProvider.getInitData()]).then(([allExtensions, telemetryInfo, remoteInitData]) => {
 			// Collect all identifiers for extension ids which can be considered "resolved"
 			const resolvedExtensions = allExtensions.filter(extension => !extension.main).map(extension => extension.identifier);
 			const hostExtensions = allExtensions.filter(extension => extension.main && extension.api === 'none').map(extension => extension.identifier);
 			const workspace = this._contextService.getWorkspace();
+			const remoteEnv = remoteInitData.remoteEnvironment;
 			const r: IInitData = {
 				commit: this._productService.commit,
 				version: this._productService.version,
 				vscodeVersion: this._productService.vscodeVersion, // {{SQL CARBON EDIT}} add vscode version
-				parentPid: remoteExtensionHostData.pid,
+				parentPid: remoteEnv.pid,
 				environment: {
 					isExtensionDevelopmentDebug,
-					appRoot: remoteExtensionHostData.appRoot,
-					appSettingsHome: remoteExtensionHostData.appSettingsHome,
+					appRoot: remoteEnv.appRoot,
+					appSettingsHome: remoteEnv.appSettingsHome,
 					appName: this._productService.nameLong,
 					appUriScheme: this._productService.urlProtocol,
 					appLanguage: platform.language,
 					extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
 					extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,
-					globalStorageHome: remoteExtensionHostData.globalStorageHome,
-					userHome: remoteExtensionHostData.userHome,
+					globalStorageHome: remoteEnv.globalStorageHome,
+					userHome: remoteEnv.userHome,
 					webviewResourceRoot: this._environmentService.webviewResourceRoot,
 					webviewCspSource: this._environmentService.webviewCspSource,
 				},
@@ -221,15 +227,16 @@ export class RemoteExtensionHostClient extends Disposable implements IExtensionH
 				},
 				remote: {
 					isRemote: true,
-					authority: this._initDataProvider.remoteAuthority
+					authority: this._initDataProvider.remoteAuthority,
+					connectionData: remoteInitData.connectionData
 				},
 				resolvedExtensions: resolvedExtensions,
 				hostExtensions: hostExtensions,
-				extensions: remoteExtensionHostData.extensions,
+				extensions: remoteEnv.extensions,
 				telemetryInfo,
 				logLevel: this._logService.getLevel(),
-				logsLocation: remoteExtensionHostData.extensionHostLogsPath,
-				logFile: joinPath(remoteExtensionHostData.extensionHostLogsPath, `${ExtensionHostLogFileName}.log`),
+				logsLocation: remoteEnv.extensionHostLogsPath,
+				logFile: joinPath(remoteEnv.extensionHostLogsPath, `${ExtensionHostLogFileName}.log`),
 				autoStart: true,
 				uiKind: platform.isWeb ? UIKind.Web : UIKind.Desktop
 			};

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

@@ -11,13 +11,13 @@ import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/
 export const IStaticExtensionsService = createDecorator<IStaticExtensionsService>('IStaticExtensionsService');
 
 export interface IStaticExtensionsService {
-	_serviceBrand: undefined;
+	readonly _serviceBrand: undefined;
 	getExtensions(): Promise<IExtensionDescription[]>;
 }
 
 export class StaticExtensionsService implements IStaticExtensionsService {
 
-	_serviceBrand: undefined;
+	declare readonly _serviceBrand: undefined;
 
 	private readonly _descriptions: IExtensionDescription[] = [];
 
@@ -27,6 +27,7 @@ export class StaticExtensionsService implements IStaticExtensionsService {
 		this._descriptions = staticExtensions.map(data => <IExtensionDescription>{
 			identifier: new ExtensionIdentifier(`${data.packageJSON.publisher}.${data.packageJSON.name}`),
 			extensionLocation: data.extensionLocation,
+			isBuiltin: !!data.isBuiltin,
 			...data.packageJSON,
 		});
 	}

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

@@ -18,7 +18,7 @@ import { INativeWorkbenchEnvironmentService } from 'vs/workbench/services/enviro
 import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
 import { IWorkbenchExtensionEnablementService } from 'vs/workbench/services/extensionManagement/common/extensionManagement';
 import { BUILTIN_MANIFEST_CACHE_FILE, MANIFEST_CACHE_FOLDER, USER_MANIFEST_CACHE_FILE, ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
-import product from 'vs/platform/product/common/product';
+import { IProductService } from 'vs/platform/product/common/productService';
 import { INotificationService, Severity } from 'vs/platform/notification/common/notification';
 import { IHostService } from 'vs/workbench/services/host/browser/host';
 import { ExtensionScanner, ExtensionScannerInput, IExtensionReference, IExtensionResolver, IRelaxedExtensionDescription } from 'vs/workbench/services/extensions/node/extensionPoints';
@@ -57,6 +57,7 @@ export class CachedExtensionScanner {
 		@IWorkbenchEnvironmentService private readonly _environmentService: INativeWorkbenchEnvironmentService,
 		@IWorkbenchExtensionEnablementService private readonly _extensionEnablementService: IWorkbenchExtensionEnablementService,
 		@IHostService private readonly _hostService: IHostService,
+		@IProductService private readonly _productService: IProductService
 	) {
 		this.scannedExtensions = new Promise<IExtensionDescription[]>((resolve, reject) => {
 			this._scannedExtensionsResolve = resolve;
@@ -68,8 +69,8 @@ export class CachedExtensionScanner {
 	public async scanSingleExtension(path: string, isBuiltin: boolean, log: ILog): Promise<IExtensionDescription | null> {
 		const translations = await this.translationConfig;
 
-		const version = product.version;
-		const commit = product.commit;
+		const version = this._productService.version;
+		const commit = this._productService.commit;
 		const devMode = !!process.env['VSCODE_DEV'];
 		const locale = platform.language;
 		const input = new ExtensionScannerInput(version, commit, locale, devMode, path, isBuiltin, false, translations);
@@ -79,7 +80,7 @@ export class CachedExtensionScanner {
 	public async startScanningExtensions(log: ILog): Promise<void> {
 		try {
 			const translations = await this.translationConfig;
-			const { system, user, development } = await CachedExtensionScanner._scanInstalledExtensions(this._hostService, this._notificationService, this._environmentService, this._extensionEnablementService, log, translations);
+			const { system, user, development } = await CachedExtensionScanner._scanInstalledExtensions(this._hostService, this._notificationService, this._environmentService, this._extensionEnablementService, this._productService, log, translations);
 
 			let result = new Map<string, IExtensionDescription>();
 			system.forEach((systemExtension) => {
@@ -239,12 +240,13 @@ export class CachedExtensionScanner {
 		notificationService: INotificationService,
 		environmentService: INativeWorkbenchEnvironmentService,
 		extensionEnablementService: IWorkbenchExtensionEnablementService,
+		productService: IProductService,
 		log: ILog,
 		translations: Translations
 	): Promise<{ system: IExtensionDescription[], user: IExtensionDescription[], development: IExtensionDescription[] }> {
 
-		const version = product.version;
-		const commit = product.commit;
+		const version = productService.version;
+		const commit = productService.commit;
 		const devMode = !!process.env['VSCODE_DEV'];
 		const locale = platform.language;
 
@@ -260,7 +262,7 @@ export class CachedExtensionScanner {
 		let finalBuiltinExtensions: Promise<IExtensionDescription[]> = builtinExtensions;
 
 		if (devMode) {
-			const builtInExtensions = Promise.resolve<IBuiltInExtension[]>(product.builtInExtensions || []);
+			const builtInExtensions = Promise.resolve<IBuiltInExtension[]>(productService.builtInExtensions || []);
 
 			const controlFilePath = path.join(os.homedir(), '.vscode-oss-dev', 'extensions', 'control.json');
 			const controlFile = pfs.readFile(controlFilePath, 'utf8')

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

@@ -25,7 +25,7 @@ import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/
 import { ILabelService } from 'vs/platform/label/common/label';
 import { ILifecycleService, WillShutdownEvent } from 'vs/platform/lifecycle/common/lifecycle';
 import { ILogService } from 'vs/platform/log/common/log';
-import product from 'vs/platform/product/common/product';
+import { IProductService } from 'vs/platform/product/common/productService';
 import { INotificationService, Severity } from 'vs/platform/notification/common/notification';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { IElectronService } from 'vs/platform/electron/electron-sandbox/electron';
@@ -85,7 +85,8 @@ export class ExtensionHostProcessWorker implements IExtensionHostStarter {
 		@ILogService private readonly _logService: ILogService,
 		@ILabelService private readonly _labelService: ILabelService,
 		@IExtensionHostDebugService private readonly _extensionHostDebugService: IExtensionHostDebugService,
-		@IHostService private readonly _hostService: IHostService
+		@IHostService private readonly _hostService: IHostService,
+		@IProductService private readonly _productService: IProductService
 	) {
 		const devOpts = parseExtensionDevOptions(this._environmentService);
 		this._isExtensionDevHost = devOpts.isExtensionDevHost;
@@ -150,7 +151,7 @@ export class ExtensionHostProcessWorker implements IExtensionHostStarter {
 						VERBOSE_LOGGING: true,
 						VSCODE_IPC_HOOK_EXTHOST: pipeName,
 						VSCODE_HANDLES_UNCAUGHT_ERRORS: true,
-						VSCODE_LOG_STACK: !this._isExtensionDevTestFromCli && (this._isExtensionDevHost || !this._environmentService.isBuilt || product.quality !== 'stable' || this._environmentService.verbose),
+						VSCODE_LOG_STACK: !this._isExtensionDevTestFromCli && (this._isExtensionDevHost || !this._environmentService.isBuilt || this._productService.quality !== 'stable' || this._environmentService.verbose),
 						VSCODE_LOG_LEVEL: this._environmentService.verbose ? 'trace' : this._environmentService.log
 					}),
 					// We only detach the extension host on windows. Linux and Mac orphan by default
@@ -175,8 +176,8 @@ export class ExtensionHostProcessWorker implements IExtensionHostStarter {
 				const crashesDirectory = this._environmentService.crashReporterDirectory;
 				if (crashesDirectory) {
 					const crashReporterOptions: CrashReporterStartOptions = {
-						companyName: product.crashReporter?.companyName || 'Microsoft',
-						productName: product.crashReporter?.productName || product.nameShort,
+						companyName: this._productService.crashReporter?.companyName || 'Microsoft',
+						productName: this._productService.crashReporter?.productName || this._productService.nameShort,
 						submitURL: '',
 						uploadToServer: false,
 						crashesDirectory
@@ -414,16 +415,16 @@ export class ExtensionHostProcessWorker implements IExtensionHostStarter {
 			.then(([telemetryInfo, extensionDescriptions]) => {
 				const workspace = this._contextService.getWorkspace();
 				const r: IInitData = {
-					commit: product.commit,
-					version: product.version,
-					vscodeVersion: product.vscodeVersion, // {{SQL CARBON EDIT}} add vscode version
+					commit: this._productService.commit,
+					version: this._productService.version,
+					vscodeVersion: this._productService.vscodeVersion, // {{SQL CARBON EDIT}} add vscode version
 					parentPid: process.pid,
 					environment: {
 						isExtensionDevelopmentDebug: this._isExtensionDevDebug,
 						appRoot: this._environmentService.appRoot ? URI.file(this._environmentService.appRoot) : undefined,
 						appSettingsHome: this._environmentService.appSettingsHome ? this._environmentService.appSettingsHome : undefined,
-						appName: product.nameLong,
-						appUriScheme: product.urlProtocol,
+						appName: this._productService.nameLong,
+						appUriScheme: this._productService.urlProtocol,
 						appLanguage: platform.language,
 						extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
 						extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,
@@ -440,6 +441,7 @@ export class ExtensionHostProcessWorker implements IExtensionHostStarter {
 					},
 					remote: {
 						authority: this._environmentService.configuration.remoteAuthority,
+						connectionData: null,
 						isRemote: false
 					},
 					resolvedExtensions: [],

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

@@ -3,7 +3,6 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { ipcRenderer } from 'vs/base/parts/sandbox/electron-sandbox/globals';
 import { ExtensionHostProcessWorker } from 'vs/workbench/services/extensions/electron-browser/extensionHost';
 import { CachedExtensionScanner } from 'vs/workbench/services/extensions/electron-browser/cachedExtensionScanner';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
@@ -52,7 +51,7 @@ class DeltaExtensionsQueueItem {
 
 export class ExtensionService extends AbstractExtensionService implements IExtensionService {
 
-	private readonly _remoteExtensionsEnvironmentData: Map<string, IRemoteAgentEnvironment>;
+	private readonly _remoteEnvironment: Map<string, IRemoteAgentEnvironment>;
 
 	private readonly _extensionScanner: CachedExtensionScanner;
 	private _deltaExtensionsQueue: DeltaExtensionsQueueItem[];
@@ -95,7 +94,7 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 			}]);
 		}
 
-		this._remoteExtensionsEnvironmentData = new Map<string, IRemoteAgentEnvironment>();
+		this._remoteEnvironment = new Map<string, IRemoteAgentEnvironment>();
 
 		this._extensionScanner = instantiationService.createInstance(CachedExtensionScanner);
 		this._deltaExtensionsQueue = [];
@@ -328,6 +327,12 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 					shouldActivateReason = activationEvent;
 					break;
 				}
+
+				if (activationEvent === 'onStartupFinished') {
+					shouldActivate = true;
+					shouldActivateReason = activationEvent;
+					break;
+				}
 			}
 		}
 
@@ -343,10 +348,11 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 	private _createProvider(remoteAuthority: string): IInitDataProvider {
 		return {
 			remoteAuthority: remoteAuthority,
-			getInitData: () => {
-				return this.whenInstalledExtensionsRegistered().then(() => {
-					return this._remoteExtensionsEnvironmentData.get(remoteAuthority)!;
-				});
+			getInitData: async () => {
+				await this.whenInstalledExtensionsRegistered();
+				const connectionData = this._remoteAuthorityResolverService.getConnectionData(remoteAuthority);
+				const remoteEnvironment = this._remoteEnvironment.get(remoteAuthority)!;
+				return { connectionData, remoteEnvironment };
 			}
 		};
 	}
@@ -432,12 +438,12 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 		}
 
 		const extensionHost = this._extensionHostProcessManagers[0];
-		this._remoteAuthorityResolverService.clearResolvedAuthority(remoteAuthority);
+		this._remoteAuthorityResolverService._clearResolvedAuthority(remoteAuthority);
 		try {
 			const result = await extensionHost.resolveAuthority(remoteAuthority);
-			this._remoteAuthorityResolverService.setResolvedAuthority(result.authority, result.options);
+			this._remoteAuthorityResolverService._setResolvedAuthority(result.authority, result.options);
 		} catch (err) {
-			this._remoteAuthorityResolverService.setResolvedAuthorityError(remoteAuthority, err);
+			this._remoteAuthorityResolverService._setResolvedAuthorityError(remoteAuthority, err);
 		}
 	}
 
@@ -470,7 +476,7 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 						console.log(`Error handled: Not showing a notification for the error`);
 					}
 				}
-				this._remoteAuthorityResolverService.setResolvedAuthorityError(remoteAuthority, err);
+				this._remoteAuthorityResolverService._setResolvedAuthorityError(remoteAuthority, err);
 
 				// Proceed with the local extension host
 				await this._startLocalExtensionHost(extensionHost, localExtensions, localExtensions.map(extension => extension.identifier));
@@ -478,7 +484,7 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 			}
 
 			// set the resolved authority
-			this._remoteAuthorityResolverService.setResolvedAuthority(resolvedAuthority.authority, resolvedAuthority.options);
+			this._remoteAuthorityResolverService._setResolvedAuthority(resolvedAuthority.authority, resolvedAuthority.options);
 			this._remoteExplorerService.setTunnelInformation(resolvedAuthority.tunnelInformation);
 
 			// monitor for breakage
@@ -490,7 +496,7 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 						return;
 					}
 					if (e.type === PersistentConnectionEventType.ConnectionLost) {
-						this._remoteAuthorityResolverService.clearResolvedAuthority(remoteAuthority);
+						this._remoteAuthorityResolverService._clearResolvedAuthority(remoteAuthority);
 					}
 				});
 				connection.onReconnecting(() => this._resolveAuthorityAgain());
@@ -546,7 +552,7 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 			remoteEnv.extensions = remoteEnv.extensions.filter(ext => runningLocation.get(ExtensionIdentifier.toKey(ext.identifier)) === RunningLocation.Remote);
 
 			// save for remote extension's init data
-			this._remoteExtensionsEnvironmentData.set(remoteAuthority, remoteEnv);
+			this._remoteEnvironment.set(remoteAuthority, remoteEnv);
 
 			await this._startLocalExtensionHost(extensionHost, remoteEnv.extensions.concat(localExtensions), localExtensions.map(extension => extension.identifier));
 		} else {
@@ -578,7 +584,7 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 	public _onExtensionHostExit(code: number): void {
 		if (this._isExtensionDevTestFromCli) {
 			// When CLI testing make sure to exit with proper exit code
-			ipcRenderer.send('vscode:exit', code);
+			this._electronService.exit(code);
 		} else {
 			// Expected development extension termination: When the extension host goes down we also shutdown the window
 			this._electronService.closeWindow();

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

@@ -24,7 +24,7 @@ import { joinPath } from 'vs/base/common/resources';
 
 export class RemoteExtensionManagementChannelClient extends ExtensionManagementChannelClient {
 
-	_serviceBrand: undefined;
+	declare readonly _serviceBrand: undefined;
 
 	constructor(
 		channel: IChannel,

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

@@ -299,7 +299,7 @@ export async function startExtensionHostProcess(): Promise<void> {
 
 	// host abstraction
 	const hostUtils = new class NodeHost implements IHostUtils {
-		_serviceBrand: undefined;
+		declare readonly _serviceBrand: undefined;
 		exit(code: number) { nativeExit(code); }
 		exists(path: string) { return exists(path); }
 		realpath(path: string) { return realpath(path); }

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

@@ -36,7 +36,7 @@ self.addEventLister = () => console.trace(`'addEventListener' has been blocked`)
 //#endregion ---
 
 const hostUtil = new class implements IHostUtils {
-	_serviceBrand: undefined;
+	declare readonly _serviceBrand: undefined;
 	exit(_code?: number | undefined): void {
 		nativeClose();
 	}