VS Code merge to df8fe74bd55313de0dd2303bc47a4aab0ca56b0e (#17979)

* Merge from vscode 504f934659740e9d41501cad9f162b54d7745ad9

* delete unused folders

* distro

* Bump build node version

* update chokidar

* FIx hygiene errors

* distro

* Fix extension lint issues

* Remove strict-vscode

* Add copyright header exemptions

* Bump vscode-extension-telemetry to fix webpacking issue with zone.js

* distro

* Fix failing tests (revert marked.js back to current one until we decide to update)

* Skip searchmodel test

* Fix mac build

* temp debug script loading

* Try disabling coverage

* log error too

* Revert "log error too"

This reverts commit af0183e5d4ab458fdf44b88fbfab9908d090526f.

* Revert "temp debug script loading"

This reverts commit 3d687d541c76db2c5b55626c78ae448d3c25089c.

* Add comments explaining coverage disabling

* Fix ansi_up loading issue

* Merge latest from ads

* Use newer option

* Fix compile

* add debug logging warn

* Always log stack

* log more

* undo debug

* Update to use correct base path (+cleanup)

* distro

* fix compile errors

* Remove strict-vscode

* Fix sql editors not showing

* Show db dropdown input & fix styling

* Fix more info in gallery

* Fix gallery asset requests

* Delete unused workflow

* Fix tapable resolutions for smoke test compile error

* Fix smoke compile

* Disable crash reporting

* Disable interactive

Co-authored-by: ADS Merger <karlb@microsoft.com>

src/vs/platform/driver/browser/baseDriver.ts

@@ -3,9 +3,11 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { getTopLeftOffset, getClientArea } from 'vs/base/browser/dom';
+import { getClientArea, getTopLeftOffset } from 'vs/base/browser/dom';
 import { coalesce } from 'vs/base/common/arrays';
-import { IElement, IWindowDriver } from 'vs/platform/driver/common/driver';
+import { language, locale } from 'vs/base/common/platform';
+import { IElement, ILocaleInfo, ILocalizedStrings, IWindowDriver } from 'vs/platform/driver/common/driver';
+import localizedStrings from 'vs/platform/localizations/common/localizedStrings';
 
 function serializeElement(element: Element, recursive: boolean): IElement {
 	const attributes = Object.create(null);
@@ -161,6 +163,21 @@ export abstract class BaseWindowDriver implements IWindowDriver {
 		xterm._core._coreService.triggerDataEvent(text);
 	}
 
+	getLocaleInfo(): Promise<ILocaleInfo> {
+		return Promise.resolve({
+			language: language,
+			locale: locale
+		});
+	}
+
+	getLocalizedStrings(): Promise<ILocalizedStrings> {
+		return Promise.resolve({
+			open: localizedStrings.open,
+			close: localizedStrings.close,
+			find: localizedStrings.find
+		});
+	}
+
 	protected async _getElementXY(selector: string, offset?: { x: number, y: number }): Promise<{ x: number; y: number; }> {
 		const element = document.querySelector(selector);
 

src/vs/platform/driver/common/driver.ts

@@ -18,13 +18,31 @@ export interface IElement {
 	left: number;
 }
 
+export interface ILocaleInfo {
+	/**
+	 * The UI language used.
+	 */
+	language: string;
+
+	/**
+	 * The requested locale
+	 */
+	locale?: string;
+}
+
+export interface ILocalizedStrings {
+	open: string;
+	close: string;
+	find: string;
+}
+
 export interface IDriver {
 	readonly _serviceBrand: undefined;
 
 	getWindowIds(): Promise<number[]>;
 	capturePage(windowId: number): Promise<string>;
 	reloadWindow(windowId: number): Promise<void>;
-	exitApplication(): Promise<void>;
+	exitApplication(): Promise<boolean>;
 	dispatchKeybinding(windowId: number, keybinding: string): Promise<void>;
 	click(windowId: number, selector: string, xoffset?: number | undefined, yoffset?: number | undefined): Promise<void>;
 	doubleClick(windowId: number, selector: string): Promise<void>;
@@ -36,6 +54,8 @@ export interface IDriver {
 	typeInEditor(windowId: number, selector: string, text: string): Promise<void>;
 	getTerminalBuffer(windowId: number, selector: string): Promise<string[]>;
 	writeInTerminal(windowId: number, selector: string, text: string): Promise<void>;
+	getLocaleInfo(windowId: number): Promise<ILocaleInfo>;
+	getLocalizedStrings(windowId: number): Promise<ILocalizedStrings>;
 }
 //*END
 
@@ -53,6 +73,8 @@ export interface IWindowDriver {
 	typeInEditor(selector: string, text: string): Promise<void>;
 	getTerminalBuffer(selector: string): Promise<string[]>;
 	writeInTerminal(selector: string, text: string): Promise<void>;
+	getLocaleInfo(): Promise<ILocaleInfo>;
+	getLocalizedStrings(): Promise<ILocalizedStrings>
 }
 
 export interface IDriverOptions {

src/vs/platform/driver/common/driverIpc.ts

@@ -5,7 +5,7 @@
 
 import { Event } from 'vs/base/common/event';
 import { IChannel, IServerChannel } from 'vs/base/parts/ipc/common/ipc';
-import { IDriverOptions, IElement, IWindowDriver, IWindowDriverRegistry } from 'vs/platform/driver/common/driver';
+import { IDriverOptions, IElement, ILocaleInfo, ILocalizedStrings as ILocalizedStrings, IWindowDriver, IWindowDriverRegistry } from 'vs/platform/driver/common/driver';
 
 export class WindowDriverChannel implements IServerChannel {
 
@@ -27,6 +27,8 @@ export class WindowDriverChannel implements IServerChannel {
 			case 'typeInEditor': return this.driver.typeInEditor(arg[0], arg[1]);
 			case 'getTerminalBuffer': return this.driver.getTerminalBuffer(arg);
 			case 'writeInTerminal': return this.driver.writeInTerminal(arg[0], arg[1]);
+			case 'getLocaleInfo': return this.driver.getLocaleInfo();
+			case 'getLocalizedStrings': return this.driver.getLocalizedStrings();
 		}
 
 		throw new Error(`Call not found: ${command}`);
@@ -78,6 +80,14 @@ export class WindowDriverChannelClient implements IWindowDriver {
 	writeInTerminal(selector: string, text: string): Promise<void> {
 		return this.channel.call('writeInTerminal', [selector, text]);
 	}
+
+	getLocaleInfo(): Promise<ILocaleInfo> {
+		return this.channel.call('getLocaleInfo');
+	}
+
+	getLocalizedStrings(): Promise<ILocalizedStrings> {
+		return this.channel.call('getLocalizedStrings');
+	}
 }
 
 export class WindowDriverRegistryChannelClient implements IWindowDriverRegistry {

src/vs/platform/driver/electron-main/driver.ts

@@ -3,24 +3,23 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { DriverChannel, WindowDriverRegistryChannel } from 'vs/platform/driver/node/driver';
-import { WindowDriverChannelClient } from 'vs/platform/driver/common/driverIpc';
-import { IWindowsMainService } from 'vs/platform/windows/electron-main/windows';
-import { serve as serveNet } from 'vs/base/parts/ipc/node/ipc.net';
-import { combinedDisposable, IDisposable } from 'vs/base/common/lifecycle';
-import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { IPCServer, StaticRouter } from 'vs/base/parts/ipc/common/ipc';
-import { SimpleKeybinding, KeyCode } from 'vs/base/common/keyCodes';
-import { USLayoutResolvedKeybinding } from 'vs/platform/keybinding/common/usLayoutResolvedKeybinding';
-import { OS } from 'vs/base/common/platform';
-import { Emitter, Event } from 'vs/base/common/event';
-import { IEnvironmentMainService } from 'vs/platform/environment/electron-main/environmentMainService';
-import { ScanCodeBinding } from 'vs/base/common/scanCode';
-import { KeybindingParser } from 'vs/base/common/keybindingParser';
 import { timeout } from 'vs/base/common/async';
-import { IDriver, IDriverOptions, IElement, IWindowDriver, IWindowDriverRegistry } from 'vs/platform/driver/common/driver';
+import { Emitter, Event } from 'vs/base/common/event';
+import { KeybindingParser } from 'vs/base/common/keybindingParser';
+import { KeyCode, SimpleKeybinding } from 'vs/base/common/keyCodes';
+import { combinedDisposable, IDisposable } from 'vs/base/common/lifecycle';
+import { OS } from 'vs/base/common/platform';
+import { ScanCodeBinding } from 'vs/base/common/scanCode';
+import { IPCServer, StaticRouter } from 'vs/base/parts/ipc/common/ipc';
+import { serve as serveNet } from 'vs/base/parts/ipc/node/ipc.net';
+import { IDriver, IDriverOptions, IElement, ILocaleInfo, ILocalizedStrings, IWindowDriver, IWindowDriverRegistry } from 'vs/platform/driver/common/driver';
+import { WindowDriverChannelClient } from 'vs/platform/driver/common/driverIpc';
+import { DriverChannel, WindowDriverRegistryChannel } from 'vs/platform/driver/node/driver';
+import { IEnvironmentMainService } from 'vs/platform/environment/electron-main/environmentMainService';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { USLayoutResolvedKeybinding } from 'vs/platform/keybinding/common/usLayoutResolvedKeybinding';
 import { ILifecycleMainService } from 'vs/platform/lifecycle/electron-main/lifecycleMainService';
-import { INativeHostMainService } from 'vs/platform/native/electron-main/nativeHostMainService';
+import { IWindowsMainService } from 'vs/platform/windows/electron-main/windows';
 
 function isSilentKeyCode(keyCode: KeyCode) {
 	return keyCode < KeyCode.KEY_0;
@@ -38,8 +37,7 @@ export class Driver implements IDriver, IWindowDriverRegistry {
 		private windowServer: IPCServer,
 		private options: IDriverOptions,
 		@IWindowsMainService private readonly windowsMainService: IWindowsMainService,
-		@ILifecycleMainService private readonly lifecycleMainService: ILifecycleMainService,
-		@INativeHostMainService private readonly nativeHostMainService: INativeHostMainService
+		@ILifecycleMainService private readonly lifecycleMainService: ILifecycleMainService
 	) { }
 
 	async registerWindowDriver(windowId: number): Promise<IDriverOptions> {
@@ -82,8 +80,8 @@ export class Driver implements IDriver, IWindowDriverRegistry {
 		this.lifecycleMainService.reload(window);
 	}
 
-	async exitApplication(): Promise<void> {
-		return this.nativeHostMainService.quit(undefined);
+	exitApplication(): Promise<boolean> {
+		return this.lifecycleMainService.quit();
 	}
 
 	async dispatchKeybinding(windowId: number, keybinding: string): Promise<void> {
@@ -189,6 +187,16 @@ export class Driver implements IDriver, IWindowDriverRegistry {
 		await windowDriver.writeInTerminal(selector, text);
 	}
 
+	async getLocaleInfo(windowId: number): Promise<ILocaleInfo> {
+		const windowDriver = await this.getWindowDriver(windowId);
+		return await windowDriver.getLocaleInfo();
+	}
+
+	async getLocalizedStrings(windowId: number): Promise<ILocalizedStrings> {
+		const windowDriver = await this.getWindowDriver(windowId);
+		return await windowDriver.getLocalizedStrings();
+	}
+
 	private async getWindowDriver(windowId: number): Promise<IWindowDriver> {
 		await this.whenUnfrozen(windowId);
 

src/vs/platform/driver/electron-sandbox/driver.ts

@@ -3,12 +3,12 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { timeout } from 'vs/base/common/async';
 import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { BaseWindowDriver } from 'vs/platform/driver/browser/baseDriver';
 import { WindowDriverChannel, WindowDriverRegistryChannelClient } from 'vs/platform/driver/common/driverIpc';
 import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
 import { IMainProcessService } from 'vs/platform/ipc/electron-sandbox/services';
-import { timeout } from 'vs/base/common/async';
-import { BaseWindowDriver } from 'vs/platform/driver/browser/baseDriver';
 import { INativeHostService } from 'vs/platform/native/electron-sandbox/native';
 
 class WindowDriver extends BaseWindowDriver {

src/vs/platform/driver/node/driver.ts

@@ -3,11 +3,11 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { Event } from 'vs/base/common/event';
+import { IChannel, IServerChannel } from 'vs/base/parts/ipc/common/ipc';
 import { Client } from 'vs/base/parts/ipc/common/ipc.net';
 import { connect as connectNet } from 'vs/base/parts/ipc/node/ipc.net';
-import { IChannel, IServerChannel } from 'vs/base/parts/ipc/common/ipc';
-import { Event } from 'vs/base/common/event';
-import { IDriver, IElement, IWindowDriverRegistry } from 'vs/platform/driver/common/driver';
+import { IDriver, IElement, ILocaleInfo, ILocalizedStrings, IWindowDriverRegistry } from 'vs/platform/driver/common/driver';
 
 export class DriverChannel implements IServerChannel {
 
@@ -34,6 +34,8 @@ export class DriverChannel implements IServerChannel {
 			case 'typeInEditor': return this.driver.typeInEditor(arg[0], arg[1], arg[2]);
 			case 'getTerminalBuffer': return this.driver.getTerminalBuffer(arg[0], arg[1]);
 			case 'writeInTerminal': return this.driver.writeInTerminal(arg[0], arg[1], arg[2]);
+			case 'getLocaleInfo': return this.driver.getLocaleInfo(arg);
+			case 'getLocalizedStrings': return this.driver.getLocalizedStrings(arg);
 		}
 
 		throw new Error(`Call not found: ${command}`);
@@ -58,7 +60,7 @@ export class DriverChannelClient implements IDriver {
 		return this.channel.call('reloadWindow', windowId);
 	}
 
-	exitApplication(): Promise<void> {
+	exitApplication(): Promise<boolean> {
 		return this.channel.call('exitApplication');
 	}
 
@@ -105,6 +107,14 @@ export class DriverChannelClient implements IDriver {
 	writeInTerminal(windowId: number, selector: string, text: string): Promise<void> {
 		return this.channel.call('writeInTerminal', [windowId, selector, text]);
 	}
+
+	getLocaleInfo(windowId: number): Promise<ILocaleInfo> {
+		return this.channel.call('getLocaleInfo', windowId);
+	}
+
+	getLocalizedStrings(windowId: number): Promise<ILocalizedStrings> {
+		return this.channel.call('getLocalizedStrings', windowId);
+	}
 }
 
 export class WindowDriverRegistryChannel implements IServerChannel {