Merge from vscode 93309f060778f6480a7d2a13913e6e7c624e9bc7

src/vs/platform/actions/common/actions.ts

@@ -126,6 +126,7 @@ export class MenuId {
 	static readonly TimelineTitle = new MenuId('TimelineTitle');
 	static readonly TimelineTitleContext = new MenuId('TimelineTitleContext');
 	static readonly AccountsContext = new MenuId('AccountsContext');
+	static readonly WebMenuActions = new MenuId('MenubarWebMenu');
 
 	readonly id: number;
 	readonly _debugName: string;

src/vs/platform/environment/node/argv.ts

@@ -49,7 +49,6 @@ export const OPTIONS: OptionDescriptions<Required<ParsedArgs>> = {
 	'waitMarkerFilePath': { type: 'string' },
 	'locale': { type: 'string', cat: 'o', args: 'locale', description: localize('locale', "The locale to use (e.g. en-US or zh-TW).") },
 	'user-data-dir': { type: 'string', cat: 'o', args: 'dir', description: localize('userDataDir', "Specifies the directory that user data is kept in. Can be used to open multiple distinct instances of Code.") },
-	'telemetry': { type: 'boolean', cat: 'o', description: localize('telemetry', "Shows all telemetry events which VS code collects.") },
 	'help': { type: 'boolean', cat: 'o', alias: 'h', description: localize('help', "Print usage.") },
 
 	'extensions-dir': { type: 'string', deprecates: 'extensionHomePath', cat: 'e', args: 'dir', description: localize('extensionHomePath', "Set the root path for extensions.") },
@@ -76,6 +75,7 @@ export const OPTIONS: OptionDescriptions<Required<ParsedArgs>> = {
 	'inspect-brk-extensions': { type: 'string', deprecates: 'debugBrkPluginHost', args: 'port', cat: 't', description: localize('inspect-brk-extensions', "Allow debugging and profiling of extensions with the extension host being paused after start. Check the developer tools for the connection URI.") },
 	'disable-gpu': { type: 'boolean', cat: 't', description: localize('disableGPU', "Disable GPU hardware acceleration.") },
 	'max-memory': { type: 'string', cat: 't', description: localize('maxMemory', "Max memory size for a window (in Mbytes).") },
+	'telemetry': { type: 'boolean', cat: 't', description: localize('telemetry', "Shows all telemetry events which VS code collects.") },
 
 	'remote': { type: 'string' },
 	'locate-extension': { type: 'string[]' },

src/vs/platform/quickinput/browser/commandsQuickAccess.ts

@@ -21,6 +21,7 @@ import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { isPromiseCanceledError } from 'vs/base/common/errors';
 import { INotificationService } from 'vs/platform/notification/common/notification';
 import { toErrorMessage } from 'vs/base/common/errorMessage';
+import { IStorageKeysSyncRegistryService } from 'vs/platform/userDataSync/common/storageKeys';
 
 export interface ICommandQuickPick extends IPickerQuickAccessItem {
 	commandId: string;
@@ -202,10 +203,15 @@ export class CommandsHistory extends Disposable {
 
 	constructor(
 		@IStorageService private readonly storageService: IStorageService,
-		@IConfigurationService private readonly configurationService: IConfigurationService
+		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@IStorageKeysSyncRegistryService storageKeysSyncRegistryService: IStorageKeysSyncRegistryService
 	) {
 		super();
 
+		// opt-in to syncing
+		storageKeysSyncRegistryService.registerStorageKey({ key: CommandsHistory.PREF_KEY_CACHE, version: 1 });
+		storageKeysSyncRegistryService.registerStorageKey({ key: CommandsHistory.PREF_KEY_COUNTER, version: 1 });
+
 		this.updateConfiguration();
 		this.load();
 

src/vs/platform/quickinput/browser/pickerQuickAccess.ts

@@ -63,12 +63,22 @@ export interface IPickerQuickAccessProviderOptions {
 	canAcceptInBackground?: boolean;
 }
 
-export type FastAndSlowPicksType<T> = { picks: Array<T | IQuickPickSeparator>, additionalPicks: Promise<Array<T | IQuickPickSeparator>> };
+export type Pick<T> = T | IQuickPickSeparator;
+export type PicksWithActive<T> = { items: ReadonlyArray<Pick<T>>, active?: T };
+export type Picks<T> = ReadonlyArray<Pick<T>> | PicksWithActive<T>;
+export type FastAndSlowPicks<T> = { picks: Picks<T>, additionalPicks: Promise<Picks<T>> };
+export type FastAndSlowPicksWithActive<T> = { picks: PicksWithActive<T>, additionalPicks: PicksWithActive<Picks<T>> };
 
-function isFastAndSlowPicksType<T>(obj: unknown): obj is FastAndSlowPicksType<T> {
-	const candidate = obj as FastAndSlowPicksType<T>;
+function isPicksWithActive<T>(obj: unknown): obj is PicksWithActive<T> {
+	const candidate = obj as PicksWithActive<T>;
 
-	return Array.isArray(candidate.picks) && candidate.additionalPicks instanceof Promise;
+	return Array.isArray(candidate.items);
+}
+
+function isFastAndSlowPicks<T>(obj: unknown): obj is FastAndSlowPicks<T> {
+	const candidate = obj as FastAndSlowPicks<T>;
+
+	return !!candidate.picks && candidate.additionalPicks instanceof Promise;
 }
 
 export abstract class PickerQuickAccessProvider<T extends IPickerQuickAccessItem> extends Disposable implements IQuickAccessProvider {
@@ -103,15 +113,26 @@ export abstract class PickerQuickAccessProvider<T extends IPickerQuickAccessItem
 
 			// Collect picks and support both long running and short or combined
 			const picksToken = picksCts.token;
-			const res = this.getPicks(picker.value.substr(this.prefix.length).trim(), picksDisposables, picksToken);
+			const providedPicks = this.getPicks(picker.value.substr(this.prefix.length).trim(), picksDisposables, picksToken);
+
+			function applyPicks(picks: Picks<T>): void {
+				if (isPicksWithActive(picks)) {
+					picker.items = picks.items;
+					if (picks.active) {
+						picker.activeItems = [picks.active];
+					}
+				} else {
+					picker.items = picks;
+				}
+			}
 
 			// No Picks
-			if (res === null) {
+			if (providedPicks === null) {
 				// Ignore
 			}
 
 			// Fast and Slow Picks
-			else if (isFastAndSlowPicksType(res)) {
+			else if (isFastAndSlowPicks(providedPicks)) {
 				let fastPicksHandlerDone = false;
 				let slowPicksHandlerDone = false;
 
@@ -129,7 +150,7 @@ export abstract class PickerQuickAccessProvider<T extends IPickerQuickAccessItem
 							}
 
 							if (!slowPicksHandlerDone) {
-								picker.items = res.picks;
+								applyPicks(providedPicks.picks);
 							}
 						} finally {
 							fastPicksHandlerDone = true;
@@ -142,13 +163,34 @@ export abstract class PickerQuickAccessProvider<T extends IPickerQuickAccessItem
 					(async () => {
 						picker.busy = true;
 						try {
-							const additionalPicks = await res.additionalPicks;
+							const awaitedAdditionalPicks = await providedPicks.additionalPicks;
 							if (picksToken.isCancellationRequested) {
 								return;
 							}
 
+							let picks: ReadonlyArray<Pick<T>>;
+							let activePick: Pick<T> | undefined = undefined;
+							if (isPicksWithActive(providedPicks.picks)) {
+								picks = providedPicks.picks.items;
+								activePick = providedPicks.picks.active;
+							} else {
+								picks = providedPicks.picks;
+							}
+
+							let additionalPicks: ReadonlyArray<Pick<T>>;
+							let additionalActivePick: Pick<T> | undefined = undefined;
+							if (isPicksWithActive(awaitedAdditionalPicks)) {
+								additionalPicks = awaitedAdditionalPicks.items;
+								additionalActivePick = awaitedAdditionalPicks.active;
+							} else {
+								additionalPicks = awaitedAdditionalPicks;
+							}
+
 							if (additionalPicks.length > 0 || !fastPicksHandlerDone) {
-								picker.items = [...res.picks, ...additionalPicks];
+								applyPicks({
+									items: [...picks, ...additionalPicks],
+									active: activePick as T || additionalActivePick as T // {{SQL CARBON EDIT}} strict-null-checks
+								});
 							}
 						} finally {
 							if (!picksToken.isCancellationRequested) {
@@ -162,20 +204,20 @@ export abstract class PickerQuickAccessProvider<T extends IPickerQuickAccessItem
 			}
 
 			// Fast Picks
-			else if (Array.isArray(res)) {
-				picker.items = res;
+			else if (!(providedPicks instanceof Promise)) {
+				applyPicks(providedPicks);
 			}
 
 			// Slow Picks
 			else {
 				picker.busy = true;
 				try {
-					const items = await res;
+					const awaitedPicks = await providedPicks;
 					if (picksToken.isCancellationRequested) {
 						return;
 					}
 
-					picker.items = items;
+					applyPicks(awaitedPicks);
 				} finally {
 					if (!picksToken.isCancellationRequested) {
 						picker.busy = false;
@@ -251,5 +293,5 @@ export abstract class PickerQuickAccessProvider<T extends IPickerQuickAccessItem
 	 * @returns the picks either directly, as promise or combined fast and slow results.
 	 * Pickers can return `null` to signal that no change in picks is needed.
 	 */
-	protected abstract getPicks(filter: string, disposables: DisposableStore, token: CancellationToken): Array<T | IQuickPickSeparator> | Promise<Array<T | IQuickPickSeparator>> | FastAndSlowPicksType<T> | null;
+	protected abstract getPicks(filter: string, disposables: DisposableStore, token: CancellationToken): Picks<T> | Promise<Picks<T>> | FastAndSlowPicks<T> | null;
 }

src/vs/platform/storage/node/storageIpc.ts

@@ -9,7 +9,6 @@ import { IStorageChangeEvent, IStorageMainService } from 'vs/platform/storage/no
 import { IUpdateRequest, IStorageDatabase, IStorageItemsChangeEvent } from 'vs/base/parts/storage/common/storage';
 import { mapToSerializable, serializableToMap, values } from 'vs/base/common/map';
 import { Disposable, IDisposable, dispose } from 'vs/base/common/lifecycle';
-import { onUnexpectedError } from 'vs/base/common/errors';
 import { ILogService } from 'vs/platform/log/common/log';
 import { generateUuid } from 'vs/base/common/uuid';
 import { instanceStorageKey, firstSessionDateStorageKey, lastSessionDateStorageKey, currentSessionDateStorageKey, crashReporterIdStorageKey } from 'vs/platform/telemetry/common/telemetry';
@@ -50,8 +49,7 @@ export class GlobalStorageDatabaseChannel extends Disposable implements IServerC
 		try {
 			await this.storageMainService.initialize();
 		} catch (error) {
-			onUnexpectedError(error);
-			this.logService.error(error);
+			this.logService.error(`[storage] init(): Unable to init global storage due to ${error}`);
 		}
 
 		// This is unique to the application instance and thereby

src/vs/platform/storage/node/storageService.ts

@@ -14,7 +14,6 @@ import { join } from 'vs/base/common/path';
 import { copy, exists, mkdirp, writeFile } from 'vs/base/node/pfs';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { IWorkspaceInitializationPayload, isWorkspaceIdentifier, isSingleFolderWorkspaceInitializationPayload } from 'vs/platform/workspaces/common/workspaces';
-import { onUnexpectedError } from 'vs/base/common/errors';
 import { assertIsDefined } from 'vs/base/common/types';
 import { RunOnceScheduler, runWhenIdle } from 'vs/base/common/async';
 
@@ -31,7 +30,7 @@ export class NativeStorageService extends Disposable implements IStorageService
 	private readonly _onWillSaveState = this._register(new Emitter<IWillSaveStateEvent>());
 	readonly onWillSaveState = this._onWillSaveState.event;
 
-	private globalStorage: IStorage;
+	private readonly globalStorage = new Storage(this.globalStorageDatabase);
 
 	private workspaceStoragePath: string | undefined;
 	private workspaceStorage: IStorage | undefined;
@@ -43,14 +42,13 @@ export class NativeStorageService extends Disposable implements IStorageService
 	private runWhenIdleDisposable: IDisposable | undefined = undefined;
 
 	constructor(
-		globalStorageDatabase: IStorageDatabase,
+		private globalStorageDatabase: IStorageDatabase,
 		@ILogService private readonly logService: ILogService,
 		@IEnvironmentService private readonly environmentService: IEnvironmentService
 	) {
 		super();
 
-		// Global Storage
-		this.globalStorage = new Storage(globalStorageDatabase);
+		// Global Storage change events
 		this._register(this.globalStorage.onDidChangeStorage(key => this.handleDidChangeStorage(key, StorageScope.GLOBAL)));
 	}
 
@@ -95,15 +93,16 @@ export class NativeStorageService extends Disposable implements IStorageService
 			// Create workspace storage and initialize
 			mark('willInitWorkspaceStorage');
 			try {
-				await this.createWorkspaceStorage(useInMemoryStorage ? SQLiteStorageDatabase.IN_MEMORY_PATH : join(result.path, NativeStorageService.WORKSPACE_STORAGE_NAME), result.wasCreated ? StorageHint.STORAGE_DOES_NOT_EXIST : undefined).init();
+				const workspaceStorage = this.createWorkspaceStorage(
+					useInMemoryStorage ? SQLiteStorageDatabase.IN_MEMORY_PATH : join(result.path, NativeStorageService.WORKSPACE_STORAGE_NAME),
+					result.wasCreated ? StorageHint.STORAGE_DOES_NOT_EXIST : undefined
+				);
+				await workspaceStorage.init();
 			} finally {
 				mark('didInitWorkspaceStorage');
 			}
 		} catch (error) {
-			onUnexpectedError(error);
-
-			// Upon error, fallback to in-memory storage
-			return this.createWorkspaceStorage(SQLiteStorageDatabase.IN_MEMORY_PATH).init();
+			this.logService.error(`[storage] initializeWorkspaceStorage(): Unable to init workspace storage due to ${error}`);
 		}
 	}
 
@@ -156,6 +155,7 @@ export class NativeStorageService extends Disposable implements IStorageService
 		}
 
 		if (meta) {
+			const logService = this.logService;
 			const workspaceStorageMetaPath = join(this.getWorkspaceStorageFolderPath(payload), NativeStorageService.WORKSPACE_META_NAME);
 			(async function () {
 				try {
@@ -164,7 +164,7 @@ export class NativeStorageService extends Disposable implements IStorageService
 						await writeFile(workspaceStorageMetaPath, JSON.stringify(meta, undefined, 2));
 					}
 				} catch (error) {
-					onUnexpectedError(error);
+					logService.error(error);
 				}
 			})();
 		}