Merge from vscode 2e5312cd61ff99c570299ecc122c52584265eda2

2026-02-09 09:42:34 -05:00 · 2020-04-23 02:50:35 +00:00
parent 3603f55d97
commit 7f1d8fc32f
659 changed files with 22709 additions and 12497 deletions
--- a/src/vs/platform/actions/common/actions.ts
+++ b/src/vs/platform/actions/common/actions.ts
@@ -346,6 +346,17 @@ export class SyncActionDescriptor {
 		return new SyncActionDescriptor(ctor as IConstructorSignature2<string, string | undefined, Action>, id, label, keybindings, keybindingContext, keybindingWeight);
 	}

+	public static from<Services extends BrandedService[]>(
+		ctor: {
+			new(id: string, label: string, ...services: Services): Action;
+			readonly ID: string;
+			readonly LABEL: string;
+		},
+		keybindings?: IKeybindings, keybindingContext?: ContextKeyExpression, keybindingWeight?: number
+	): SyncActionDescriptor {
+		return SyncActionDescriptor.create(ctor, ctor.ID, ctor.LABEL, keybindings, keybindingContext, keybindingWeight);
+	}
+
 	private constructor(ctor: IConstructorSignature2<string, string | undefined, Action>,
 		id: string, label: string | undefined, keybindings?: IKeybindings, keybindingContext?: ContextKeyExpression, keybindingWeight?: number
 	) {
--- a/src/vs/platform/authentication/common/authentication.ts
+++ b/src/vs/platform/authentication/common/authentication.ts
@@ -9,14 +9,19 @@ import { Disposable } from 'vs/base/common/lifecycle';

 export const IAuthenticationTokenService = createDecorator<IAuthenticationTokenService>('IAuthenticationTokenService');

+export interface IUserDataSyncAuthToken {
+	readonly authenticationProviderId: string;
+	readonly token: string;
+}
+
 export interface IAuthenticationTokenService {
 	_serviceBrand: undefined;

-	readonly onDidChangeToken: Event<string | undefined>;
+	readonly onDidChangeToken: Event<IUserDataSyncAuthToken | undefined>;
 	readonly onTokenFailed: Event<void>;

-	getToken(): Promise<string | undefined>;
-	setToken(accessToken: string | undefined): Promise<void>;
+	getToken(): Promise<IUserDataSyncAuthToken | undefined>;
+	setToken(userDataSyncAuthToken: IUserDataSyncAuthToken | undefined): Promise<void>;
 	sendTokenFailed(): void;
 }

@@ -24,24 +29,24 @@ export class AuthenticationTokenService extends Disposable implements IAuthentic

 	_serviceBrand: any;

-	private _onDidChangeToken: Emitter<string | undefined> = this._register(new Emitter<string | undefined>());
-	readonly onDidChangeToken: Event<string | undefined> = this._onDidChangeToken.event;
+	private _onDidChangeToken = this._register(new Emitter<IUserDataSyncAuthToken | undefined>());
+	readonly onDidChangeToken = this._onDidChangeToken.event;

 	private _onTokenFailed: Emitter<void> = this._register(new Emitter<void>());
 	readonly onTokenFailed: Event<void> = this._onTokenFailed.event;

-	private _token: string | undefined;
+	private _token: IUserDataSyncAuthToken | undefined;

 	constructor() {
 		super();
 	}

-	async getToken(): Promise<string | undefined> {
+	async getToken(): Promise<IUserDataSyncAuthToken | undefined> {
 		return this._token;
 	}

-	async setToken(token: string | undefined): Promise<void> {
-		if (token !== this._token) {
+	async setToken(token: IUserDataSyncAuthToken | undefined): Promise<void> {
+		if (token && this._token ? token.token !== this._token.token && token.authenticationProviderId !== this._token.authenticationProviderId : token !== this._token) {
 			this._token = token;
 			this._onDidChangeToken.fire(token);
 		}
--- a/src/vs/platform/commands/common/commands.ts
+++ b/src/vs/platform/commands/common/commands.ts
@@ -39,9 +39,14 @@ export interface ICommand {
 }

 export interface ICommandHandlerDescription {
-	description: string;
-	args: { name: string; description?: string; constraint?: TypeConstraint; schema?: IJSONSchema; }[];
-	returns?: string;
+	readonly description: string;
+	readonly args: ReadonlyArray<{
+		readonly name: string;
+		readonly description?: string;
+		readonly constraint?: TypeConstraint;
+		readonly schema?: IJSONSchema;
+	}>;
+	readonly returns?: string;
 }

 export interface ICommandRegistry {
--- a/src/vs/platform/environment/common/environment.ts
+++ b/src/vs/platform/environment/common/environment.ts
@@ -36,10 +36,15 @@ export interface IEnvironmentService {
 	argvResource: URI;
 	snippetsHome: URI;

+	// --- data paths
+	backupHome: URI;
+	untitledWorkspacesHome: URI;
+
 	// --- settings sync
 	userDataSyncLogResource: URI;
 	userDataSyncHome: URI;
-	sync: 'on' | 'off';
+	sync: 'on' | 'off' | undefined;
+	enableSyncByDefault: boolean;

 	// --- extension development
 	debugExtensionHost: IExtensionHostDebugParams;
@@ -56,20 +61,10 @@ export interface IEnvironmentService {
 	verbose: boolean;
 	isBuilt: boolean;

-	// --- data paths
-	backupHome: URI;
-	untitledWorkspacesHome: URI;
-
 	// --- misc
 	disableTelemetry: boolean;
-
 	serviceMachineIdResource: URI;

-	/**
-	 * @deprecated use IRemotePathService#userHome instead (https://github.com/microsoft/vscode/issues/94506)
-	 */
-	userHome?: URI;
-
 	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 	// NOTE: DO NOT ADD ANY OTHER PROPERTY INTO THE COLLECTION HERE
 	// UNLESS THIS PROPERTY IS SUPPORTED BOTH IN WEB AND DESKTOP!!!!
--- a/src/vs/platform/environment/node/argv.ts
+++ b/src/vs/platform/environment/node/argv.ts
@@ -96,6 +96,7 @@ export interface ParsedArgs {
 	'force-renderer-accessibility'?: boolean;
 	'ignore-certificate-errors'?: boolean;
 	'allow-insecure-localhost'?: boolean;
+	'log-net-log'?: string;
 }

 /**
@@ -218,6 +219,7 @@ export const OPTIONS: OptionDescriptions<Required<ParsedArgs>> = {
 	'force-renderer-accessibility': { type: 'boolean' },
 	'ignore-certificate-errors': { type: 'boolean' },
 	'allow-insecure-localhost': { type: 'boolean' },
+	'log-net-log': { type: 'string' },
 	'_urls': { type: 'string[]' },

 	_: { type: 'string[]' } // main arguments
--- a/src/vs/platform/environment/node/environmentService.ts
+++ b/src/vs/platform/environment/node/environmentService.ts
@@ -13,7 +13,7 @@ import * as resources from 'vs/base/common/resources';
 import { memoize } from 'vs/base/common/decorators';
 import product from 'vs/platform/product/common/product';
 import { toLocalISOString } from 'vs/base/common/date';
-import { isWindows, isLinux } from 'vs/base/common/platform';
+import { isWindows, isLinux, Platform, platform } from 'vs/base/common/platform';
 import { getPathFromAmdModule } from 'vs/base/common/amd';
 import { URI } from 'vs/base/common/uri';

@@ -92,7 +92,10 @@ export class EnvironmentService implements INativeEnvironmentService {
 	get userDataSyncLogResource(): URI { return URI.file(path.join(this.logsPath, 'userDataSync.log')); }

 	@memoize
-	get sync(): 'on' | 'off' { return this.args.sync === 'off' ? 'off' : 'on'; }
+	get sync(): 'on' | 'off' | undefined { return this.args.sync; }
+
+	@memoize
+	get enableSyncByDefault(): boolean { return false; }

 	@memoize
 	get machineSettingsResource(): URI { return resources.joinPath(URI.file(path.join(this.userDataPath, 'Machine')), 'settings.json'); }
@@ -271,15 +274,31 @@ export class EnvironmentService implements INativeEnvironmentService {
 // Related to https://github.com/Microsoft/vscode/issues/30624
 export const xdgRuntimeDir = process.env['XDG_RUNTIME_DIR'];

+const safeIpcPathLengths: { [platform: number]: number } = {
+	[Platform.Linux]: 107,
+	[Platform.Mac]: 103
+};
+
 function getNixIPCHandle(userDataPath: string, type: string): string {
 	const vscodePortable = process.env['VSCODE_PORTABLE'];

+	let result: string;
 	if (xdgRuntimeDir && !vscodePortable) {
 		const scope = crypto.createHash('md5').update(userDataPath).digest('hex').substr(0, 8);
-		return path.join(xdgRuntimeDir, `vscode-${scope}-${product.version}-${type}.sock`);
+		result = path.join(xdgRuntimeDir, `vscode-${scope}-${product.version}-${type}.sock`);
+	} else {
+		result = path.join(userDataPath, `${product.version}-${type}.sock`);
 	}

-	return path.join(userDataPath, `${product.version}-${type}.sock`);
+	const limit = safeIpcPathLengths[platform];
+	if (typeof limit === 'number') {
+		if (result.length >= limit) {
+			// https://nodejs.org/api/net.html#net_identifying_paths_for_ipc_connections
+			console.warn(`WARNING: IPC handle "${result}" is longer than ${limit} chars, try a shorter --user-data-dir`);
+		}
+	}
+
+	return result;
 }

 function getWin32IPCHandle(userDataPath: string, type: string): string {
--- a/src/vs/platform/extensionManagement/common/configRemotes.ts
+++ b/src/vs/platform/extensionManagement/common/configRemotes.ts
@@ -0,0 +1,122 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI } from 'vs/base/common/uri';
+import { endsWith } from 'vs/base/common/strings';
+
+const SshProtocolMatcher = /^([^@:]+@)?([^:]+):/;
+const SshUrlMatcher = /^([^@:]+@)?([^:]+):(.+)$/;
+const AuthorityMatcher = /^([^@]+@)?([^:]+)(:\d+)?$/;
+const SecondLevelDomainMatcher = /([^@:.]+\.[^@:.]+)(:\d+)?$/;
+const RemoteMatcher = /^\s*url\s*=\s*(.+\S)\s*$/mg;
+const AnyButDot = /[^.]/g;
+
+export const SecondLevelDomainWhitelist = [
+	'github.com',
+	'bitbucket.org',
+	'visualstudio.com',
+	'gitlab.com',
+	'heroku.com',
+	'azurewebsites.net',
+	'ibm.com',
+	'amazon.com',
+	'amazonaws.com',
+	'cloudapp.net',
+	'rhcloud.com',
+	'google.com',
+	'azure.com'
+];
+
+function stripLowLevelDomains(domain: string): string | null {
+	const match = domain.match(SecondLevelDomainMatcher);
+	return match ? match[1] : null;
+}
+
+function extractDomain(url: string): string | null {
+	if (url.indexOf('://') === -1) {
+		const match = url.match(SshProtocolMatcher);
+		if (match) {
+			return stripLowLevelDomains(match[2]);
+		} else {
+			return null;
+		}
+	}
+	try {
+		const uri = URI.parse(url);
+		if (uri.authority) {
+			return stripLowLevelDomains(uri.authority);
+		}
+	} catch (e) {
+		// ignore invalid URIs
+	}
+	return null;
+}
+
+export function getDomainsOfRemotes(text: string, whitelist: string[]): string[] {
+	const domains = new Set<string>();
+	let match: RegExpExecArray | null;
+	while (match = RemoteMatcher.exec(text)) {
+		const domain = extractDomain(match[1]);
+		if (domain) {
+			domains.add(domain);
+		}
+	}
+
+	const whitemap = whitelist.reduce((map, key) => {
+		map[key] = true;
+		return map;
+	}, Object.create(null));
+
+	const elements: string[] = [];
+	domains.forEach(e => elements.push(e));
+
+	return elements
+		.map(key => whitemap[key] ? key : key.replace(AnyButDot, 'a'));
+}
+
+function stripPort(authority: string): string | null {
+	const match = authority.match(AuthorityMatcher);
+	return match ? match[2] : null;
+}
+
+function normalizeRemote(host: string | null, path: string, stripEndingDotGit: boolean): string | null {
+	if (host && path) {
+		if (stripEndingDotGit && endsWith(path, '.git')) {
+			path = path.substr(0, path.length - 4);
+		}
+		return (path.indexOf('/') === 0) ? `${host}${path}` : `${host}/${path}`;
+	}
+	return null;
+}
+
+function extractRemote(url: string, stripEndingDotGit: boolean): string | null {
+	if (url.indexOf('://') === -1) {
+		const match = url.match(SshUrlMatcher);
+		if (match) {
+			return normalizeRemote(match[2], match[3], stripEndingDotGit);
+		}
+	}
+	try {
+		const uri = URI.parse(url);
+		if (uri.authority) {
+			return normalizeRemote(stripPort(uri.authority), uri.path, stripEndingDotGit);
+		}
+	} catch (e) {
+		// ignore invalid URIs
+	}
+	return null;
+}
+
+export function getRemotes(text: string, stripEndingDotGit: boolean = false): string[] {
+	const remotes: string[] = [];
+	let match: RegExpExecArray | null;
+	while (match = RemoteMatcher.exec(text)) {
+		const remote = extractRemote(match[1], stripEndingDotGit);
+		if (remote) {
+			remotes.push(remote);
+		}
+	}
+	return remotes;
+}
--- a/src/vs/platform/extensionManagement/common/extensionManagement.ts
+++ b/src/vs/platform/extensionManagement/common/extensionManagement.ts
@@ -226,6 +226,13 @@ export interface IGlobalExtensionEnablementService {

 }

+export type IConfigBasedExtensionTip = {
+	readonly extensionId: string,
+	readonly extensionName: string,
+	readonly isExtensionPack: boolean,
+	readonly configName: string,
+	readonly important: boolean,
+};
 export type IExecutableBasedExtensionTip = { extensionId: string } & Omit<Omit<IExeBasedExtensionTip, 'recommendations'>, 'important'>;
 export type IWorkspaceTips = { readonly remoteSet: string[]; readonly recommendations: string[]; };

@@ -233,6 +240,7 @@ export const IExtensionTipsService = createDecorator<IExtensionTipsService>('IEx
 export interface IExtensionTipsService {
 	_serviceBrand: undefined;

+	getConfigBasedTips(folder: URI): Promise<IConfigBasedExtensionTip[]>;
 	getImportantExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]>;
 	getOtherExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]>;
 	getAllWorkspacesTips(): Promise<IWorkspaceTips[]>;
--- a/src/vs/platform/extensionManagement/common/extensionManagementIpc.ts
+++ b/src/vs/platform/extensionManagement/common/extensionManagementIpc.ts
@@ -142,6 +142,7 @@ export class ExtensionTipsChannel implements IServerChannel {

 	call(context: any, command: string, args?: any): Promise<any> {
 		switch (command) {
+			case 'getConfigBasedTips': return this.service.getConfigBasedTips(URI.revive(args[0]));
 			case 'getImportantExecutableBasedTips': return this.service.getImportantExecutableBasedTips();
 			case 'getOtherExecutableBasedTips': return this.service.getOtherExecutableBasedTips();
 			case 'getAllWorkspacesTips': return this.service.getAllWorkspacesTips();
--- a/src/vs/platform/extensionManagement/common/extensionTipsService.ts
+++ b/src/vs/platform/extensionManagement/common/extensionTipsService.ts
@@ -0,0 +1,107 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI } from 'vs/base/common/uri';
+import { IProductService, IConfigBasedExtensionTip as IRawConfigBasedExtensionTip } from 'vs/platform/product/common/productService';
+import { IFileService } from 'vs/platform/files/common/files';
+import { isNonEmptyArray } from 'vs/base/common/arrays';
+import { IExtensionTipsService, IExecutableBasedExtensionTip, IWorkspaceTips, IConfigBasedExtensionTip } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { forEach } from 'vs/base/common/collections';
+import { IRequestService, asJson } from 'vs/platform/request/common/request';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { ILogService } from 'vs/platform/log/common/log';
+import { joinPath } from 'vs/base/common/resources';
+import { getDomainsOfRemotes } from 'vs/platform/extensionManagement/common/configRemotes';
+import { keys } from 'vs/base/common/map';
+
+export class ExtensionTipsService implements IExtensionTipsService {
+
+	_serviceBrand: any;
+
+	private readonly allConfigBasedTips: Map<string, IRawConfigBasedExtensionTip> = new Map<string, IRawConfigBasedExtensionTip>();
+
+	constructor(
+		@IFileService protected readonly fileService: IFileService,
+		@IProductService private readonly productService: IProductService,
+		@IRequestService private readonly requestService: IRequestService,
+		@ILogService private readonly logService: ILogService,
+	) {
+		if (this.productService.configBasedExtensionTips) {
+			forEach(this.productService.configBasedExtensionTips, ({ value }) => this.allConfigBasedTips.set(value.configPath, value));
+		}
+	}
+
+	getConfigBasedTips(folder: URI): Promise<IConfigBasedExtensionTip[]> {
+		return this.getValidConfigBasedTips(folder);
+	}
+
+	getAllWorkspacesTips(): Promise<IWorkspaceTips[]> {
+		return this.fetchWorkspacesTips();
+	}
+
+	async getImportantExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]> {
+		return [];
+	}
+
+	async getOtherExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]> {
+		return [];
+	}
+
+	private async getValidConfigBasedTips(folder: URI): Promise<IConfigBasedExtensionTip[]> {
+		const result: IConfigBasedExtensionTip[] = [];
+		for (const [configPath, tip] of this.allConfigBasedTips) {
+			try {
+				const content = await this.fileService.readFile(joinPath(folder, configPath));
+				const recommendationByRemote: Map<string, IConfigBasedExtensionTip> = new Map<string, IConfigBasedExtensionTip>();
+				forEach(tip.recommendations, ({ key, value }) => {
+					if (isNonEmptyArray(value.remotes)) {
+						for (const remote of value.remotes) {
+							recommendationByRemote.set(remote, {
+								extensionId: key,
+								extensionName: value.name,
+								configName: tip.configName,
+								important: !!value.important,
+								isExtensionPack: !!value.isExtensionPack
+							});
+						}
+					} else {
+						result.push({
+							extensionId: key,
+							extensionName: value.name,
+							configName: tip.configName,
+							important: !!value.important,
+							isExtensionPack: !!value.isExtensionPack
+						});
+					}
+				});
+				const remotes = getDomainsOfRemotes(content.value.toString(), keys(recommendationByRemote));
+				remotes.forEach(remote => result.push(recommendationByRemote.get(remote)!));
+			} catch (error) { /* Ignore */ }
+		}
+		return result;
+	}
+
+
+	private async fetchWorkspacesTips(): Promise<IWorkspaceTips[]> {
+		if (!this.productService.extensionsGallery?.recommendationsUrl) {
+			return [];
+		}
+		try {
+			const context = await this.requestService.request({ type: 'GET', url: this.productService.extensionsGallery?.recommendationsUrl }, CancellationToken.None);
+			if (context.res.statusCode !== 200) {
+				return [];
+			}
+			const result = await asJson<{ workspaceRecommendations?: IWorkspaceTips[] }>(context);
+			if (!result) {
+				return [];
+			}
+			return result.workspaceRecommendations || [];
+		} catch (error) {
+			this.logService.error(error);
+			return [];
+		}
+	}
+
+}
--- a/src/vs/platform/extensionManagement/node/extensionManagementService.ts
+++ b/src/vs/platform/extensionManagement/node/extensionManagementService.ts
@@ -771,7 +771,6 @@ export class ExtensionManagementService extends Disposable implements IExtension
 		// Scan other system extensions during development
 		const devSystemExtensionsPromise = this.getDevSystemExtensionsList()
 			.then(devSystemExtensionsList => {
-				console.log(devSystemExtensionsList);
 				if (devSystemExtensionsList.length) {
 					return this.scanExtensions(this.devSystemExtensionsPath, ExtensionType.System)
 						.then(result => {
--- a/src/vs/platform/extensionManagement/node/extensionTipsService.ts
+++ b/src/vs/platform/extensionManagement/node/extensionTipsService.ts
@@ -12,13 +12,13 @@ import { INativeEnvironmentService } from 'vs/platform/environment/node/environm
 import { IFileService } from 'vs/platform/files/common/files';
 import { isWindows } from 'vs/base/common/platform';
 import { isNonEmptyArray } from 'vs/base/common/arrays';
-import { IExtensionTipsService, IExecutableBasedExtensionTip, IWorkspaceTips } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { IExecutableBasedExtensionTip } from 'vs/platform/extensionManagement/common/extensionManagement';
 import { IStringDictionary, forEach } from 'vs/base/common/collections';
-import { IRequestService, asJson } from 'vs/platform/request/common/request';
-import { CancellationToken } from 'vs/base/common/cancellation';
+import { IRequestService } from 'vs/platform/request/common/request';
 import { ILogService } from 'vs/platform/log/common/log';
+import { ExtensionTipsService as BaseExtensionTipsService } from 'vs/platform/extensionManagement/common/extensionTipsService';

-export class ExtensionTipsService implements IExtensionTipsService {
+export class ExtensionTipsService extends BaseExtensionTipsService {

 	_serviceBrand: any;

@@ -26,14 +26,15 @@ export class ExtensionTipsService implements IExtensionTipsService {
 	private readonly allOtherExecutableTips: IStringDictionary<IExeBasedExtensionTip> = {};

 	constructor(
-		@IFileService private readonly fileService: IFileService,
-		@IEnvironmentService private readonly environmentService: IEnvironmentService,
-		@IProductService private readonly productService: IProductService,
-		@IRequestService private readonly requestService: IRequestService,
-		@ILogService private readonly logService: ILogService,
+		@IEnvironmentService private readonly environmentService: INativeEnvironmentService,
+		@IFileService fileService: IFileService,
+		@IProductService productService: IProductService,
+		@IRequestService requestService: IRequestService,
+		@ILogService logService: ILogService,
 	) {
-		if (this.productService.exeBasedExtensionTips) {
-			forEach(this.productService.exeBasedExtensionTips, ({ key, value }) => {
+		super(fileService, productService, requestService, logService);
+		if (productService.exeBasedExtensionTips) {
+			forEach(productService.exeBasedExtensionTips, ({ key, value }) => {
 				if (value.important) {
 					this.allImportantExecutableTips[key] = value;
 				} else {
@@ -43,10 +44,6 @@ export class ExtensionTipsService implements IExtensionTipsService {
 		}
 	}

-	getAllWorkspacesTips(): Promise<IWorkspaceTips[]> {
-		return this.fetchWorkspacesTips();
-	}
-
 	getImportantExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]> {
 		return this.getValidExecutableBasedExtensionTips(this.allImportantExecutableTips);
 	}
@@ -76,7 +73,7 @@ export class ExtensionTipsService implements IExtensionTipsService {
 				}
 			} else {
 				exePaths.push(join('/usr/local/bin', exeName));
-				exePaths.push(join((this.environmentService as INativeEnvironmentService).userHome.fsPath, exeName));
+				exePaths.push(join(this.environmentService.userHome.fsPath, exeName));
 			}

 			for (const exePath of exePaths) {
@@ -99,24 +96,4 @@ export class ExtensionTipsService implements IExtensionTipsService {
 		return result;
 	}

-	private async fetchWorkspacesTips(): Promise<IWorkspaceTips[]> {
-		if (!this.productService.extensionsGallery?.recommendationsUrl) {
-			return [];
-		}
-		try {
-			const context = await this.requestService.request({ type: 'GET', url: this.productService.extensionsGallery?.recommendationsUrl }, CancellationToken.None);
-			if (context.res.statusCode !== 200) {
-				return [];
-			}
-			const result = await asJson<{ workspaceRecommendations?: IWorkspaceTips[] }>(context);
-			if (!result) {
-				return [];
-			}
-			return result.workspaceRecommendations || [];
-		} catch (error) {
-			this.logService.error(error);
-			return [];
-		}
-	}
-
 }
--- a/src/vs/platform/extensionManagement/test/common/configRemotes.test.ts
+++ b/src/vs/platform/extensionManagement/test/common/configRemotes.test.ts
@@ -0,0 +1,130 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { getDomainsOfRemotes, getRemotes } from 'vs/platform/extensionManagement/common/configRemotes';
+
+suite('Config Remotes', () => {
+
+	const whitelist = [
+		'github.com',
+		'github2.com',
+		'github3.com',
+		'example.com',
+		'example2.com',
+		'example3.com',
+		'server.org',
+		'server2.org',
+	];
+
+	test('HTTPS remotes', function () {
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('https://github.com/Microsoft/vscode.git'), whitelist), ['github.com']);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('https://git.example.com/gitproject.git'), whitelist), ['example.com']);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('https://username@github2.com/username/repository.git'), whitelist), ['github2.com']);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('https://username:password@github3.com/username/repository.git'), whitelist), ['github3.com']);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('https://username:password@example2.com:1234/username/repository.git'), whitelist), ['example2.com']);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('https://example3.com:1234/username/repository.git'), whitelist), ['example3.com']);
+	});
+
+	test('SSH remotes', function () {
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('ssh://user@git.server.org/project.git'), whitelist), ['server.org']);
+	});
+
+	test('SCP-like remotes', function () {
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('git@github.com:Microsoft/vscode.git'), whitelist), ['github.com']);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('user@git.server.org:project.git'), whitelist), ['server.org']);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('git.server2.org:project.git'), whitelist), ['server2.org']);
+	});
+
+	test('Local remotes', function () {
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('/opt/git/project.git'), whitelist), []);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('file:///opt/git/project.git'), whitelist), []);
+	});
+
+	test('Multiple remotes', function () {
+		const config = ['https://github.com/Microsoft/vscode.git', 'https://git.example.com/gitproject.git'].map(remote).join('');
+		assert.deepStrictEqual(getDomainsOfRemotes(config, whitelist).sort(), ['example.com', 'github.com']);
+	});
+
+	test('Whitelisting', () => {
+		const config = ['https://github.com/Microsoft/vscode.git', 'https://git.foobar.com/gitproject.git'].map(remote).join('');
+		assert.deepStrictEqual(getDomainsOfRemotes(config, whitelist).sort(), ['aaaaaa.aaa', 'github.com']);
+	});
+
+	test('HTTPS remotes to be hashed', function () {
+		assert.deepStrictEqual(getRemotes(remote('https://github.com/Microsoft/vscode.git')), ['github.com/Microsoft/vscode.git']);
+		assert.deepStrictEqual(getRemotes(remote('https://git.example.com/gitproject.git')), ['git.example.com/gitproject.git']);
+		assert.deepStrictEqual(getRemotes(remote('https://username@github2.com/username/repository.git')), ['github2.com/username/repository.git']);
+		assert.deepStrictEqual(getRemotes(remote('https://username:password@github3.com/username/repository.git')), ['github3.com/username/repository.git']);
+		assert.deepStrictEqual(getRemotes(remote('https://username:password@example2.com:1234/username/repository.git')), ['example2.com/username/repository.git']);
+		assert.deepStrictEqual(getRemotes(remote('https://example3.com:1234/username/repository.git')), ['example3.com/username/repository.git']);
+
+		// Strip .git
+		assert.deepStrictEqual(getRemotes(remote('https://github.com/Microsoft/vscode.git'), true), ['github.com/Microsoft/vscode']);
+		assert.deepStrictEqual(getRemotes(remote('https://git.example.com/gitproject.git'), true), ['git.example.com/gitproject']);
+		assert.deepStrictEqual(getRemotes(remote('https://username@github2.com/username/repository.git'), true), ['github2.com/username/repository']);
+		assert.deepStrictEqual(getRemotes(remote('https://username:password@github3.com/username/repository.git'), true), ['github3.com/username/repository']);
+		assert.deepStrictEqual(getRemotes(remote('https://username:password@example2.com:1234/username/repository.git'), true), ['example2.com/username/repository']);
+		assert.deepStrictEqual(getRemotes(remote('https://example3.com:1234/username/repository.git'), true), ['example3.com/username/repository']);
+
+		// Compare Striped .git with no .git
+		assert.deepStrictEqual(getRemotes(remote('https://github.com/Microsoft/vscode.git'), true), getRemotes(remote('https://github.com/Microsoft/vscode')));
+		assert.deepStrictEqual(getRemotes(remote('https://git.example.com/gitproject.git'), true), getRemotes(remote('https://git.example.com/gitproject')));
+		assert.deepStrictEqual(getRemotes(remote('https://username@github2.com/username/repository.git'), true), getRemotes(remote('https://username@github2.com/username/repository')));
+		assert.deepStrictEqual(getRemotes(remote('https://username:password@github3.com/username/repository.git'), true), getRemotes(remote('https://username:password@github3.com/username/repository')));
+		assert.deepStrictEqual(getRemotes(remote('https://username:password@example2.com:1234/username/repository.git'), true), getRemotes(remote('https://username:password@example2.com:1234/username/repository')));
+		assert.deepStrictEqual(getRemotes(remote('https://example3.com:1234/username/repository.git'), true), getRemotes(remote('https://example3.com:1234/username/repository')));
+	});
+
+	test('SSH remotes to be hashed', function () {
+		assert.deepStrictEqual(getRemotes(remote('ssh://user@git.server.org/project.git')), ['git.server.org/project.git']);
+
+		// Strip .git
+		assert.deepStrictEqual(getRemotes(remote('ssh://user@git.server.org/project.git'), true), ['git.server.org/project']);
+
+		// Compare Striped .git with no .git
+		assert.deepStrictEqual(getRemotes(remote('ssh://user@git.server.org/project.git'), true), getRemotes(remote('ssh://user@git.server.org/project')));
+	});
+
+	test('SCP-like remotes to be hashed', function () {
+		assert.deepStrictEqual(getRemotes(remote('git@github.com:Microsoft/vscode.git')), ['github.com/Microsoft/vscode.git']);
+		assert.deepStrictEqual(getRemotes(remote('user@git.server.org:project.git')), ['git.server.org/project.git']);
+		assert.deepStrictEqual(getRemotes(remote('git.server2.org:project.git')), ['git.server2.org/project.git']);
+
+		// Strip .git
+		assert.deepStrictEqual(getRemotes(remote('git@github.com:Microsoft/vscode.git'), true), ['github.com/Microsoft/vscode']);
+		assert.deepStrictEqual(getRemotes(remote('user@git.server.org:project.git'), true), ['git.server.org/project']);
+		assert.deepStrictEqual(getRemotes(remote('git.server2.org:project.git'), true), ['git.server2.org/project']);
+
+		// Compare Striped .git with no .git
+		assert.deepStrictEqual(getRemotes(remote('git@github.com:Microsoft/vscode.git'), true), getRemotes(remote('git@github.com:Microsoft/vscode')));
+		assert.deepStrictEqual(getRemotes(remote('user@git.server.org:project.git'), true), getRemotes(remote('user@git.server.org:project')));
+		assert.deepStrictEqual(getRemotes(remote('git.server2.org:project.git'), true), getRemotes(remote('git.server2.org:project')));
+	});
+
+	test('Local remotes to be hashed', function () {
+		assert.deepStrictEqual(getRemotes(remote('/opt/git/project.git')), []);
+		assert.deepStrictEqual(getRemotes(remote('file:///opt/git/project.git')), []);
+	});
+
+	test('Multiple remotes to be hashed', function () {
+		const config = ['https://github.com/Microsoft/vscode.git', 'https://git.example.com/gitproject.git'].map(remote).join(' ');
+		assert.deepStrictEqual(getRemotes(config), ['github.com/Microsoft/vscode.git', 'git.example.com/gitproject.git']);
+
+		// Strip .git
+		assert.deepStrictEqual(getRemotes(config, true), ['github.com/Microsoft/vscode', 'git.example.com/gitproject']);
+
+		// Compare Striped .git with no .git
+		const noDotGitConfig = ['https://github.com/Microsoft/vscode', 'https://git.example.com/gitproject'].map(remote).join(' ');
+		assert.deepStrictEqual(getRemotes(config, true), getRemotes(noDotGitConfig));
+	});
+
+	function remote(url: string): string {
+		return `[remote "origin"]
+	url = ${url}
+	fetch = +refs/heads/*:refs/remotes/origin/*
+`;
+	}
+});
--- a/src/vs/platform/files/common/fileService.ts
+++ b/src/vs/platform/files/common/fileService.ts
@@ -182,21 +182,21 @@ export class FileService extends Disposable implements IFileService {

 		const stat = await provider.stat(resource);

-		let trie: TernarySearchTree<string, boolean> | undefined;
+		let trie: TernarySearchTree<URI, boolean> | undefined;

 		return this.toFileStat(provider, resource, stat, undefined, !!resolveMetadata, (stat, siblings) => {

 			// lazy trie to check for recursive resolving
 			if (!trie) {
-				trie = TernarySearchTree.forPaths<true>();
-				trie.set(resource.toString(), true);
+				trie = TernarySearchTree.forUris<true>();
+				trie.set(resource, true);
 				if (isNonEmptyArray(resolveTo)) {
-					resolveTo.forEach(uri => trie!.set(uri.toString(), true));
+					resolveTo.forEach(uri => trie!.set(uri, true));
 				}
 			}

 			// check for recursive resolving
-			if (Boolean(trie.findSuperstr(stat.resource.toString()) || trie.get(stat.resource.toString()))) {
+			if (Boolean(trie.findSuperstr(stat.resource) || trie.get(stat.resource))) {
 				return true;
 			}

--- a/src/vs/platform/files/test/electron-browser/diskFileService.test.ts
+++ b/src/vs/platform/files/test/electron-browser/diskFileService.test.ts
@@ -416,11 +416,7 @@ suite('Disk File Service', function () {
 		assert.equal(r2.name, 'deep');
 	});

-	test('resolve - folder symbolic link', async () => {
-		if (isWindows) {
-			return; // not reliable on windows
-		}
-
+	(isWindows /* not reliable on windows */ ? test.skip : test)('resolve - folder symbolic link', async () => {
 		const link = URI.file(join(testDir, 'deep-link'));
 		await symlink(join(testDir, 'deep'), link.fsPath);

@@ -430,11 +426,7 @@ suite('Disk File Service', function () {
 		assert.equal(resolved.isSymbolicLink, true);
 	});

-	test('resolve - file symbolic link', async () => {
-		if (isWindows) {
-			return; // not reliable on windows
-		}
-
+	(isWindows /* not reliable on windows */ ? test.skip : test)('resolve - file symbolic link', async () => {
 		const link = URI.file(join(testDir, 'lorem.txt-linked'));
 		await symlink(join(testDir, 'lorem.txt'), link.fsPath);

@@ -443,11 +435,7 @@ suite('Disk File Service', function () {
 		assert.equal(resolved.isSymbolicLink, true);
 	});

-	test('resolve - symbolic link pointing to non-existing file does not break', async () => {
-		if (isWindows) {
-			return; // not reliable on windows
-		}
-
+	(isWindows /* not reliable on windows */ ? test.skip : test)('resolve - symbolic link pointing to non-existing file does not break', async () => {
 		await symlink(join(testDir, 'foo'), join(testDir, 'bar'));

 		const resolved = await service.resolve(URI.file(testDir));
@@ -495,11 +483,7 @@ suite('Disk File Service', function () {
 		assert.equal((<FileOperationError>error).fileOperationResult, FileOperationResult.FILE_NOT_FOUND);
 	}

-	test('deleteFile - symbolic link (exists)', async () => {
-		if (isWindows) {
-			return; // not reliable on windows
-		}
-
+	(isWindows /* not reliable on windows */ ? test.skip : test)('deleteFile - symbolic link (exists)', async () => {
 		const target = URI.file(join(testDir, 'lorem.txt'));
 		const link = URI.file(join(testDir, 'lorem.txt-linked'));
 		await symlink(target.fsPath, link.fsPath);
@@ -520,11 +504,7 @@ suite('Disk File Service', function () {
 		assert.equal(existsSync(target.fsPath), true); // target the link pointed to is never deleted
 	});

-	test('deleteFile - symbolic link (pointing to non-existing file)', async () => {
-		if (isWindows) {
-			return; // not reliable on windows
-		}
-
+	(isWindows /* not reliable on windows */ ? test.skip : test)('deleteFile - symbolic link (pointing to non-existing file)', async () => {
 		const target = URI.file(join(testDir, 'foo'));
 		const link = URI.file(join(testDir, 'bar'));
 		await symlink(target.fsPath, link.fsPath);
@@ -1409,11 +1389,7 @@ suite('Disk File Service', function () {
 		assert.equal(error!.fileOperationResult, FileOperationResult.FILE_IS_DIRECTORY);
 	});

-	test('readFile - FILE_NOT_DIRECTORY', async () => {
-		if (isWindows) {
-			return; // error code does not seem to be supported on windows
-		}
-
+	(isWindows /* error code does not seem to be supported on windows */ ? test.skip : test)('readFile - FILE_NOT_DIRECTORY', async () => {
 		const resource = URI.file(join(testDir, 'lorem.txt', 'file.txt'));

 		let error: FileOperationError | undefined = undefined;
@@ -1525,10 +1501,10 @@ suite('Disk File Service', function () {

 		// Also test when the stat size is wrong
 		fileProvider.setSmallStatSize(true);
-		return doTestFileExceedsMemoryLimit(false);
+		return doTestFileExceedsMemoryLimit();
 	}

-	async function doTestFileExceedsMemoryLimit(testTotalBytesRead = true) {
+	async function doTestFileExceedsMemoryLimit() {
 		const resource = URI.file(join(testDir, 'index.html'));

 		let error: FileOperationError | undefined = undefined;
@@ -1540,10 +1516,6 @@ suite('Disk File Service', function () {

 		assert.ok(error);
 		assert.equal(error!.fileOperationResult, FileOperationResult.FILE_EXCEEDS_MEMORY_LIMIT);
-
-		if (testTotalBytesRead) {
-			assert.equal(fileProvider.totalBytesRead, 0);
-		}
 	}

 	test('readFile - FILE_TOO_LARGE - default', async () => {
@@ -1569,7 +1541,7 @@ suite('Disk File Service', function () {
 	});

 	async function testFileTooLarge() {
-		await doTestFileExceedsMemoryLimit();
+		await doTestFileTooLarge();

 		// Also test when the stat size is wrong
 		fileProvider.setSmallStatSize(true);
--- a/src/vs/platform/list/browser/listService.ts
+++ b/src/vs/platform/list/browser/listService.ts
@@ -5,8 +5,8 @@

 import { createStyleSheet } from 'vs/base/browser/dom';
 import { IListMouseEvent, IListTouchEvent, IListRenderer, IListVirtualDelegate } from 'vs/base/browser/ui/list/list';
-import { IPagedRenderer, PagedList } from 'vs/base/browser/ui/list/listPaging';
-import { DefaultStyleController, IListOptions, IMultipleSelectionController, IOpenController, isSelectionRangeChangeEvent, isSelectionSingleChangeEvent, List } from 'vs/base/browser/ui/list/listWidget';
+import { IPagedRenderer, PagedList, IPagedListOptions } from 'vs/base/browser/ui/list/listPaging';
+import { DefaultStyleController, IListOptions, IMultipleSelectionController, IOpenController, isSelectionRangeChangeEvent, isSelectionSingleChangeEvent, List, IListAccessibilityProvider, IListOptionsUpdate } from 'vs/base/browser/ui/list/listWidget';
 import { Emitter, Event } from 'vs/base/common/event';
 import { Disposable, dispose, IDisposable, toDisposable, DisposableStore, combinedDisposable } from 'vs/base/common/lifecycle';
 import { ScrollbarVisibility } from 'vs/base/common/scrollable';
@@ -25,11 +25,11 @@ import { Registry } from 'vs/platform/registry/common/platform';
 import { attachListStyler, computeStyles, defaultListStyles, IColorMapping } from 'vs/platform/theme/common/styler';
 import { IThemeService } from 'vs/platform/theme/common/themeService';
 import { InputFocusedContextKey } from 'vs/platform/contextkey/common/contextkeys';
-import { ObjectTree, IObjectTreeOptions, ICompressibleTreeRenderer, CompressibleObjectTree, ICompressibleObjectTreeOptions } from 'vs/base/browser/ui/tree/objectTree';
+import { ObjectTree, IObjectTreeOptions, ICompressibleTreeRenderer, CompressibleObjectTree, ICompressibleObjectTreeOptions, ICompressibleObjectTreeOptionsUpdate } from 'vs/base/browser/ui/tree/objectTree';
 import { ITreeRenderer, IAsyncDataSource, IDataSource } from 'vs/base/browser/ui/tree/tree';
-import { AsyncDataTree, IAsyncDataTreeOptions, CompressibleAsyncDataTree, ITreeCompressionDelegate, ICompressibleAsyncDataTreeOptions } from 'vs/base/browser/ui/tree/asyncDataTree';
+import { AsyncDataTree, IAsyncDataTreeOptions, CompressibleAsyncDataTree, ITreeCompressionDelegate, ICompressibleAsyncDataTreeOptions, IAsyncDataTreeOptionsUpdate } from 'vs/base/browser/ui/tree/asyncDataTree';
 import { DataTree, IDataTreeOptions } from 'vs/base/browser/ui/tree/dataTree';
-import { IKeyboardNavigationEventFilter, IAbstractTreeOptions, RenderIndentGuides } from 'vs/base/browser/ui/tree/abstractTree';
+import { IKeyboardNavigationEventFilter, IAbstractTreeOptions, RenderIndentGuides, IAbstractTreeOptionsUpdate } from 'vs/base/browser/ui/tree/abstractTree';
 import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility';

 export type ListWidget = List<any> | PagedList<any> | ITree | ObjectTree<any, any> | DataTree<any, any, any> | AsyncDataTree<any, any, any>;
@@ -235,10 +235,14 @@ function toWorkbenchListOptions<T>(options: IListOptions<T>, configurationServic
 	return [result, disposables];
 }

-export interface IWorkbenchListOptions<T> extends IListOptions<T> {
+export interface IWorkbenchListOptionsUpdate extends IListOptionsUpdate {
 	readonly overrideStyles?: IColorMapping;
 }

+export interface IWorkbenchListOptions<T> extends IWorkbenchListOptionsUpdate, IListOptions<T> {
+	readonly accessibilityProvider: IListAccessibilityProvider<T>;
+}
+
 export class WorkbenchList<T> extends List<T> {

 	readonly contextKeyService: IContextKeyService;
@@ -316,7 +320,7 @@ export class WorkbenchList<T> extends List<T> {
 		this.registerListeners();
 	}

-	updateOptions(options: IWorkbenchListOptions<T>): void {
+	updateOptions(options: IWorkbenchListOptionsUpdate): void {
 		super.updateOptions(options);

 		if (options.overrideStyles) {
@@ -352,6 +356,10 @@ export class WorkbenchList<T> extends List<T> {
 	}
 }

+export interface IWorkbenchPagedListOptions<T> extends IWorkbenchListOptionsUpdate, IPagedListOptions<T> {
+	readonly accessibilityProvider: IListAccessibilityProvider<T>;
+}
+
 export class WorkbenchPagedList<T> extends PagedList<T> {

 	readonly contextKeyService: IContextKeyService;
@@ -366,7 +374,7 @@ export class WorkbenchPagedList<T> extends PagedList<T> {
 		container: HTMLElement,
 		delegate: IListVirtualDelegate<number>,
 		renderers: IPagedRenderer<T, any>[],
-		options: IWorkbenchListOptions<T>,
+		options: IWorkbenchPagedListOptions<T>,
 		@IContextKeyService contextKeyService: IContextKeyService,
 		@IListService listService: IListService,
 		@IThemeService themeService: IThemeService,
@@ -635,29 +643,7 @@ export function getSelectionKeyboardEvent(typeArg = 'keydown', preserveFocus?: b
 	return e;
 }

-export abstract class ResourceNavigator<T> extends Disposable {
-
-	static createListResourceNavigator<T>(list: WorkbenchList<T> | WorkbenchPagedList<T>, options?: IResourceNavigatorOptions): ResourceNavigator<number> {
-		return new class extends ResourceNavigator<number> {
-			constructor() {
-				super(list, options);
-			}
-		}();
-	}
-
-	static createTreeResourceNavigator<T, TFilterData>(tree: WorkbenchObjectTree<T, TFilterData> | WorkbenchCompressibleObjectTree<T, TFilterData> | WorkbenchDataTree<any, T, TFilterData> | WorkbenchAsyncDataTree<any, T, TFilterData> | WorkbenchCompressibleAsyncDataTree<any, T, TFilterData>,
-		options?: IResourceNavigatorOptions): ResourceNavigator<T> {
-		return new class extends ResourceNavigator<T> {
-			constructor() {
-				super(tree, {
-					...{
-						openOnSingleClick: tree.openOnSingleClick
-					},
-					...(options || {})
-				});
-			}
-		}();
-	}
+abstract class ResourceNavigator<T> extends Disposable {

 	private readonly options: IResourceNavigatorOptions;

@@ -677,12 +663,7 @@ export abstract class ResourceNavigator<T> extends Disposable {
 	) {
 		super();

-		this.options = {
-			...{
-				openOnSelection: true
-			},
-			...(options || {})
-		};
+		this.options = { openOnSelection: true, ...(options || {}) };

 		this.registerListeners();
 	}
@@ -750,6 +731,18 @@ export abstract class ResourceNavigator<T> extends Disposable {
 	}
 }

+export class ListResourceNavigator<T> extends ResourceNavigator<number> {
+	constructor(list: WorkbenchList<T> | WorkbenchPagedList<T>, options?: IResourceNavigatorOptions) {
+		super(list, options);
+	}
+}
+
+export class TreeResourceNavigator<T, TFilterData> extends ResourceNavigator<T> {
+	constructor(tree: WorkbenchObjectTree<T, TFilterData> | WorkbenchCompressibleObjectTree<T, TFilterData> | WorkbenchDataTree<any, T, TFilterData> | WorkbenchAsyncDataTree<any, T, TFilterData> | WorkbenchCompressibleAsyncDataTree<any, T, TFilterData>, options?: IResourceNavigatorOptions) {
+		super(tree, { openOnSingleClick: tree.openOnSingleClick, ...(options || {}) });
+	}
+}
+
 function createKeyboardNavigationEventFilter(container: HTMLElement, keybindingService: IKeybindingService): IKeyboardNavigationEventFilter {
 	let inChord = false;

@@ -772,6 +765,7 @@ function createKeyboardNavigationEventFilter(container: HTMLElement, keybindingS
 }

 export interface IWorkbenchObjectTreeOptions<T, TFilterData> extends IObjectTreeOptions<T, TFilterData> {
+	readonly accessibilityProvider: IListAccessibilityProvider<T>;
 	readonly overrideStyles?: IColorMapping;
 }

@@ -802,10 +796,14 @@ export class WorkbenchObjectTree<T extends NonNullable<any>, TFilterData = void>
 	}
 }

-export interface IWorkbenchCompressibleObjectTreeOptions<T, TFilterData> extends ICompressibleObjectTreeOptions<T, TFilterData> {
+export interface IWorkbenchCompressibleObjectTreeOptionsUpdate extends ICompressibleObjectTreeOptionsUpdate {
 	readonly overrideStyles?: IColorMapping;
 }

+export interface IWorkbenchCompressibleObjectTreeOptions<T, TFilterData> extends IWorkbenchCompressibleObjectTreeOptionsUpdate, ICompressibleObjectTreeOptions<T, TFilterData> {
+	readonly accessibilityProvider: IListAccessibilityProvider<T>;
+}
+
 export class WorkbenchCompressibleObjectTree<T extends NonNullable<any>, TFilterData = void> extends CompressibleObjectTree<T, TFilterData> {

 	private internals: WorkbenchTreeInternals<any, T, TFilterData>;
@@ -832,7 +830,7 @@ export class WorkbenchCompressibleObjectTree<T extends NonNullable<any>, TFilter
 		this.disposables.add(this.internals);
 	}

-	updateOptions(options: IWorkbenchAsyncDataTreeOptions<T, TFilterData> = {}): void {
+	updateOptions(options: IWorkbenchCompressibleObjectTreeOptionsUpdate = {}): void {
 		super.updateOptions(options);

 		if (options.overrideStyles) {
@@ -841,10 +839,14 @@ export class WorkbenchCompressibleObjectTree<T extends NonNullable<any>, TFilter
 	}
 }

-export interface IWorkbenchDataTreeOptions<T, TFilterData> extends IDataTreeOptions<T, TFilterData> {
+export interface IWorkbenchDataTreeOptionsUpdate extends IAbstractTreeOptionsUpdate {
 	readonly overrideStyles?: IColorMapping;
 }

+export interface IWorkbenchDataTreeOptions<T, TFilterData> extends IWorkbenchDataTreeOptionsUpdate, IDataTreeOptions<T, TFilterData> {
+	readonly accessibilityProvider: IListAccessibilityProvider<T>;
+}
+
 export class WorkbenchDataTree<TInput, T, TFilterData = void> extends DataTree<TInput, T, TFilterData> {

 	private internals: WorkbenchTreeInternals<TInput, T, TFilterData>;
@@ -872,7 +874,7 @@ export class WorkbenchDataTree<TInput, T, TFilterData = void> extends DataTree<T
 		this.disposables.add(this.internals);
 	}

-	updateOptions(options: IWorkbenchAsyncDataTreeOptions<T, TFilterData> = {}): void {
+	updateOptions(options: IWorkbenchDataTreeOptionsUpdate = {}): void {
 		super.updateOptions(options);

 		if (options.overrideStyles) {
@@ -881,10 +883,14 @@ export class WorkbenchDataTree<TInput, T, TFilterData = void> extends DataTree<T
 	}
 }

-export interface IWorkbenchAsyncDataTreeOptions<T, TFilterData> extends IAsyncDataTreeOptions<T, TFilterData> {
+export interface IWorkbenchAsyncDataTreeOptionsUpdate extends IAsyncDataTreeOptionsUpdate {
 	readonly overrideStyles?: IColorMapping;
 }

+export interface IWorkbenchAsyncDataTreeOptions<T, TFilterData> extends IWorkbenchAsyncDataTreeOptionsUpdate, IAsyncDataTreeOptions<T, TFilterData> {
+	readonly accessibilityProvider: IListAccessibilityProvider<T>;
+}
+
 export class WorkbenchAsyncDataTree<TInput, T, TFilterData = void> extends AsyncDataTree<TInput, T, TFilterData> {

 	private internals: WorkbenchTreeInternals<TInput, T, TFilterData>;
@@ -912,7 +918,7 @@ export class WorkbenchAsyncDataTree<TInput, T, TFilterData = void> extends Async
 		this.disposables.add(this.internals);
 	}

-	updateOptions(options: IWorkbenchAsyncDataTreeOptions<T, TFilterData> = {}): void {
+	updateOptions(options: IWorkbenchAsyncDataTreeOptionsUpdate = {}): void {
 		super.updateOptions(options);

 		if (options.overrideStyles) {
@@ -922,6 +928,7 @@ export class WorkbenchAsyncDataTree<TInput, T, TFilterData = void> extends Async
 }

 export interface IWorkbenchCompressibleAsyncDataTreeOptions<T, TFilterData> extends ICompressibleAsyncDataTreeOptions<T, TFilterData> {
+	readonly accessibilityProvider: IListAccessibilityProvider<T>;
 	readonly overrideStyles?: IColorMapping;
 }

--- a/src/vs/platform/product/common/productService.ts
+++ b/src/vs/platform/product/common/productService.ts
@@ -5,6 +5,7 @@

 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { ExtensionKind } from 'vs/platform/extensions/common/extensions';
+import { IStringDictionary } from 'vs/base/common/collections';

 export const IProductService = createDecorator<IProductService>('productService');

@@ -21,6 +22,8 @@ export interface IBuiltInExtension {
 	readonly metadata: any;
 }

+export type ConfigurationSyncStore = { url: string, authenticationProviders: IStringDictionary<{ scopes: string[] }> };
+
 export interface IProductConfiguration {
 	readonly version: string;
 	readonly date?: string;
@@ -57,6 +60,7 @@ export interface IProductConfiguration {

 	readonly extensionTips?: { [id: string]: string; };
 	readonly extensionImportantTips?: { [id: string]: { name: string; pattern: string; isExtensionPack?: boolean }; };
+	readonly configBasedExtensionTips?: { [id: string]: IConfigBasedExtensionTip; };
 	readonly exeBasedExtensionTips?: { [id: string]: IExeBasedExtensionTip; };
 	readonly remoteExtensionTips?: { [remoteName: string]: IRemoteExtensionTip; };
 	readonly extensionKeywords?: { [extension: string]: readonly string[]; };
@@ -119,7 +123,13 @@ export interface IProductConfiguration {
 	readonly msftInternalDomains?: string[];
 	readonly linkProtectionTrustedDomains?: readonly string[];

-	readonly 'configurationSync.store'?: { url: string, authenticationProviderId: string };
+	readonly 'configurationSync.store'?: ConfigurationSyncStore;
+}
+
+export interface IConfigBasedExtensionTip {
+	configPath: string;
+	configName: string;
+	recommendations: IStringDictionary<{ name: string, remotes?: string[], important?: boolean, isExtensionPack?: boolean }>;
 }

 export interface IExeBasedExtensionTip {
--- a/src/vs/platform/quickinput/browser/quickInput.ts
+++ b/src/vs/platform/quickinput/browser/quickInput.ts
@@ -13,8 +13,8 @@ import { computeStyles } from 'vs/platform/theme/common/styler';
 import { IContextKeyService, RawContextKey, IContextKey } from 'vs/platform/contextkey/common/contextkey';
 import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility';
 import { QuickInputController, IQuickInputStyles, IQuickInputOptions } from 'vs/base/parts/quickinput/browser/quickInput';
-import { WorkbenchList } from 'vs/platform/list/browser/listService';
-import { List, IListOptions } from 'vs/base/browser/ui/list/listWidget';
+import { WorkbenchList, IWorkbenchListOptions } from 'vs/platform/list/browser/listService';
+import { List } from 'vs/base/browser/ui/list/listWidget';
 import { IListVirtualDelegate, IListRenderer } from 'vs/base/browser/ui/list/list';
 import { IQuickAccessController } from 'vs/platform/quickinput/common/quickAccess';
 import { QuickAccessController } from 'vs/platform/quickinput/browser/quickAccess';
@@ -74,7 +74,7 @@ export class QuickInputService extends Themable implements IQuickInputService {
 				container: HTMLElement,
 				delegate: IListVirtualDelegate<T>,
 				renderers: IListRenderer<T, any>[],
-				options: IListOptions<T>,
+				options: IWorkbenchListOptions<T>,
 			) => this.instantiationService.createInstance(WorkbenchList, user, container, delegate, renderers, options) as List<T>,
 			styles: this.computeStyles()
 		};
@@ -126,11 +126,11 @@ export class QuickInputService extends Themable implements IQuickInputService {
 		});
 	}

-	pick<T extends IQuickPickItem, O extends IPickOptions<T>>(picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[], options: O = <O>{}, token: CancellationToken = CancellationToken.None): Promise<O extends { canPickMany: true } ? T[] : T> {
+	pick<T extends IQuickPickItem, O extends IPickOptions<T>>(picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[], options: O = <O>{}, token: CancellationToken = CancellationToken.None): Promise<(O extends { canPickMany: true } ? T[] : T) | undefined> {
 		return this.controller.pick(picks, options, token);
 	}

-	input(options: IInputOptions = {}, token: CancellationToken = CancellationToken.None): Promise<string> {
+	input(options: IInputOptions = {}, token: CancellationToken = CancellationToken.None): Promise<string | undefined> {
 		return this.controller.input(options, token);
 	}

--- a/src/vs/platform/quickinput/common/quickInput.ts
+++ b/src/vs/platform/quickinput/common/quickInput.ts
@@ -43,14 +43,14 @@ export interface IQuickInputService {
 	 * Opens the quick input box for selecting items and returns a promise
 	 * with the user selected item(s) if any.
 	 */
-	pick<T extends IQuickPickItem>(picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[], options?: IPickOptions<T> & { canPickMany: true }, token?: CancellationToken): Promise<T[]>;
-	pick<T extends IQuickPickItem>(picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[], options?: IPickOptions<T> & { canPickMany: false }, token?: CancellationToken): Promise<T>;
-	pick<T extends IQuickPickItem>(picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[], options?: Omit<IPickOptions<T>, 'canPickMany'>, token?: CancellationToken): Promise<T>;
+	pick<T extends IQuickPickItem>(picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[], options?: IPickOptions<T> & { canPickMany: true }, token?: CancellationToken): Promise<T[] | undefined>;
+	pick<T extends IQuickPickItem>(picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[], options?: IPickOptions<T> & { canPickMany: false }, token?: CancellationToken): Promise<T | undefined>;
+	pick<T extends IQuickPickItem>(picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[], options?: Omit<IPickOptions<T>, 'canPickMany'>, token?: CancellationToken): Promise<T | undefined>;

 	/**
 	 * Opens the quick input box for text input and returns a promise with the user typed value if any.
 	 */
-	input(options?: IInputOptions, token?: CancellationToken): Promise<string>;
+	input(options?: IInputOptions, token?: CancellationToken): Promise<string | undefined>;

 	/**
 	 * Provides raw access to the quick pick controller.
--- a/src/vs/platform/request/common/request.ts
+++ b/src/vs/platform/request/common/request.ts
@@ -48,7 +48,13 @@ export async function asJson<T = {}>(context: IRequestContext): Promise<T | null
 		return null;
 	}
 	const buffer = await streamToBuffer(context.stream);
-	return JSON.parse(buffer.toString());
+	const str = buffer.toString();
+	try {
+		return JSON.parse(str);
+	} catch (err) {
+		err.message += ':\n' + str;
+		throw err;
+	}
 }


--- a/src/vs/platform/severityIcon/common/severityIcon.ts
+++ b/src/vs/platform/severityIcon/common/severityIcon.ts
@@ -6,19 +6,20 @@
 import Severity from 'vs/base/common/severity';
 import { registerThemingParticipant } from 'vs/platform/theme/common/themeService';
 import { problemsErrorIconForeground, problemsInfoIconForeground, problemsWarningIconForeground } from 'vs/platform/theme/common/colorRegistry';
+import { Codicon } from 'vs/base/common/codicons';

 export namespace SeverityIcon {

 	export function className(severity: Severity): string {
 		switch (severity) {
 			case Severity.Ignore:
-				return 'severity-ignore codicon-info';
+				return 'severity-ignore ' + Codicon.info.classNames;
 			case Severity.Info:
-				return 'codicon-info';
+				return Codicon.info.classNames;
 			case Severity.Warning:
-				return 'codicon-warning';
+				return Codicon.warning.classNames;
 			case Severity.Error:
-				return 'codicon-error';
+				return Codicon.error.classNames;
 		}
 		return '';
 	}
@@ -28,37 +29,37 @@ registerThemingParticipant((theme, collector) => {

 	const errorIconForeground = theme.getColor(problemsErrorIconForeground);
 	if (errorIconForeground) {
+		const errorCodiconSelector = Codicon.error.cssSelector;
 		collector.addRule(`
-			.monaco-editor .zone-widget .codicon-error,
-			.markers-panel .marker-icon.codicon-error,
-			.extensions-viewlet > .extensions .codicon-error,
-			.monaco-dialog-box .dialog-message-row .codicon-error {
+			.monaco-editor .zone-widget ${errorCodiconSelector},
+			.markers-panel .marker-icon${errorCodiconSelector},
+			.extensions-viewlet > .extensions ${errorCodiconSelector} {
 				color: ${errorIconForeground};
 			}
 		`);
 	}

 	const warningIconForeground = theme.getColor(problemsWarningIconForeground);
-	if (errorIconForeground) {
+	if (warningIconForeground) {
+		const warningCodiconSelector = Codicon.warning.cssSelector;
 		collector.addRule(`
-			.monaco-editor .zone-widget .codicon-warning,
-			.markers-panel .marker-icon.codicon-warning,
-			.extensions-viewlet > .extensions .codicon-warning,
-			.extension-editor .codicon-warning,
-			.monaco-dialog-box .dialog-message-row .codicon-warning {
+			.monaco-editor .zone-widget ${warningCodiconSelector},
+			.markers-panel .marker-icon${warningCodiconSelector},
+			.extensions-viewlet > .extensions ${warningCodiconSelector},
+			.extension-editor ${warningCodiconSelector} {
 				color: ${warningIconForeground};
 			}
 		`);
 	}

 	const infoIconForeground = theme.getColor(problemsInfoIconForeground);
-	if (errorIconForeground) {
+	if (infoIconForeground) {
+		const infoCodiconSelector = Codicon.info.cssSelector;
 		collector.addRule(`
-			.monaco-editor .zone-widget .codicon-info,
-			.markers-panel .marker-icon.codicon-info,
-			.extensions-viewlet > .extensions .codicon-info,
-			.extension-editor .codicon-info,
-			.monaco-dialog-box .dialog-message-row .codicon-info {
+			.monaco-editor .zone-widget ${infoCodiconSelector},
+			.markers-panel .marker-icon${infoCodiconSelector},
+			.extensions-viewlet > .extensions ${infoCodiconSelector},
+			.extension-editor ${infoCodiconSelector} {
 				color: ${infoIconForeground};
 			}
 		`);
--- a/src/vs/platform/theme/common/iconRegistry.ts
+++ b/src/vs/platform/theme/common/iconRegistry.ts
@@ -8,6 +8,8 @@ import { IJSONSchema, IJSONSchemaMap } from 'vs/base/common/jsonSchema';
 import { ThemeIcon } from 'vs/platform/theme/common/themeService';
 import { Event, Emitter } from 'vs/base/common/event';
 import { localize } from 'vs/nls';
+import { Extensions as JSONExtensions, IJSONContributionRegistry } from 'vs/platform/jsonschemas/common/jsonContributionRegistry';
+import { RunOnceScheduler } from 'vs/base/common/async';

 //  ------ API types

@@ -17,8 +19,10 @@ export const Extensions = {
 	IconContribution: 'base.contributions.icons'
 };

-export interface IconDefaults {
-	font?: string;
+export type IconDefaults = ThemeIcon | IconDefinition;
+
+export interface IconDefinition {
+	fontId?: string;
 	character: string;
 }

@@ -69,20 +73,38 @@ class IconRegistry implements IIconRegistry {
 	readonly onDidChangeSchema: Event<void> = this._onDidChangeSchema.event;

 	private iconsById: { [key: string]: IconContribution };
-	private iconSchema: IJSONSchema & { properties: IJSONSchemaMap } = { type: 'object', properties: {} };
+	private iconSchema: IJSONSchema & { properties: IJSONSchemaMap } = {
+		definitions: {
+			icons: {
+				type: 'object',
+				properties: {
+					fontId: { type: 'string', description: localize('iconDefintion.fontId', 'The id of the font to use. If not set, the font that is defined first is used.') },
+					fontCharacter: { type: 'string', description: localize('iconDefintion.fontCharacter', 'The font character associated with the icon definition.') }
+				},
+				additionalProperties: false,
+				defaultSnippets: [{ body: { fontCharacter: '\\\\e030' } }]
+			}
+		},
+		type: 'object',
+		properties: {}
+	};
 	private iconReferenceSchema: IJSONSchema & { enum: string[], enumDescriptions: string[] } = { type: 'string', enum: [], enumDescriptions: [] };

 	constructor() {
 		this.iconsById = {};
 	}

-	public registerIcon(id: string, defaults: IconDefaults, description: string, deprecationMessage?: string): ThemeIcon {
+	public registerIcon(id: string, defaults: IconDefaults, description?: string, deprecationMessage?: string): ThemeIcon {
+		if (!description) {
+			description = localize('icon.defaultDescription', 'Icon with identifier {0}', id);
+		}
 		let iconContribution: IconContribution = { id, description, defaults, deprecationMessage };
 		this.iconsById[id] = iconContribution;
-		let propertySchema: IJSONSchema = { type: 'object', description, properties: { font: { type: 'string' }, fontCharacter: { type: 'string' } }, defaultSnippets: [{ body: { fontCharacter: '\\\\e030' } }] };
+		let propertySchema: IJSONSchema = { $ref: '#/definitions/icons' };
 		if (deprecationMessage) {
 			propertySchema.deprecationMessage = deprecationMessage;
 		}
+		propertySchema.markdownDescription = `${description}: $(${id})`;
 		this.iconSchema.properties[id] = propertySchema;
 		this.iconReferenceSchema.enum.push(id);
 		this.iconReferenceSchema.enumDescriptions.push(description);
@@ -133,7 +155,7 @@ class IconRegistry implements IIconRegistry {
 const iconRegistry = new IconRegistry();
 platform.Registry.add(Extensions.IconContribution, iconRegistry);

-export function registerIcon(id: string, defaults: IconDefaults, description: string, deprecationMessage?: string): ThemeIcon {
+export function registerIcon(id: string, defaults: IconDefaults, description?: string, deprecationMessage?: string): ThemeIcon {
 	return iconRegistry.registerIcon(id, defaults, description, deprecationMessage);
 }

@@ -141,403 +163,21 @@ export function getIconRegistry(): IIconRegistry {
 	return iconRegistry;
 }

-registerIcon('add', { character: '\ea60' }, localize('add', ''));
-registerIcon('plus', { character: '\ea60' }, localize('plus', ''));
-registerIcon('gist-new', { character: '\ea60' }, localize('gist-new', ''));
-registerIcon('repo-create', { character: '\ea60' }, localize('repo-create', ''));
-registerIcon('lightbulb', { character: '\ea61' }, localize('lightbulb', ''));
-registerIcon('light-bulb', { character: '\ea61' }, localize('light-bulb', ''));
-registerIcon('repo', { character: '\ea62' }, localize('repo', ''));
-registerIcon('repo-delete', { character: '\ea62' }, localize('repo-delete', ''));
-registerIcon('gist-fork', { character: '\ea63' }, localize('gist-fork', ''));
-registerIcon('repo-forked', { character: '\ea63' }, localize('repo-forked', ''));
-registerIcon('git-pull-request', { character: '\ea64' }, localize('git-pull-request', ''));
-registerIcon('git-pull-request-abandoned', { character: '\ea64' }, localize('git-pull-request-abandoned', ''));
-registerIcon('record-keys', { character: '\ea65' }, localize('record-keys', ''));
-registerIcon('keyboard', { character: '\ea65' }, localize('keyboard', ''));
-registerIcon('tag', { character: '\ea66' }, localize('tag', ''));
-registerIcon('tag-add', { character: '\ea66' }, localize('tag-add', ''));
-registerIcon('tag-remove', { character: '\ea66' }, localize('tag-remove', ''));
-registerIcon('person', { character: '\ea67' }, localize('person', ''));
-registerIcon('person-add', { character: '\ea67' }, localize('person-add', ''));
-registerIcon('person-follow', { character: '\ea67' }, localize('person-follow', ''));
-registerIcon('person-outline', { character: '\ea67' }, localize('person-outline', ''));
-registerIcon('person-filled', { character: '\ea67' }, localize('person-filled', ''));
-registerIcon('git-branch', { character: '\ea68' }, localize('git-branch', ''));
-registerIcon('git-branch-create', { character: '\ea68' }, localize('git-branch-create', ''));
-registerIcon('git-branch-delete', { character: '\ea68' }, localize('git-branch-delete', ''));
-registerIcon('source-control', { character: '\ea68' }, localize('source-control', ''));
-registerIcon('mirror', { character: '\ea69' }, localize('mirror', ''));
-registerIcon('mirror-public', { character: '\ea69' }, localize('mirror-public', ''));
-registerIcon('star', { character: '\ea6a' }, localize('star', ''));
-registerIcon('star-add', { character: '\ea6a' }, localize('star-add', ''));
-registerIcon('star-delete', { character: '\ea6a' }, localize('star-delete', ''));
-registerIcon('star-empty', { character: '\ea6a' }, localize('star-empty', ''));
-registerIcon('comment', { character: '\ea6b' }, localize('comment', ''));
-registerIcon('comment-add', { character: '\ea6b' }, localize('comment-add', ''));
-registerIcon('alert', { character: '\ea6c' }, localize('alert', ''));
-registerIcon('warning', { character: '\ea6c' }, localize('warning', ''));
-registerIcon('search', { character: '\ea6d' }, localize('search', ''));
-registerIcon('search-save', { character: '\ea6d' }, localize('search-save', ''));
-registerIcon('log-out', { character: '\ea6e' }, localize('log-out', ''));
-registerIcon('sign-out', { character: '\ea6e' }, localize('sign-out', ''));
-registerIcon('log-in', { character: '\ea6f' }, localize('log-in', ''));
-registerIcon('sign-in', { character: '\ea6f' }, localize('sign-in', ''));
-registerIcon('eye', { character: '\ea70' }, localize('eye', ''));
-registerIcon('eye-unwatch', { character: '\ea70' }, localize('eye-unwatch', ''));
-registerIcon('eye-watch', { character: '\ea70' }, localize('eye-watch', ''));
-registerIcon('circle-filled', { character: '\ea71' }, localize('circle-filled', ''));
-registerIcon('primitive-dot', { character: '\ea71' }, localize('primitive-dot', ''));
-registerIcon('close-dirty', { character: '\ea71' }, localize('close-dirty', ''));
-registerIcon('debug-breakpoint', { character: '\ea71' }, localize('debug-breakpoint', ''));
-registerIcon('debug-breakpoint-disabled', { character: '\ea71' }, localize('debug-breakpoint-disabled', ''));
-registerIcon('debug-hint', { character: '\ea71' }, localize('debug-hint', ''));
-registerIcon('primitive-square', { character: '\ea72' }, localize('primitive-square', ''));
-registerIcon('edit', { character: '\ea73' }, localize('edit', ''));
-registerIcon('pencil', { character: '\ea73' }, localize('pencil', ''));
-registerIcon('info', { character: '\ea74' }, localize('info', ''));
-registerIcon('issue-opened', { character: '\ea74' }, localize('issue-opened', ''));
-registerIcon('gist-private', { character: '\ea75' }, localize('gist-private', ''));
-registerIcon('git-fork-private', { character: '\ea75' }, localize('git-fork-private', ''));
-registerIcon('lock', { character: '\ea75' }, localize('lock', ''));
-registerIcon('mirror-private', { character: '\ea75' }, localize('mirror-private', ''));
-registerIcon('close', { character: '\ea76' }, localize('close', ''));
-registerIcon('remove-close', { character: '\ea76' }, localize('remove-close', ''));
-registerIcon('x', { character: '\ea76' }, localize('x', ''));
-registerIcon('repo-sync', { character: '\ea77' }, localize('repo-sync', ''));
-registerIcon('sync', { character: '\ea77' }, localize('sync', ''));
-registerIcon('clone', { character: '\ea78' }, localize('clone', ''));
-registerIcon('desktop-download', { character: '\ea78' }, localize('desktop-download', ''));
-registerIcon('beaker', { character: '\ea79' }, localize('beaker', ''));
-registerIcon('microscope', { character: '\ea79' }, localize('microscope', ''));
-registerIcon('vm', { character: '\ea7a' }, localize('vm', ''));
-registerIcon('device-desktop', { character: '\ea7a' }, localize('device-desktop', ''));
-registerIcon('file', { character: '\ea7b' }, localize('file', ''));
-registerIcon('file-text', { character: '\ea7b' }, localize('file-text', ''));
-registerIcon('more', { character: '\ea7c' }, localize('more', ''));
-registerIcon('ellipsis', { character: '\ea7c' }, localize('ellipsis', ''));
-registerIcon('kebab-horizontal', { character: '\ea7c' }, localize('kebab-horizontal', ''));
-registerIcon('mail-reply', { character: '\ea7d' }, localize('mail-reply', ''));
-registerIcon('reply', { character: '\ea7d' }, localize('reply', ''));
-registerIcon('organization', { character: '\ea7e' }, localize('organization', ''));
-registerIcon('organization-filled', { character: '\ea7e' }, localize('organization-filled', ''));
-registerIcon('organization-outline', { character: '\ea7e' }, localize('organization-outline', ''));
-registerIcon('new-file', { character: '\ea7f' }, localize('new-file', ''));
-registerIcon('file-add', { character: '\ea7f' }, localize('file-add', ''));
-registerIcon('new-folder', { character: '\ea80' }, localize('new-folder', ''));
-registerIcon('file-directory-create', { character: '\ea80' }, localize('file-directory-create', ''));
-registerIcon('trash', { character: '\ea81' }, localize('trash', ''));
-registerIcon('trashcan', { character: '\ea81' }, localize('trashcan', ''));
-registerIcon('history', { character: '\ea82' }, localize('history', ''));
-registerIcon('clock', { character: '\ea82' }, localize('clock', ''));
-registerIcon('folder', { character: '\ea83' }, localize('folder', ''));
-registerIcon('file-directory', { character: '\ea83' }, localize('file-directory', ''));
-registerIcon('symbol-folder', { character: '\ea83' }, localize('symbol-folder', ''));
-registerIcon('logo-github', { character: '\ea84' }, localize('logo-github', ''));
-registerIcon('mark-github', { character: '\ea84' }, localize('mark-github', ''));
-registerIcon('github', { character: '\ea84' }, localize('github', ''));
-registerIcon('terminal', { character: '\ea85' }, localize('terminal', ''));
-registerIcon('console', { character: '\ea85' }, localize('console', ''));
-registerIcon('repl', { character: '\ea85' }, localize('repl', ''));
-registerIcon('zap', { character: '\ea86' }, localize('zap', ''));
-registerIcon('symbol-event', { character: '\ea86' }, localize('symbol-event', ''));
-registerIcon('error', { character: '\ea87' }, localize('error', ''));
-registerIcon('stop', { character: '\ea87' }, localize('stop', ''));
-registerIcon('variable', { character: '\ea88' }, localize('variable', ''));
-registerIcon('symbol-variable', { character: '\ea88' }, localize('symbol-variable', ''));
-registerIcon('array', { character: '\ea8a' }, localize('array', ''));
-registerIcon('symbol-array', { character: '\ea8a' }, localize('symbol-array', ''));
-registerIcon('symbol-module', { character: '\ea8b' }, localize('symbol-module', ''));
-registerIcon('symbol-package', { character: '\ea8b' }, localize('symbol-package', ''));
-registerIcon('symbol-namespace', { character: '\ea8b' }, localize('symbol-namespace', ''));
-registerIcon('symbol-object', { character: '\ea8b' }, localize('symbol-object', ''));
-registerIcon('symbol-method', { character: '\ea8c' }, localize('symbol-method', ''));
-registerIcon('symbol-function', { character: '\ea8c' }, localize('symbol-function', ''));
-registerIcon('symbol-constructor', { character: '\ea8c' }, localize('symbol-constructor', ''));
-registerIcon('symbol-boolean', { character: '\ea8f' }, localize('symbol-boolean', ''));
-registerIcon('symbol-null', { character: '\ea8f' }, localize('symbol-null', ''));
-registerIcon('symbol-numeric', { character: '\ea90' }, localize('symbol-numeric', ''));
-registerIcon('symbol-number', { character: '\ea90' }, localize('symbol-number', ''));
-registerIcon('symbol-structure', { character: '\ea91' }, localize('symbol-structure', ''));
-registerIcon('symbol-struct', { character: '\ea91' }, localize('symbol-struct', ''));
-registerIcon('symbol-parameter', { character: '\ea92' }, localize('symbol-parameter', ''));
-registerIcon('symbol-type-parameter', { character: '\ea92' }, localize('symbol-type-parameter', ''));
-registerIcon('symbol-key', { character: '\ea93' }, localize('symbol-key', ''));
-registerIcon('symbol-text', { character: '\ea93' }, localize('symbol-text', ''));
-registerIcon('symbol-reference', { character: '\ea94' }, localize('symbol-reference', ''));
-registerIcon('go-to-file', { character: '\ea94' }, localize('go-to-file', ''));
-registerIcon('symbol-enum', { character: '\ea95' }, localize('symbol-enum', ''));
-registerIcon('symbol-value', { character: '\ea95' }, localize('symbol-value', ''));
-registerIcon('symbol-ruler', { character: '\ea96' }, localize('symbol-ruler', ''));
-registerIcon('symbol-unit', { character: '\ea96' }, localize('symbol-unit', ''));
-registerIcon('activate-breakpoints', { character: '\ea97' }, localize('activate-breakpoints', ''));
-registerIcon('archive', { character: '\ea98' }, localize('archive', ''));
-registerIcon('arrow-both', { character: '\ea99' }, localize('arrow-both', ''));
-registerIcon('arrow-down', { character: '\ea9a' }, localize('arrow-down', ''));
-registerIcon('arrow-left', { character: '\ea9b' }, localize('arrow-left', ''));
-registerIcon('arrow-right', { character: '\ea9c' }, localize('arrow-right', ''));
-registerIcon('arrow-small-down', { character: '\ea9d' }, localize('arrow-small-down', ''));
-registerIcon('arrow-small-left', { character: '\ea9e' }, localize('arrow-small-left', ''));
-registerIcon('arrow-small-right', { character: '\ea9f' }, localize('arrow-small-right', ''));
-registerIcon('arrow-small-up', { character: '\eaa0' }, localize('arrow-small-up', ''));
-registerIcon('arrow-up', { character: '\eaa1' }, localize('arrow-up', ''));
-registerIcon('bell', { character: '\eaa2' }, localize('bell', ''));
-registerIcon('bold', { character: '\eaa3' }, localize('bold', ''));
-registerIcon('book', { character: '\eaa4' }, localize('book', ''));
-registerIcon('bookmark', { character: '\eaa5' }, localize('bookmark', ''));
-registerIcon('debug-breakpoint-conditional-unverified', { character: '\eaa6' }, localize('debug-breakpoint-conditional-unverified', ''));
-registerIcon('debug-breakpoint-conditional', { character: '\eaa7' }, localize('debug-breakpoint-conditional', ''));
-registerIcon('debug-breakpoint-conditional-disabled', { character: '\eaa7' }, localize('debug-breakpoint-conditional-disabled', ''));
-registerIcon('debug-breakpoint-data-unverified', { character: '\eaa8' }, localize('debug-breakpoint-data-unverified', ''));
-registerIcon('debug-breakpoint-data', { character: '\eaa9' }, localize('debug-breakpoint-data', ''));
-registerIcon('debug-breakpoint-data-disabled', { character: '\eaa9' }, localize('debug-breakpoint-data-disabled', ''));
-registerIcon('debug-breakpoint-log-unverified', { character: '\eaaa' }, localize('debug-breakpoint-log-unverified', ''));
-registerIcon('debug-breakpoint-log', { character: '\eaab' }, localize('debug-breakpoint-log', ''));
-registerIcon('debug-breakpoint-log-disabled', { character: '\eaab' }, localize('debug-breakpoint-log-disabled', ''));
-registerIcon('briefcase', { character: '\eaac' }, localize('briefcase', ''));
-registerIcon('broadcast', { character: '\eaad' }, localize('broadcast', ''));
-registerIcon('browser', { character: '\eaae' }, localize('browser', ''));
-registerIcon('bug', { character: '\eaaf' }, localize('bug', ''));
-registerIcon('calendar', { character: '\eab0' }, localize('calendar', ''));
-registerIcon('case-sensitive', { character: '\eab1' }, localize('case-sensitive', ''));
-registerIcon('check', { character: '\eab2' }, localize('check', ''));
-registerIcon('checklist', { character: '\eab3' }, localize('checklist', ''));
-registerIcon('chevron-down', { character: '\eab4' }, localize('chevron-down', ''));
-registerIcon('chevron-left', { character: '\eab5' }, localize('chevron-left', ''));
-registerIcon('chevron-right', { character: '\eab6' }, localize('chevron-right', ''));
-registerIcon('chevron-up', { character: '\eab7' }, localize('chevron-up', ''));
-registerIcon('chrome-close', { character: '\eab8' }, localize('chrome-close', ''));
-registerIcon('chrome-maximize', { character: '\eab9' }, localize('chrome-maximize', ''));
-registerIcon('chrome-minimize', { character: '\eaba' }, localize('chrome-minimize', ''));
-registerIcon('chrome-restore', { character: '\eabb' }, localize('chrome-restore', ''));
-registerIcon('circle-outline', { character: '\eabc' }, localize('circle-outline', ''));
-registerIcon('debug-breakpoint-unverified', { character: '\eabc' }, localize('debug-breakpoint-unverified', ''));
-registerIcon('circle-slash', { character: '\eabd' }, localize('circle-slash', ''));
-registerIcon('circuit-board', { character: '\eabe' }, localize('circuit-board', ''));
-registerIcon('clear-all', { character: '\eabf' }, localize('clear-all', ''));
-registerIcon('clippy', { character: '\eac0' }, localize('clippy', ''));
-registerIcon('close-all', { character: '\eac1' }, localize('close-all', ''));
-registerIcon('cloud-download', { character: '\eac2' }, localize('cloud-download', ''));
-registerIcon('cloud-upload', { character: '\eac3' }, localize('cloud-upload', ''));
-registerIcon('code', { character: '\eac4' }, localize('code', ''));
-registerIcon('collapse-all', { character: '\eac5' }, localize('collapse-all', ''));
-registerIcon('color-mode', { character: '\eac6' }, localize('color-mode', ''));
-registerIcon('comment-discussion', { character: '\eac7' }, localize('comment-discussion', ''));
-registerIcon('compare-changes', { character: '\eac8' }, localize('compare-changes', ''));
-registerIcon('credit-card', { character: '\eac9' }, localize('credit-card', ''));
-registerIcon('dash', { character: '\eacc' }, localize('dash', ''));
-registerIcon('dashboard', { character: '\eacd' }, localize('dashboard', ''));
-registerIcon('database', { character: '\eace' }, localize('database', ''));
-registerIcon('debug-continue', { character: '\eacf' }, localize('debug-continue', ''));
-registerIcon('debug-disconnect', { character: '\ead0' }, localize('debug-disconnect', ''));
-registerIcon('debug-pause', { character: '\ead1' }, localize('debug-pause', ''));
-registerIcon('debug-restart', { character: '\ead2' }, localize('debug-restart', ''));
-registerIcon('debug-start', { character: '\ead3' }, localize('debug-start', ''));
-registerIcon('debug-step-into', { character: '\ead4' }, localize('debug-step-into', ''));
-registerIcon('debug-step-out', { character: '\ead5' }, localize('debug-step-out', ''));
-registerIcon('debug-step-over', { character: '\ead6' }, localize('debug-step-over', ''));
-registerIcon('debug-stop', { character: '\ead7' }, localize('debug-stop', ''));
-registerIcon('debug', { character: '\ead8' }, localize('debug', ''));
-registerIcon('device-camera-video', { character: '\ead9' }, localize('device-camera-video', ''));
-registerIcon('device-camera', { character: '\eada' }, localize('device-camera', ''));
-registerIcon('device-mobile', { character: '\eadb' }, localize('device-mobile', ''));
-registerIcon('diff-added', { character: '\eadc' }, localize('diff-added', ''));
-registerIcon('diff-ignored', { character: '\eadd' }, localize('diff-ignored', ''));
-registerIcon('diff-modified', { character: '\eade' }, localize('diff-modified', ''));
-registerIcon('diff-removed', { character: '\eadf' }, localize('diff-removed', ''));
-registerIcon('diff-renamed', { character: '\eae0' }, localize('diff-renamed', ''));
-registerIcon('diff', { character: '\eae1' }, localize('diff', ''));
-registerIcon('discard', { character: '\eae2' }, localize('discard', ''));
-registerIcon('editor-layout', { character: '\eae3' }, localize('editor-layout', ''));
-registerIcon('empty-window', { character: '\eae4' }, localize('empty-window', ''));
-registerIcon('exclude', { character: '\eae5' }, localize('exclude', ''));
-registerIcon('extensions', { character: '\eae6' }, localize('extensions', ''));
-registerIcon('eye-closed', { character: '\eae7' }, localize('eye-closed', ''));
-registerIcon('file-binary', { character: '\eae8' }, localize('file-binary', ''));
-registerIcon('file-code', { character: '\eae9' }, localize('file-code', ''));
-registerIcon('file-media', { character: '\eaea' }, localize('file-media', ''));
-registerIcon('file-pdf', { character: '\eaeb' }, localize('file-pdf', ''));
-registerIcon('file-submodule', { character: '\eaec' }, localize('file-submodule', ''));
-registerIcon('file-symlink-directory', { character: '\eaed' }, localize('file-symlink-directory', ''));
-registerIcon('file-symlink-file', { character: '\eaee' }, localize('file-symlink-file', ''));
-registerIcon('file-zip', { character: '\eaef' }, localize('file-zip', ''));
-registerIcon('files', { character: '\eaf0' }, localize('files', ''));
-registerIcon('filter', { character: '\eaf1' }, localize('filter', ''));
-registerIcon('flame', { character: '\eaf2' }, localize('flame', ''));
-registerIcon('fold-down', { character: '\eaf3' }, localize('fold-down', ''));
-registerIcon('fold-up', { character: '\eaf4' }, localize('fold-up', ''));
-registerIcon('fold', { character: '\eaf5' }, localize('fold', ''));
-registerIcon('folder-active', { character: '\eaf6' }, localize('folder-active', ''));
-registerIcon('folder-opened', { character: '\eaf7' }, localize('folder-opened', ''));
-registerIcon('gear', { character: '\eaf8' }, localize('gear', ''));
-registerIcon('gift', { character: '\eaf9' }, localize('gift', ''));
-registerIcon('gist-secret', { character: '\eafa' }, localize('gist-secret', ''));
-registerIcon('gist', { character: '\eafb' }, localize('gist', ''));
-registerIcon('git-commit', { character: '\eafc' }, localize('git-commit', ''));
-registerIcon('git-compare', { character: '\eafd' }, localize('git-compare', ''));
-registerIcon('git-merge', { character: '\eafe' }, localize('git-merge', ''));
-registerIcon('github-action', { character: '\eaff' }, localize('github-action', ''));
-registerIcon('github-alt', { character: '\eb00' }, localize('github-alt', ''));
-registerIcon('globe', { character: '\eb01' }, localize('globe', ''));
-registerIcon('grabber', { character: '\eb02' }, localize('grabber', ''));
-registerIcon('graph', { character: '\eb03' }, localize('graph', ''));
-registerIcon('gripper', { character: '\eb04' }, localize('gripper', ''));
-registerIcon('heart', { character: '\eb05' }, localize('heart', ''));
-registerIcon('home', { character: '\eb06' }, localize('home', ''));
-registerIcon('horizontal-rule', { character: '\eb07' }, localize('horizontal-rule', ''));
-registerIcon('hubot', { character: '\eb08' }, localize('hubot', ''));
-registerIcon('inbox', { character: '\eb09' }, localize('inbox', ''));
-registerIcon('issue-closed', { character: '\eb0a' }, localize('issue-closed', ''));
-registerIcon('issue-reopened', { character: '\eb0b' }, localize('issue-reopened', ''));
-registerIcon('issues', { character: '\eb0c' }, localize('issues', ''));
-registerIcon('italic', { character: '\eb0d' }, localize('italic', ''));
-registerIcon('jersey', { character: '\eb0e' }, localize('jersey', ''));
-registerIcon('json', { character: '\eb0f' }, localize('json', ''));
-registerIcon('kebab-vertical', { character: '\eb10' }, localize('kebab-vertical', ''));
-registerIcon('key', { character: '\eb11' }, localize('key', ''));
-registerIcon('law', { character: '\eb12' }, localize('law', ''));
-registerIcon('lightbulb-autofix', { character: '\eb13' }, localize('lightbulb-autofix', ''));
-registerIcon('link-external', { character: '\eb14' }, localize('link-external', ''));
-registerIcon('link', { character: '\eb15' }, localize('link', ''));
-registerIcon('list-ordered', { character: '\eb16' }, localize('list-ordered', ''));
-registerIcon('list-unordered', { character: '\eb17' }, localize('list-unordered', ''));
-registerIcon('live-share', { character: '\eb18' }, localize('live-share', ''));
-registerIcon('loading', { character: '\eb19' }, localize('loading', ''));
-registerIcon('location', { character: '\eb1a' }, localize('location', ''));
-registerIcon('mail-read', { character: '\eb1b' }, localize('mail-read', ''));
-registerIcon('mail', { character: '\eb1c' }, localize('mail', ''));
-registerIcon('markdown', { character: '\eb1d' }, localize('markdown', ''));
-registerIcon('megaphone', { character: '\eb1e' }, localize('megaphone', ''));
-registerIcon('mention', { character: '\eb1f' }, localize('mention', ''));
-registerIcon('milestone', { character: '\eb20' }, localize('milestone', ''));
-registerIcon('mortar-board', { character: '\eb21' }, localize('mortar-board', ''));
-registerIcon('move', { character: '\eb22' }, localize('move', ''));
-registerIcon('multiple-windows', { character: '\eb23' }, localize('multiple-windows', ''));
-registerIcon('mute', { character: '\eb24' }, localize('mute', ''));
-registerIcon('no-newline', { character: '\eb25' }, localize('no-newline', ''));
-registerIcon('note', { character: '\eb26' }, localize('note', ''));
-registerIcon('octoface', { character: '\eb27' }, localize('octoface', ''));
-registerIcon('open-preview', { character: '\eb28' }, localize('open-preview', ''));
-registerIcon('package', { character: '\eb29' }, localize('package', ''));
-registerIcon('paintcan', { character: '\eb2a' }, localize('paintcan', ''));
-registerIcon('pin', { character: '\eb2b' }, localize('pin', ''));
-registerIcon('play', { character: '\eb2c' }, localize('play', ''));
-registerIcon('run', { character: '\eb2c' }, localize('run', ''));
-registerIcon('plug', { character: '\eb2d' }, localize('plug', ''));
-registerIcon('preserve-case', { character: '\eb2e' }, localize('preserve-case', ''));
-registerIcon('preview', { character: '\eb2f' }, localize('preview', ''));
-registerIcon('project', { character: '\eb30' }, localize('project', ''));
-registerIcon('pulse', { character: '\eb31' }, localize('pulse', ''));
-registerIcon('question', { character: '\eb32' }, localize('question', ''));
-registerIcon('quote', { character: '\eb33' }, localize('quote', ''));
-registerIcon('radio-tower', { character: '\eb34' }, localize('radio-tower', ''));
-registerIcon('reactions', { character: '\eb35' }, localize('reactions', ''));
-registerIcon('references', { character: '\eb36' }, localize('references', ''));
-registerIcon('refresh', { character: '\eb37' }, localize('refresh', ''));
-registerIcon('regex', { character: '\eb38' }, localize('regex', ''));
-registerIcon('remote-explorer', { character: '\eb39' }, localize('remote-explorer', ''));
-registerIcon('remote', { character: '\eb3a' }, localize('remote', ''));
-registerIcon('remove', { character: '\eb3b' }, localize('remove', ''));
-registerIcon('replace-all', { character: '\eb3c' }, localize('replace-all', ''));
-registerIcon('replace', { character: '\eb3d' }, localize('replace', ''));
-registerIcon('repo-clone', { character: '\eb3e' }, localize('repo-clone', ''));
-registerIcon('repo-force-push', { character: '\eb3f' }, localize('repo-force-push', ''));
-registerIcon('repo-pull', { character: '\eb40' }, localize('repo-pull', ''));
-registerIcon('repo-push', { character: '\eb41' }, localize('repo-push', ''));
-registerIcon('report', { character: '\eb42' }, localize('report', ''));
-registerIcon('request-changes', { character: '\eb43' }, localize('request-changes', ''));
-registerIcon('rocket', { character: '\eb44' }, localize('rocket', ''));
-registerIcon('root-folder-opened', { character: '\eb45' }, localize('root-folder-opened', ''));
-registerIcon('root-folder', { character: '\eb46' }, localize('root-folder', ''));
-registerIcon('rss', { character: '\eb47' }, localize('rss', ''));
-registerIcon('ruby', { character: '\eb48' }, localize('ruby', ''));
-registerIcon('save-all', { character: '\eb49' }, localize('save-all', ''));
-registerIcon('save-as', { character: '\eb4a' }, localize('save-as', ''));
-registerIcon('save', { character: '\eb4b' }, localize('save', ''));
-registerIcon('screen-full', { character: '\eb4c' }, localize('screen-full', ''));
-registerIcon('screen-normal', { character: '\eb4d' }, localize('screen-normal', ''));
-registerIcon('search-stop', { character: '\eb4e' }, localize('search-stop', ''));
-registerIcon('server', { character: '\eb50' }, localize('server', ''));
-registerIcon('settings-gear', { character: '\eb51' }, localize('settings-gear', ''));
-registerIcon('settings', { character: '\eb52' }, localize('settings', ''));
-registerIcon('shield', { character: '\eb53' }, localize('shield', ''));
-registerIcon('smiley', { character: '\eb54' }, localize('smiley', ''));
-registerIcon('sort-precedence', { character: '\eb55' }, localize('sort-precedence', ''));
-registerIcon('split-horizontal', { character: '\eb56' }, localize('split-horizontal', ''));
-registerIcon('split-vertical', { character: '\eb57' }, localize('split-vertical', ''));
-registerIcon('squirrel', { character: '\eb58' }, localize('squirrel', ''));
-registerIcon('star-full', { character: '\eb59' }, localize('star-full', ''));
-registerIcon('star-half', { character: '\eb5a' }, localize('star-half', ''));
-registerIcon('symbol-class', { character: '\eb5b' }, localize('symbol-class', ''));
-registerIcon('symbol-color', { character: '\eb5c' }, localize('symbol-color', ''));
-registerIcon('symbol-constant', { character: '\eb5d' }, localize('symbol-constant', ''));
-registerIcon('symbol-enum-member', { character: '\eb5e' }, localize('symbol-enum-member', ''));
-registerIcon('symbol-field', { character: '\eb5f' }, localize('symbol-field', ''));
-registerIcon('symbol-file', { character: '\eb60' }, localize('symbol-file', ''));
-registerIcon('symbol-interface', { character: '\eb61' }, localize('symbol-interface', ''));
-registerIcon('symbol-keyword', { character: '\eb62' }, localize('symbol-keyword', ''));
-registerIcon('symbol-misc', { character: '\eb63' }, localize('symbol-misc', ''));
-registerIcon('symbol-operator', { character: '\eb64' }, localize('symbol-operator', ''));
-registerIcon('symbol-property', { character: '\eb65' }, localize('symbol-property', ''));
-registerIcon('wrench', { character: '\eb65' }, localize('wrench', ''));
-registerIcon('wrench-subaction', { character: '\eb65' }, localize('wrench-subaction', ''));
-registerIcon('symbol-snippet', { character: '\eb66' }, localize('symbol-snippet', ''));
-registerIcon('tasklist', { character: '\eb67' }, localize('tasklist', ''));
-registerIcon('telescope', { character: '\eb68' }, localize('telescope', ''));
-registerIcon('text-size', { character: '\eb69' }, localize('text-size', ''));
-registerIcon('three-bars', { character: '\eb6a' }, localize('three-bars', ''));
-registerIcon('thumbsdown', { character: '\eb6b' }, localize('thumbsdown', ''));
-registerIcon('thumbsup', { character: '\eb6c' }, localize('thumbsup', ''));
-registerIcon('tools', { character: '\eb6d' }, localize('tools', ''));
-registerIcon('triangle-down', { character: '\eb6e' }, localize('triangle-down', ''));
-registerIcon('triangle-left', { character: '\eb6f' }, localize('triangle-left', ''));
-registerIcon('triangle-right', { character: '\eb70' }, localize('triangle-right', ''));
-registerIcon('triangle-up', { character: '\eb71' }, localize('triangle-up', ''));
-registerIcon('twitter', { character: '\eb72' }, localize('twitter', ''));
-registerIcon('unfold', { character: '\eb73' }, localize('unfold', ''));
-registerIcon('unlock', { character: '\eb74' }, localize('unlock', ''));
-registerIcon('unmute', { character: '\eb75' }, localize('unmute', ''));
-registerIcon('unverified', { character: '\eb76' }, localize('unverified', ''));
-registerIcon('verified', { character: '\eb77' }, localize('verified', ''));
-registerIcon('versions', { character: '\eb78' }, localize('versions', ''));
-registerIcon('vm-active', { character: '\eb79' }, localize('vm-active', ''));
-registerIcon('vm-outline', { character: '\eb7a' }, localize('vm-outline', ''));
-registerIcon('vm-running', { character: '\eb7b' }, localize('vm-running', ''));
-registerIcon('watch', { character: '\eb7c' }, localize('watch', ''));
-registerIcon('whitespace', { character: '\eb7d' }, localize('whitespace', ''));
-registerIcon('whole-word', { character: '\eb7e' }, localize('whole-word', ''));
-registerIcon('window', { character: '\eb7f' }, localize('window', ''));
-registerIcon('word-wrap', { character: '\eb80' }, localize('word-wrap', ''));
-registerIcon('zoom-in', { character: '\eb81' }, localize('zoom-in', ''));
-registerIcon('zoom-out', { character: '\eb82' }, localize('zoom-out', ''));
-registerIcon('list-filter', { character: '\eb83' }, localize('list-filter', ''));
-registerIcon('list-flat', { character: '\eb84' }, localize('list-flat', ''));
-registerIcon('list-selection', { character: '\eb85' }, localize('list-selection', ''));
-registerIcon('selection', { character: '\eb85' }, localize('selection', ''));
-registerIcon('list-tree', { character: '\eb86' }, localize('list-tree', ''));
-registerIcon('debug-breakpoint-function-unverified', { character: '\eb87' }, localize('debug-breakpoint-function-unverified', ''));
-registerIcon('debug-breakpoint-function', { character: '\eb88' }, localize('debug-breakpoint-function', ''));
-registerIcon('debug-breakpoint-function-disabled', { character: '\eb88' }, localize('debug-breakpoint-function-disabled', ''));
-registerIcon('debug-stackframe-active', { character: '\eb89' }, localize('debug-stackframe-active', ''));
-registerIcon('debug-stackframe-dot', { character: '\eb8a' }, localize('debug-stackframe-dot', ''));
-registerIcon('debug-stackframe', { character: '\eb8b' }, localize('debug-stackframe', ''));
-registerIcon('debug-stackframe-focused', { character: '\eb8b' }, localize('debug-stackframe-focused', ''));
-registerIcon('debug-breakpoint-unsupported', { character: '\eb8c' }, localize('debug-breakpoint-unsupported', ''));
-registerIcon('symbol-string', { character: '\eb8d' }, localize('symbol-string', ''));
-registerIcon('debug-reverse-continue', { character: '\eb8e' }, localize('debug-reverse-continue', ''));
-registerIcon('debug-step-back', { character: '\eb8f' }, localize('debug-step-back', ''));
-registerIcon('debug-restart-frame', { character: '\eb90' }, localize('debug-restart-frame', ''));
-registerIcon('debug-alternate', { character: '\eb91' }, localize('debug-alternate', ''));
-registerIcon('call-incoming', { character: '\eb92' }, localize('call-incoming', ''));
-registerIcon('call-outgoing', { character: '\eb93' }, localize('call-outgoing', ''));
-registerIcon('menu', { character: '\eb94' }, localize('menu', ''));
-registerIcon('expand-all', { character: '\eb95' }, localize('expand-all', ''));
-registerIcon('feedback', { character: '\eb96' }, localize('feedback', ''));
-registerIcon('group-by-ref-type', { character: '\eb97' }, localize('group-by-ref-type', ''));
-registerIcon('ungroup-by-ref-type', { character: '\eb98' }, localize('ungroup-by-ref-type', ''));
-registerIcon('bell-dot', { character: '\f101' }, localize('bell-dot', ''));
-registerIcon('debug-alt-2', { character: '\f102' }, localize('debug-alt-2', ''));
-registerIcon('debug-alt', { character: '\f103' }, localize('debug-alt', ''));
+
+
+
+
+export const iconsSchemaId = 'vscode://schemas/icons';
+
+let schemaRegistry = platform.Registry.as<IJSONContributionRegistry>(JSONExtensions.JSONContribution);
+schemaRegistry.registerSchema(iconsSchemaId, iconRegistry.getIconSchema());
+
+const delayer = new RunOnceScheduler(() => schemaRegistry.notifySchemaChanged(iconsSchemaId), 200);
+iconRegistry.onDidChangeSchema(() => {
+	if (!delayer.isScheduled()) {
+		delayer.schedule();
+	}
+});


 // setTimeout(_ => console.log(colorRegistry.toString()), 5000);
--- a/src/vs/platform/theme/common/styler.ts
+++ b/src/vs/platform/theme/common/styler.ts
@@ -4,7 +4,7 @@
 *--------------------------------------------------------------------------------------------*/

 import { IColorTheme, IThemeService } from 'vs/platform/theme/common/themeService';
-import { focusBorder, inputBackground, inputForeground, ColorIdentifier, selectForeground, selectBackground, selectListBackground, selectBorder, inputBorder, foreground, editorBackground, contrastBorder, inputActiveOptionBorder, inputActiveOptionBackground, listFocusBackground, listFocusForeground, listActiveSelectionBackground, listActiveSelectionForeground, listInactiveSelectionForeground, listInactiveSelectionBackground, listInactiveFocusBackground, listHoverBackground, listHoverForeground, listDropBackground, pickerGroupBorder, pickerGroupForeground, widgetShadow, inputValidationInfoBorder, inputValidationInfoBackground, inputValidationWarningBorder, inputValidationWarningBackground, inputValidationErrorBorder, inputValidationErrorBackground, activeContrastBorder, buttonForeground, buttonBackground, buttonHoverBackground, ColorFunction, badgeBackground, badgeForeground, progressBarBackground, breadcrumbsForeground, breadcrumbsFocusForeground, breadcrumbsActiveSelectionForeground, breadcrumbsBackground, editorWidgetBorder, inputValidationInfoForeground, inputValidationWarningForeground, inputValidationErrorForeground, menuForeground, menuBackground, menuSelectionForeground, menuSelectionBackground, menuSelectionBorder, menuBorder, menuSeparatorBackground, darken, listFilterWidgetOutline, listFilterWidgetNoMatchesOutline, listFilterWidgetBackground, editorWidgetBackground, treeIndentGuidesStroke, editorWidgetForeground, simpleCheckboxBackground, simpleCheckboxBorder, simpleCheckboxForeground, ColorValue, resolveColorValue, textLinkForeground } from 'vs/platform/theme/common/colorRegistry';
+import { focusBorder, inputBackground, inputForeground, ColorIdentifier, selectForeground, selectBackground, selectListBackground, selectBorder, inputBorder, foreground, editorBackground, contrastBorder, inputActiveOptionBorder, inputActiveOptionBackground, listFocusBackground, listFocusForeground, listActiveSelectionBackground, listActiveSelectionForeground, listInactiveSelectionForeground, listInactiveSelectionBackground, listInactiveFocusBackground, listHoverBackground, listHoverForeground, listDropBackground, pickerGroupBorder, pickerGroupForeground, widgetShadow, inputValidationInfoBorder, inputValidationInfoBackground, inputValidationWarningBorder, inputValidationWarningBackground, inputValidationErrorBorder, inputValidationErrorBackground, activeContrastBorder, buttonForeground, buttonBackground, buttonHoverBackground, ColorFunction, badgeBackground, badgeForeground, progressBarBackground, breadcrumbsForeground, breadcrumbsFocusForeground, breadcrumbsActiveSelectionForeground, breadcrumbsBackground, editorWidgetBorder, inputValidationInfoForeground, inputValidationWarningForeground, inputValidationErrorForeground, menuForeground, menuBackground, menuSelectionForeground, menuSelectionBackground, menuSelectionBorder, menuBorder, menuSeparatorBackground, darken, listFilterWidgetOutline, listFilterWidgetNoMatchesOutline, listFilterWidgetBackground, editorWidgetBackground, treeIndentGuidesStroke, editorWidgetForeground, simpleCheckboxBackground, simpleCheckboxBorder, simpleCheckboxForeground, ColorValue, resolveColorValue, textLinkForeground, problemsWarningIconForeground, problemsErrorIconForeground, problemsInfoIconForeground } from 'vs/platform/theme/common/colorRegistry';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { Color } from 'vs/base/common/color';
 import { IThemable, styleFn } from 'vs/base/common/styler';
@@ -347,6 +347,9 @@ export interface IDialogStyleOverrides extends IButtonStyleOverrides {
 	checkboxBorder?: ColorIdentifier;
 	checkboxBackground?: ColorIdentifier;
 	checkboxForeground?: ColorIdentifier;
+	errorIconForeground?: ColorIdentifier;
+	warningIconForeground?: ColorIdentifier;
+	infoIconForeground?: ColorIdentifier;
 }

 export const defaultDialogStyles = <IDialogStyleOverrides>{
@@ -360,7 +363,10 @@ export const defaultDialogStyles = <IDialogStyleOverrides>{
 	buttonBorder: contrastBorder,
 	checkboxBorder: simpleCheckboxBorder,
 	checkboxBackground: simpleCheckboxBackground,
-	checkboxForeground: simpleCheckboxForeground
+	checkboxForeground: simpleCheckboxForeground,
+	errorIconForeground: problemsErrorIconForeground,
+	warningIconForeground: problemsWarningIconForeground,
+	infoIconForeground: problemsInfoIconForeground
 };


--- a/src/vs/platform/theme/common/tokenClassificationRegistry.ts
+++ b/src/vs/platform/theme/common/tokenClassificationRegistry.ts
@@ -295,7 +295,6 @@ class TokenClassificationRegistry implements ITokenClassificationRegistry {
 						defaultSnippets: [{ label: nls.localize('schema.token.fontStyle.none', 'None (clear inherited style)'), bodyText: '""' }, { body: 'italic' }, { body: 'bold' }, { body: 'underline' }, { body: 'italic underline' }, { body: 'bold underline' }, { body: 'italic bold underline' }]
 					}
 				},
-				additionalProperties: false,
 				defaultSnippets: [{ body: { foreground: '${1:#FF0000}', fontStyle: '${2:bold}' } }]
 			}
 		}
--- a/src/vs/platform/userDataSync/common/userDataSync.ts
+++ b/src/vs/platform/userDataSync/common/userDataSync.ts
@@ -20,8 +20,9 @@ import { FormattingOptions } from 'vs/base/common/jsonFormatter';
 import { URI } from 'vs/base/common/uri';
 import { joinPath, isEqualOrParent } from 'vs/base/common/resources';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
-import { IProductService } from 'vs/platform/product/common/productService';
+import { IProductService, ConfigurationSyncStore } from 'vs/platform/product/common/productService';
 import { distinct } from 'vs/base/common/arrays';
+import { isArray, isString, isObject } from 'vs/base/common/types';

 export const CONFIGURATION_SYNC_STORE_KEY = 'configurationSync.store';

@@ -119,17 +120,33 @@ export interface IUserData {
 	content: string | null;
 }

+export type IAuthenticationProvider = { id: string, scopes: string[] };
+
 export interface IUserDataSyncStore {
 	url: URI;
-	authenticationProviderId: string;
+	authenticationProviders: IAuthenticationProvider[];
+}
+
+export function isAuthenticationProvider(thing: any): thing is IAuthenticationProvider {
+	return thing
+		&& isObject(thing)
+		&& isString(thing.id)
+		&& isArray(thing.scopes);
 }

 export function getUserDataSyncStore(productService: IProductService, configurationService: IConfigurationService): IUserDataSyncStore | undefined {
-	const value = configurationService.getValue<{ url: string, authenticationProviderId: string }>(CONFIGURATION_SYNC_STORE_KEY) || productService[CONFIGURATION_SYNC_STORE_KEY];
-	if (value && value.url && value.authenticationProviderId) {
+	const value = configurationService.getValue<ConfigurationSyncStore>(CONFIGURATION_SYNC_STORE_KEY) || productService[CONFIGURATION_SYNC_STORE_KEY];
+	if (value
+		&& isString(value.url)
+		&& isObject(value.authenticationProviders)
+		&& Object.keys(value.authenticationProviders).every(authenticationProviderId => isArray(value.authenticationProviders[authenticationProviderId].scopes))
+	) {
 		return {
 			url: joinPath(URI.parse(value.url), 'v1'),
-			authenticationProviderId: value.authenticationProviderId
+			authenticationProviders: Object.keys(value.authenticationProviders).reduce<IAuthenticationProvider[]>((result, id) => {
+				result.push({ id, scopes: value.authenticationProviders[id].scopes });
+				return result;
+			}, [])
 		};
 	}
 	return undefined;
@@ -299,6 +316,7 @@ export interface IUserDataSyncEnablementService {

 	isEnabled(): boolean;
 	setEnablement(enabled: boolean): void;
+	canToggleEnablement(): boolean;

 	isResourceEnabled(resource: SyncResource): boolean;
 	setResourceEnablement(resource: SyncResource, enabled: boolean): void;
--- a/src/vs/platform/userDataSync/common/userDataSyncEnablementService.ts
+++ b/src/vs/platform/userDataSync/common/userDataSyncEnablementService.ts
@@ -30,22 +30,24 @@ export class UserDataSyncEnablementService extends Disposable implements IUserDa
 	constructor(
 		@IStorageService private readonly storageService: IStorageService,
 		@ITelemetryService private readonly telemetryService: ITelemetryService,
-		@IEnvironmentService environmentService: IEnvironmentService,
+		@IEnvironmentService private readonly environmentService: IEnvironmentService,
 	) {
 		super();
-		switch (environmentService.sync) {
-			case 'on':
-				this.setEnablement(true);
-				break;
-			case 'off':
-				this.setEnablement(false);
-				break;
-		}
 		this._register(storageService.onDidChangeStorage(e => this.onDidStorageChange(e)));
 	}

+	canToggleEnablement(): boolean {
+		return this.environmentService.sync === undefined;
+	}
+
 	isEnabled(): boolean {
-		return this.storageService.getBoolean(enablementKey, StorageScope.GLOBAL, false);
+		switch (this.environmentService.sync) {
+			case 'on':
+				return true;
+			case 'off':
+				return false;
+		}
+		return this.storageService.getBoolean(enablementKey, StorageScope.GLOBAL, this.environmentService.enableSyncByDefault);
 	}

 	setEnablement(enabled: boolean): void {
--- a/src/vs/platform/userDataSync/common/userDataSyncStoreService.ts
+++ b/src/vs/platform/userDataSync/common/userDataSyncStoreService.ts
@@ -195,7 +195,8 @@ export class UserDataSyncStoreService extends Disposable implements IUserDataSyn

 		const commonHeaders = await this.commonHeadersPromise;
 		options.headers = assign(options.headers || {}, commonHeaders, {
-			'authorization': `Bearer ${authToken}`,
+			'X-Account-Type': authToken.authenticationProviderId,
+			'authorization': `Bearer ${authToken.token}`,
 		});

 		this.logService.trace('Sending request to server', { url: options.url, type: options.type, headers: { ...options.headers, ...{ authorization: undefined } } });
--- a/src/vs/platform/userDataSync/test/common/userDataSyncClient.ts
+++ b/src/vs/platform/userDataSync/test/common/userDataSyncClient.ts
@@ -32,7 +32,7 @@ import { InMemoryFileSystemProvider } from 'vs/platform/files/common/inMemoryFil
 import { ConfigurationService } from 'vs/platform/configuration/common/configurationService';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { Emitter } from 'vs/base/common/event';
-import { IAuthenticationTokenService } from 'vs/platform/authentication/common/authentication';
+import { IAuthenticationTokenService, IUserDataSyncAuthToken } from 'vs/platform/authentication/common/authentication';
 import product from 'vs/platform/product/common/product';
 import { IProductService } from 'vs/platform/product/common/productService';
 import { UserDataSyncBackupStoreService } from 'vs/platform/userDataSync/common/userDataSyncBackupStoreService';
@@ -65,7 +65,7 @@ export class UserDataSyncClient extends Disposable {
 			_serviceBrand: undefined, ...product, ...{
 				'configurationSync.store': {
 					url: this.testServer.url,
-					authenticationProviderId: 'test'
+					authenticationProviders: { 'test': { scopes: [] } }
 				}
 			}
 		});
@@ -82,8 +82,8 @@ export class UserDataSyncClient extends Disposable {

 		this.instantiationService.stub(IRequestService, this.testServer);
 		this.instantiationService.stub(IAuthenticationTokenService, <Partial<IAuthenticationTokenService>>{
-			onDidChangeToken: new Emitter<string | undefined>().event,
-			async getToken() { return 'token'; }
+			onDidChangeToken: new Emitter<IUserDataSyncAuthToken | undefined>().event,
+			async getToken() { return { authenticationProviderId: 'id', token: 'token' }; }
 		});

 		this.instantiationService.stub(IUserDataSyncLogService, logService);
--- a/src/vs/platform/workspace/common/workspace.ts
+++ b/src/vs/platform/workspace/common/workspace.ts
@@ -144,7 +144,7 @@ export interface IWorkspaceFolder extends IWorkspaceFolderData {

 export class Workspace implements IWorkspace {

-	private _foldersMap: TernarySearchTree<string, WorkspaceFolder> = TernarySearchTree.forPaths<WorkspaceFolder>();
+	private _foldersMap: TernarySearchTree<URI, WorkspaceFolder> = TernarySearchTree.forUris<WorkspaceFolder>();
 	private _folders!: WorkspaceFolder[];

 	constructor(
@@ -191,13 +191,13 @@ export class Workspace implements IWorkspace {
 			scheme: resource.scheme,
 			authority: resource.authority,
 			path: resource.path
-		}).toString()) || null;
+		})) || null;
 	}

 	private updateFoldersMap(): void {
-		this._foldersMap = TernarySearchTree.forPaths<WorkspaceFolder>();
+		this._foldersMap = TernarySearchTree.forUris<WorkspaceFolder>();
 		for (const folder of this.folders) {
-			this._foldersMap.set(folder.uri.toString(), folder);
+			this._foldersMap.set(folder.uri, folder);
 		}
 	}