Merge remote-tracking branch 'origin/master' into tyriar/conpty

2026-04-24 10:38:59 +01:00 · 2018-12-21 10:49:44 -08:00
parent 58f6dc5185 c8b7d5d91e
commit dceb815558
273 changed files with 3777 additions and 2905 deletions
--- a/src/vs/workbench/api/node/extHost.api.impl.ts
+++ b/src/vs/workbench/api/node/extHost.api.impl.ts
@@ -63,6 +63,7 @@ import { IExtensionDescription, throwProposedApiError, checkProposedApiEnabled,
 import { ProxyIdentifier } from 'vs/workbench/services/extensions/node/proxyIdentifier';
 import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/node/extensionDescriptionRegistry';
 import * as vscode from 'vscode';
+import { CanonicalExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

 export interface IExtensionApiFactory {
 	(extension: IExtensionDescription, registry: ExtensionDescriptionRegistry): typeof vscode;
@@ -152,7 +153,7 @@ export function createApiFactory(
 			let done = (!extension.isUnderDevelopment);
 			function informOnce(selector: vscode.DocumentSelector) {
 				if (!done) {
-					console.info(`Extension '${extension.id}' uses a document selector without scheme. Learn more about this: https://go.microsoft.com/fwlink/?linkid=872305`);
+					console.info(`Extension '${extension.identifier.value}' uses a document selector without scheme. Learn more about this: https://go.microsoft.com/fwlink/?linkid=872305`);
 					done = true;
 				}
 			}
@@ -180,7 +181,7 @@ export function createApiFactory(
 			const informOnce = () => {
 				if (!done) {
 					done = true;
-					console.warn(`Extension '${extension.id}' uses the 'vscode.previewHtml' command which is deprecated and will be removed. Please update your extension to use the Webview API: https://go.microsoft.com/fwlink/?linkid=2039309`);
+					console.warn(`Extension '${extension.identifier.value}' uses the 'vscode.previewHtml' command which is deprecated and will be removed. Please update your extension to use the Webview API: https://go.microsoft.com/fwlink/?linkid=2039309`);
 				}
 			};
 			return (commandId: string) => {
@@ -310,7 +311,7 @@ export function createApiFactory(
 				return extHostLanguageFeatures.registerTypeDefinitionProvider(extension, checkSelector(selector), provider);
 			},
 			registerHoverProvider(selector: vscode.DocumentSelector, provider: vscode.HoverProvider): vscode.Disposable {
-				return extHostLanguageFeatures.registerHoverProvider(extension, checkSelector(selector), provider, extension.id);
+				return extHostLanguageFeatures.registerHoverProvider(extension, checkSelector(selector), provider, extension.identifier);
 			},
 			registerDocumentHighlightProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentHighlightProvider): vscode.Disposable {
 				return extHostLanguageFeatures.registerDocumentHighlightProvider(extension, checkSelector(selector), provider);
@@ -448,7 +449,7 @@ export function createApiFactory(
 				return extHostDialogs.showSaveDialog(options);
 			},
 			createStatusBarItem(position?: vscode.StatusBarAlignment, priority?: number): vscode.StatusBarItem {
-				return extHostStatusBar.createStatusBarEntry(extension.id, <number>position, priority);
+				return extHostStatusBar.createStatusBarEntry(extension.identifier, <number>position, priority);
 			},
 			setStatusBarMessage(text: string, timeoutOrThenable?: number | Thenable<any>): vscode.Disposable {
 				return extHostStatusBar.setStatusBarMessage(text, timeoutOrThenable);
@@ -485,16 +486,16 @@ export function createApiFactory(
 				return extHostWebviews.registerWebviewPanelSerializer(viewType, serializer);
 			},
 			registerDecorationProvider: proposedApiFunction(extension, (provider: vscode.DecorationProvider) => {
-				return extHostDecorations.registerDecorationProvider(provider, extension.id);
+				return extHostDecorations.registerDecorationProvider(provider, extension.identifier);
 			}),
 			registerUriHandler(handler: vscode.UriHandler) {
-				return extHostUrls.registerUriHandler(extension.id, handler);
+				return extHostUrls.registerUriHandler(extension.identifier, handler);
 			},
 			createQuickPick<T extends vscode.QuickPickItem>(): vscode.QuickPick<T> {
-				return extHostQuickOpen.createQuickPick(extension.id, extension.enableProposedApi);
+				return extHostQuickOpen.createQuickPick(extension.identifier, extension.enableProposedApi);
 			},
 			createInputBox(): vscode.InputBox {
-				return extHostQuickOpen.createInputBox(extension.id);
+				return extHostQuickOpen.createInputBox(extension.identifier);
 			},
 		};

@@ -528,7 +529,7 @@ export function createApiFactory(
 				return extHostWorkspace.getRelativePath(pathOrUri, includeWorkspace);
 			},
 			findFiles: (include, exclude, maxResults?, token?) => {
-				return extHostWorkspace.findFiles(typeConverters.GlobPattern.from(include), typeConverters.GlobPattern.from(exclude), maxResults, extension.id, token);
+				return extHostWorkspace.findFiles(typeConverters.GlobPattern.from(include), typeConverters.GlobPattern.from(exclude), maxResults, extension.identifier, token);
 			},
 			findTextInFiles: (query: vscode.TextSearchQuery, optionsOrCallback, callbackOrToken?, token?: vscode.CancellationToken) => {
 				let options: vscode.FindTextInFilesOptions;
@@ -543,7 +544,7 @@ export function createApiFactory(
 					token = callbackOrToken;
 				}

-				return extHostWorkspace.findTextInFiles(query, options || {}, callback, extension.id, token);
+				return extHostWorkspace.findTextInFiles(query, options || {}, callback, extension.identifier, token);
 			},
 			saveAll: (includeUntitled?) => {
 				return extHostWorkspace.saveAll(includeUntitled);
@@ -601,7 +602,7 @@ export function createApiFactory(
 			},
 			getConfiguration(section?: string, resource?: vscode.Uri): vscode.WorkspaceConfiguration {
 				resource = arguments.length === 1 ? void 0 : resource;
-				return extHostConfiguration.getConfiguration(section, resource, extension.id);
+				return extHostConfiguration.getConfiguration(section, resource, extension.identifier);
 			},
 			registerTextDocumentContentProvider(scheme: string, provider: vscode.TextDocumentContentProvider) {
 				return extHostDocumentContentProviders.registerTextDocumentContentProvider(scheme, provider);
@@ -629,7 +630,7 @@ export function createApiFactory(
 				return exthostCommentProviders.registerDocumentCommentProvider(provider);
 			}),
 			registerWorkspaceCommentProvider: proposedApiFunction(extension, (provider: vscode.WorkspaceCommentProvider) => {
-				return exthostCommentProviders.registerWorkspaceCommentProvider(extension.id, provider);
+				return exthostCommentProviders.registerWorkspaceCommentProvider(extension.identifier, provider);
 			}),
 			onDidRenameFile: proposedApiFunction(extension, (listener, thisArg?, disposables?) => {
 				return extHostFileSystemEvent.onDidRenameFile(listener, thisArg, disposables);
@@ -837,6 +838,7 @@ export function originalFSPath(uri: URI): string {
 class Extension<T> implements vscode.Extension<T> {

 	private _extensionService: ExtHostExtensionService;
+	private _identifier: CanonicalExtensionIdentifier;

 	public id: string;
 	public extensionPath: string;
@@ -844,21 +846,22 @@ class Extension<T> implements vscode.Extension<T> {

 	constructor(extensionService: ExtHostExtensionService, description: IExtensionDescription) {
 		this._extensionService = extensionService;
-		this.id = description.id;
+		this._identifier = description.identifier;
+		this.id = description.identifier.value;
 		this.extensionPath = paths.normalize(originalFSPath(description.extensionLocation), true);
 		this.packageJSON = description;
 	}

 	get isActive(): boolean {
-		return this._extensionService.isActivated(this.id);
+		return this._extensionService.isActivated(this._identifier);
 	}

 	get exports(): T {
-		return <T>this._extensionService.getExtensionExports(this.id);
+		return <T>this._extensionService.getExtensionExports(this._identifier);
 	}

 	activate(): Thenable<T> {
-		return this._extensionService.activateByIdWithErrors(this.id, new ExtensionActivatedByAPI(false)).then(() => this.exports);
+		return this._extensionService.activateByIdWithErrors(this._identifier, new ExtensionActivatedByAPI(false)).then(() => this.exports);
 	}
 }

@@ -882,10 +885,10 @@ function defineAPI(factory: IExtensionApiFactory, extensionPaths: TernarySearchT
 		// get extension id from filename and api for extension
 		const ext = extensionPaths.findSubstr(URI.file(parent.filename).fsPath);
 		if (ext) {
-			let apiImpl = extApiImpl.get(ext.id);
+			let apiImpl = extApiImpl.get(CanonicalExtensionIdentifier.toKey(ext.identifier));
 			if (!apiImpl) {
 				apiImpl = factory(ext, extensionRegistry);
-				extApiImpl.set(ext.id, apiImpl);
+				extApiImpl.set(CanonicalExtensionIdentifier.toKey(ext.identifier), apiImpl);
 			}
 			return apiImpl;
 		}
@@ -893,7 +896,7 @@ function defineAPI(factory: IExtensionApiFactory, extensionPaths: TernarySearchT
 		// fall back to a default implementation
 		if (!defaultApiImpl) {
 			let extensionPathsPretty = '';
-			extensionPaths.forEach((value, index) => extensionPathsPretty += `\t${index} -> ${value.id}\n`);
+			extensionPaths.forEach((value, index) => extensionPathsPretty += `\t${index} -> ${value.identifier.value}\n`);
 			console.warn(`Could not identify extension for 'vscode' require call from ${parent.filename}. These are the extension path mappings: \n${extensionPathsPretty}`);
 			defaultApiImpl = factory(nullExtensionDescription, extensionRegistry);
 		}
--- a/src/vs/workbench/api/node/extHost.protocol.ts
+++ b/src/vs/workbench/api/node/extHost.protocol.ts
@@ -43,6 +43,7 @@ import { SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
 import * as vscode from 'vscode';
 import { IMarkdownString } from 'vs/base/common/htmlContent';
 import { ResolvedAuthority } from 'vs/platform/remote/common/remoteAuthorityResolver';
+import { CanonicalExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

 export interface IEnvironment {
 	isExtensionDevelopmentDebug: boolean;
@@ -113,7 +114,7 @@ export interface CommentProviderFeatures {
 export interface MainThreadCommentsShape extends IDisposable {
 	$registerDocumentCommentProvider(handle: number, features: CommentProviderFeatures): void;
 	$unregisterDocumentCommentProvider(handle: number): void;
-	$registerWorkspaceCommentProvider(handle: number, extensionId: string): void;
+	$registerWorkspaceCommentProvider(handle: number, extensionId: CanonicalExtensionIdentifier): void;
 	$unregisterWorkspaceCommentProvider(handle: number): void;
 	$onDidCommentThreadsChange(handle: number, event: modes.CommentThreadChangedEvent): void;
 }
@@ -439,7 +440,7 @@ export interface MainThreadQuickOpenShape extends IDisposable {
 }

 export interface MainThreadStatusBarShape extends IDisposable {
-	$setEntry(id: number, extensionId: string, text: string, tooltip: string, command: string, color: string | ThemeColor, alignment: MainThreadStatusBarAlignment, priority: number): void;
+	$setEntry(id: number, extensionId: CanonicalExtensionIdentifier, text: string, tooltip: string, command: string, color: string | ThemeColor, alignment: MainThreadStatusBarAlignment, priority: number): void;
 	$dispose(id: number): void;
 }

@@ -460,7 +461,7 @@ export interface WebviewPanelShowOptions {
 }

 export interface MainThreadWebviewsShape extends IDisposable {
-	$createWebviewPanel(handle: WebviewPanelHandle, viewType: string, title: string, showOptions: WebviewPanelShowOptions, options: vscode.WebviewPanelOptions & vscode.WebviewOptions, extensionId: string, extensionLocation: UriComponents): void;
+	$createWebviewPanel(handle: WebviewPanelHandle, viewType: string, title: string, showOptions: WebviewPanelShowOptions, options: vscode.WebviewPanelOptions & vscode.WebviewOptions, extensionId: CanonicalExtensionIdentifier, extensionLocation: UriComponents): void;
 	$disposeWebview(handle: WebviewPanelHandle): void;
 	$reveal(handle: WebviewPanelHandle, showOptions: WebviewPanelShowOptions): void;
 	$setTitle(handle: WebviewPanelHandle, value: string): void;
@@ -487,7 +488,7 @@ export interface ExtHostWebviewsShape {
 }

 export interface MainThreadUrlsShape extends IDisposable {
-	$registerUriHandler(handle: number, extensionId: string): Promise<void>;
+	$registerUriHandler(handle: number, extensionId: CanonicalExtensionIdentifier): Promise<void>;
 	$unregisterUriHandler(handle: number): Promise<void>;
 }

@@ -537,11 +538,11 @@ export interface MainThreadTaskShape extends IDisposable {

 export interface MainThreadExtensionServiceShape extends IDisposable {
 	$localShowMessage(severity: Severity, msg: string): void;
-	$onWillActivateExtension(extensionId: string): void;
-	$onDidActivateExtension(extensionId: string, startup: boolean, codeLoadingTime: number, activateCallTime: number, activateResolvedTime: number, activationEvent: string): void;
-	$onExtensionActivationFailed(extensionId: string): void;
-	$onExtensionRuntimeError(extensionId: string, error: SerializedError): void;
-	$addMessage(extensionId: string, severity: Severity, message: string): void;
+	$onWillActivateExtension(extensionId: CanonicalExtensionIdentifier): void;
+	$onDidActivateExtension(extensionId: CanonicalExtensionIdentifier, startup: boolean, codeLoadingTime: number, activateCallTime: number, activateResolvedTime: number, activationEvent: string): void;
+	$onExtensionActivationFailed(extensionId: CanonicalExtensionIdentifier): void;
+	$onExtensionRuntimeError(extensionId: CanonicalExtensionIdentifier, error: SerializedError): void;
+	$addMessage(extensionId: CanonicalExtensionIdentifier, severity: Severity, message: string): void;
 }

 export interface SCMProviderFeatures {
@@ -736,7 +737,7 @@ export interface ExtHostSearchShape {

 export interface ExtHostExtensionServiceShape {
 	$resolveAuthority(remoteAuthority: string): Promise<ResolvedAuthority>;
-	$startExtensionHost(enabledExtensionIds: string[]): Promise<void>;
+	$startExtensionHost(enabledExtensionIds: CanonicalExtensionIdentifier[]): Promise<void>;
 	$activateByEvent(activationEvent: string): Promise<void>;
 }

--- a/src/vs/workbench/api/node/extHostComments.ts
+++ b/src/vs/workbench/api/node/extHostComments.ts
@@ -13,6 +13,7 @@ import { ExtHostCommentsShape, IMainContext, MainContext, MainThreadCommentsShap
 import { CommandsConverter } from './extHostCommands';
 import { IRange } from 'vs/editor/common/core/range';
 import { CancellationToken } from 'vs/base/common/cancellation';
+import { CanonicalExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

 export class ExtHostComments implements ExtHostCommentsShape {
 	private static handlePool = 0;
@@ -31,7 +32,7 @@ export class ExtHostComments implements ExtHostCommentsShape {
 	}

 	registerWorkspaceCommentProvider(
-		extensionId: string,
+		extensionId: CanonicalExtensionIdentifier,
 		provider: vscode.WorkspaceCommentProvider
 	): vscode.Disposable {
 		const handle = ExtHostComments.handlePool++;
--- a/src/vs/workbench/api/node/extHostConfiguration.ts
+++ b/src/vs/workbench/api/node/extHostConfiguration.ts
@@ -16,6 +16,7 @@ import { WorkspaceConfigurationChangeEvent } from 'vs/workbench/services/configu
 import { ResourceMap } from 'vs/base/common/map';
 import { ConfigurationScope, OVERRIDE_PROPERTY_PATTERN } from 'vs/platform/configuration/common/configurationRegistry';
 import { isObject } from 'vs/base/common/types';
+import { CanonicalExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

 function lookUp(tree: any, key: string) {
 	if (key) {
@@ -60,7 +61,7 @@ export class ExtHostConfiguration implements ExtHostConfigurationShape {
 		this._onDidChangeConfiguration.fire(this._toConfigurationChangeEvent(eventData));
 	}

-	getConfiguration(section?: string, resource?: URI, extensionId?: string): vscode.WorkspaceConfiguration {
+	getConfiguration(section?: string, resource?: URI, extensionId?: CanonicalExtensionIdentifier): vscode.WorkspaceConfiguration {
 		const config = this._toReadonlyValue(section
 			? lookUp(this._configuration.getValue(null, { resource }, this._extHostWorkspace.workspace), section)
 			: this._configuration.getValue(null, { resource }, this._extHostWorkspace.workspace));
@@ -187,9 +188,9 @@ export class ExtHostConfiguration implements ExtHostConfigurationShape {
 		return readonlyProxy(result);
 	}

-	private _validateConfigurationAccess(key: string, resource: URI, extensionId: string): void {
+	private _validateConfigurationAccess(key: string, resource: URI, extensionId: CanonicalExtensionIdentifier): void {
 		const scope = OVERRIDE_PROPERTY_PATTERN.test(key) ? ConfigurationScope.RESOURCE : this._configurationScopes[key];
-		const extensionIdText = extensionId ? `[${extensionId}] ` : '';
+		const extensionIdText = extensionId ? `[${extensionId.value}] ` : '';
 		if (ConfigurationScope.RESOURCE === scope) {
 			if (resource === void 0) {
 				console.warn(`${extensionIdText}Accessing a resource scoped configuration without providing a resource is not expected. To get the effective value for '${key}', provide the URI of a resource or 'null' for any resource.`);
--- a/src/vs/workbench/api/node/extHostDebugService.ts
+++ b/src/vs/workbench/api/node/extHostDebugService.ts
@@ -128,8 +128,8 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 					const debuggers = <IDebuggerContribution[]>ed.contributes['debuggers'];
 					if (debuggers && debuggers.length > 0) {
 						for (const dbg of debuggers) {
-							// only debugger contributions with a "label" are considered a "defining" debugger contribution
-							if (dbg.type && dbg.label) {
+							// only debugger contributions with a label, program, or runtime attribute are considered a "defining" debugger contribution
+							if (dbg.type && (dbg.label || dbg.program || dbg.runtime)) {
 								debugTypes.push(dbg.type);
 								if (dbg.adapterExecutableCommand) {
 									this._aexCommands.set(dbg.type, dbg.adapterExecutableCommand);
--- a/src/vs/workbench/api/node/extHostDecorations.ts
+++ b/src/vs/workbench/api/node/extHostDecorations.ts
@@ -8,10 +8,11 @@ import { URI } from 'vs/base/common/uri';
 import { MainContext, IMainContext, ExtHostDecorationsShape, MainThreadDecorationsShape, DecorationData, DecorationRequest, DecorationReply } from 'vs/workbench/api/node/extHost.protocol';
 import { Disposable } from 'vs/workbench/api/node/extHostTypes';
 import { CancellationToken } from 'vs/base/common/cancellation';
+import { CanonicalExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

 interface ProviderData {
 	provider: vscode.DecorationProvider;
-	extensionId: string;
+	extensionId: CanonicalExtensionIdentifier;
 }

 export class ExtHostDecorations implements ExtHostDecorationsShape {
@@ -25,10 +26,10 @@ export class ExtHostDecorations implements ExtHostDecorationsShape {
 		this._proxy = mainContext.getProxy(MainContext.MainThreadDecorations);
 	}

-	registerDecorationProvider(provider: vscode.DecorationProvider, extensionId: string): vscode.Disposable {
+	registerDecorationProvider(provider: vscode.DecorationProvider, extensionId: CanonicalExtensionIdentifier): vscode.Disposable {
 		const handle = ExtHostDecorations._handlePool++;
 		this._provider.set(handle, { provider, extensionId });
-		this._proxy.$registerDecorationProvider(handle, extensionId);
+		this._proxy.$registerDecorationProvider(handle, extensionId.value);

 		const listener = provider.onDidChangeDecorations(e => {
 			this._proxy.$onDidChange(handle, !e ? null : Array.isArray(e) ? e : [e]);
@@ -52,7 +53,7 @@ export class ExtHostDecorations implements ExtHostDecorationsShape {
 			const { provider, extensionId } = this._provider.get(handle);
 			return Promise.resolve(provider.provideDecoration(URI.revive(uri), token)).then(data => {
 				if (data && data.letter && data.letter.length !== 1) {
-					console.warn(`INVALID decoration from extension '${extensionId}'. The 'letter' must be set and be one character, not '${data.letter}'.`);
+					console.warn(`INVALID decoration from extension '${extensionId.value}'. The 'letter' must be set and be one character, not '${data.letter}'.`);
 				}
 				result[id] = data && <DecorationData>[data.priority, data.bubble, data.title, data.letter, data.color, data.source];
 			}, err => {
--- a/src/vs/workbench/api/node/extHostDocumentSaveParticipant.ts
+++ b/src/vs/workbench/api/node/extHostDocumentSaveParticipant.ts
@@ -83,7 +83,7 @@ export class ExtHostDocumentSaveParticipant implements ExtHostDocumentSavePartic

 		}, err => {

-			this._logService.error(`onWillSaveTextDocument-listener from extension '${extension.id}' threw ERROR`);
+			this._logService.error(`onWillSaveTextDocument-listener from extension '${extension.identifier.value}' threw ERROR`);
 			this._logService.error(err);

 			if (!(err instanceof Error) || (<Error>err).message !== 'concurrent_edits') {
@@ -91,7 +91,7 @@ export class ExtHostDocumentSaveParticipant implements ExtHostDocumentSavePartic
 				this._badListeners.set(listener, !errors ? 1 : errors + 1);

 				if (errors > this._thresholds.errors) {
-					this._logService.info(`onWillSaveTextDocument-listener from extension '${extension.id}' will now be IGNORED because of timeouts and/or errors`);
+					this._logService.info(`onWillSaveTextDocument-listener from extension '${extension.identifier.value}' will now be IGNORED because of timeouts and/or errors`);
 				}
 			}
 			return false;
@@ -132,7 +132,7 @@ export class ExtHostDocumentSaveParticipant implements ExtHostDocumentSavePartic
 			const handle = setTimeout(() => reject(new Error('timeout')), this._thresholds.timeout);

 			return Promise.all(promises).then(edits => {
-				this._logService.debug(`onWillSaveTextDocument-listener from extension '${extension.id}' finished after ${(Date.now() - t1)}ms`);
+				this._logService.debug(`onWillSaveTextDocument-listener from extension '${extension.identifier.value}' finished after ${(Date.now() - t1)}ms`);
 				clearTimeout(handle);
 				resolve(edits);
 			}).catch(err => {
--- a/src/vs/workbench/api/node/extHostExtensionActivator.ts
+++ b/src/vs/workbench/api/node/extHostExtensionActivator.ts
@@ -8,8 +8,8 @@ import { IDisposable } from 'vs/base/common/lifecycle';
 import Severity from 'vs/base/common/severity';
 import { IExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
 import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/node/extensionDescriptionRegistry';
+import { CanonicalExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

-const hasOwnProperty = Object.hasOwnProperty;
 const NO_OP_VOID_PROMISE = Promise.resolve<void>(void 0);

 export interface IExtensionMemento {
@@ -192,8 +192,8 @@ export class ExtensionsActivator {

 	private readonly _registry: ExtensionDescriptionRegistry;
 	private readonly _host: IExtensionsActivatorHost;
-	private readonly _activatingExtensions: { [extensionId: string]: Promise<void>; };
-	private readonly _activatedExtensions: { [extensionId: string]: ActivatedExtension; };
+	private readonly _activatingExtensions: Map<string, Promise<void>>;
+	private readonly _activatedExtensions: Map<string, ActivatedExtension>;
 	/**
 	 * A map of already activated events to speed things up if the same activation event is triggered multiple times.
 	 */
@@ -202,20 +202,24 @@ export class ExtensionsActivator {
 	constructor(registry: ExtensionDescriptionRegistry, host: IExtensionsActivatorHost) {
 		this._registry = registry;
 		this._host = host;
-		this._activatingExtensions = {};
-		this._activatedExtensions = {};
+		this._activatingExtensions = new Map<string, Promise<void>>();
+		this._activatedExtensions = new Map<string, ActivatedExtension>();
 		this._alreadyActivatedEvents = Object.create(null);
 	}

-	public isActivated(extensionId: string): boolean {
-		return hasOwnProperty.call(this._activatedExtensions, extensionId);
+	public isActivated(extensionId: CanonicalExtensionIdentifier): boolean {
+		const extensionKey = CanonicalExtensionIdentifier.toKey(extensionId);
+
+		return this._activatedExtensions.has(extensionKey);
 	}

-	public getActivatedExtension(extensionId: string): ActivatedExtension {
-		if (!hasOwnProperty.call(this._activatedExtensions, extensionId)) {
-			throw new Error('Extension `' + extensionId + '` is not known or not activated');
+	public getActivatedExtension(extensionId: CanonicalExtensionIdentifier): ActivatedExtension {
+		const extensionKey = CanonicalExtensionIdentifier.toKey(extensionId);
+
+		if (!this._activatedExtensions.has(extensionKey)) {
+			throw new Error('Extension `' + extensionId.value + '` is not known or not activated');
 		}
-		return this._activatedExtensions[extensionId];
+		return this._activatedExtensions.get(extensionKey);
 	}

 	public activateByEvent(activationEvent: string, reason: ExtensionActivationReason): Promise<void> {
@@ -228,7 +232,7 @@ export class ExtensionsActivator {
 		});
 	}

-	public activateById(extensionId: string, reason: ExtensionActivationReason): Promise<void> {
+	public activateById(extensionId: CanonicalExtensionIdentifier, reason: ExtensionActivationReason): Promise<void> {
 		let desc = this._registry.getExtensionDescription(extensionId);
 		if (!desc) {
 			throw new Error('Extension `' + extensionId + '` is not known');
@@ -251,31 +255,31 @@ export class ExtensionsActivator {

 			if (!depDesc) {
 				// Error condition 1: unknown dependency
-				this._host.showMessage(Severity.Error, nls.localize('unknownDep', "Cannot activate extension '{0}' as the depending extension '{1}' is not found. Please install or enable the depending extension and reload the window.", currentExtension.displayName || currentExtension.id, depId));
+				this._host.showMessage(Severity.Error, nls.localize('unknownDep', "Cannot activate extension '{0}' as the depending extension '{1}' is not found. Please install or enable the depending extension and reload the window.", currentExtension.displayName || currentExtension.identifier.value, depId));
 				const error = new Error(`Unknown dependency '${depId}'`);
-				this._activatedExtensions[currentExtension.id] = new FailedExtension(error);
+				this._activatedExtensions.set(CanonicalExtensionIdentifier.toKey(currentExtension.identifier), new FailedExtension(error));
 				return;
 			}

-			if (hasOwnProperty.call(this._activatedExtensions, depId)) {
-				let dep = this._activatedExtensions[depId];
+			if (this._activatedExtensions.has(CanonicalExtensionIdentifier.toKey(depId))) {
+				let dep = this._activatedExtensions.get(CanonicalExtensionIdentifier.toKey(depId));
 				if (dep.activationFailed) {
 					// Error condition 2: a dependency has already failed activation
-					this._host.showMessage(Severity.Error, nls.localize('failedDep1', "Cannot activate extension '{0}' as the depending extension '{1}' is failed to activate.", currentExtension.displayName || currentExtension.id, depId));
+					this._host.showMessage(Severity.Error, nls.localize('failedDep1', "Cannot activate extension '{0}' as the depending extension '{1}' is failed to activate.", currentExtension.displayName || currentExtension.identifier.value, depId));
 					const error = new Error(`Dependency ${depId} failed to activate`);
 					(<any>error).detail = dep.activationFailedError;
-					this._activatedExtensions[currentExtension.id] = new FailedExtension(error);
+					this._activatedExtensions.set(CanonicalExtensionIdentifier.toKey(currentExtension.identifier), new FailedExtension(error));
 					return;
 				}
 			} else {
 				// must first wait for the dependency to activate
 				currentExtensionGetsGreenLight = false;
-				greenExtensions[depId] = depDesc;
+				greenExtensions[CanonicalExtensionIdentifier.toKey(depId)] = depDesc;
 			}
 		}

 		if (currentExtensionGetsGreenLight) {
-			greenExtensions[currentExtension.id] = currentExtension;
+			greenExtensions[CanonicalExtensionIdentifier.toKey(currentExtension.identifier)] = currentExtension;
 		} else {
 			redExtensions.push(currentExtension);
 		}
@@ -287,7 +291,7 @@ export class ExtensionsActivator {
 			return Promise.resolve(void 0);
 		}

-		extensionDescriptions = extensionDescriptions.filter((p) => !hasOwnProperty.call(this._activatedExtensions, p.id));
+		extensionDescriptions = extensionDescriptions.filter((p) => !this._activatedExtensions.has(CanonicalExtensionIdentifier.toKey(p.identifier)));
 		if (extensionDescriptions.length === 0) {
 			return Promise.resolve(void 0);
 		}
@@ -296,9 +300,9 @@ export class ExtensionsActivator {
 			// More than 10 dependencies deep => most likely a dependency loop
 			for (let i = 0, len = extensionDescriptions.length; i < len; i++) {
 				// Error condition 3: dependency loop
-				this._host.showMessage(Severity.Error, nls.localize('failedDep2', "Extension '{0}' failed to activate. Reason: more than 10 levels of dependencies (most likely a dependency loop).", extensionDescriptions[i].id));
+				this._host.showMessage(Severity.Error, nls.localize('failedDep2', "Extension '{0}' failed to activate. Reason: more than 10 levels of dependencies (most likely a dependency loop).", extensionDescriptions[i].identifier.value));
 				const error = new Error('More than 10 levels of dependencies (most likely a dependency loop)');
-				this._activatedExtensions[extensionDescriptions[i].id] = new FailedExtension(error);
+				this._activatedExtensions.set(CanonicalExtensionIdentifier.toKey(extensionDescriptions[i].identifier), new FailedExtension(error));
 			}
 			return Promise.resolve(void 0);
 		}
@@ -312,8 +316,9 @@ export class ExtensionsActivator {

 		// Make sure no red is also green
 		for (let i = 0, len = red.length; i < len; i++) {
-			if (greenMap[red[i].id]) {
-				delete greenMap[red[i].id];
+			const redExtensionKey = CanonicalExtensionIdentifier.toKey(red[i].identifier);
+			if (greenMap[redExtensionKey]) {
+				delete greenMap[redExtensionKey];
 			}
 		}

@@ -333,25 +338,27 @@ export class ExtensionsActivator {
 	}

 	private _activateExtension(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): Promise<void> {
-		if (hasOwnProperty.call(this._activatedExtensions, extensionDescription.id)) {
+		const extensionKey = CanonicalExtensionIdentifier.toKey(extensionDescription.identifier);
+
+		if (this._activatedExtensions.has(extensionKey)) {
 			return Promise.resolve(void 0);
 		}

-		if (hasOwnProperty.call(this._activatingExtensions, extensionDescription.id)) {
-			return this._activatingExtensions[extensionDescription.id];
+		if (this._activatingExtensions.has(extensionKey)) {
+			return this._activatingExtensions.get(extensionKey);
 		}

-		this._activatingExtensions[extensionDescription.id] = this._host.actualActivateExtension(extensionDescription, reason).then(void 0, (err) => {
-			this._host.showMessage(Severity.Error, nls.localize('activationError', "Activating extension '{0}' failed: {1}.", extensionDescription.id, err.message));
-			console.error('Activating extension `' + extensionDescription.id + '` failed: ', err.message);
+		this._activatingExtensions.set(extensionKey, this._host.actualActivateExtension(extensionDescription, reason).then(void 0, (err) => {
+			this._host.showMessage(Severity.Error, nls.localize('activationError', "Activating extension '{0}' failed: {1}.", extensionDescription.identifier.value, err.message));
+			console.error('Activating extension `' + extensionDescription.identifier.value + '` failed: ', err.message);
 			console.log('Here is the error stack: ', err.stack);
 			// Treat the extension as being empty
 			return new FailedExtension(err);
 		}).then((x: ActivatedExtension) => {
-			this._activatedExtensions[extensionDescription.id] = x;
-			delete this._activatingExtensions[extensionDescription.id];
-		});
+			this._activatedExtensions.set(extensionKey, x);
+			this._activatingExtensions.delete(extensionKey);
+		}));

-		return this._activatingExtensions[extensionDescription.id];
+		return this._activatingExtensions.get(extensionKey);
 	}
 }
--- a/src/vs/workbench/api/node/extHostExtensionService.ts
+++ b/src/vs/workbench/api/node/extHostExtensionService.ts
@@ -25,6 +25,7 @@ import { connectProxyResolver } from 'vs/workbench/node/proxyResolver';
 import { CancellationTokenSource } from 'vs/base/common/cancellation';
 import * as errors from 'vs/base/common/errors';
 import { ResolvedAuthority } from 'vs/platform/remote/common/remoteAuthorityResolver';
+import { CanonicalExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

 class ExtensionMemento implements IExtensionMemento {

@@ -97,13 +98,13 @@ class ExtensionStoragePath {

 	workspaceValue(extension: IExtensionDescription): string {
 		if (this._value) {
-			return path.join(this._value, extension.id);
+			return path.join(this._value, extension.identifier.value);
 		}
 		return undefined;
 	}

 	globalValue(extension: IExtensionDescription): string {
-		return path.join(this._environment.globalStorageHome.fsPath, extension.id);
+		return path.join(this._environment.globalStorageHome.fsPath, extension.identifier.value);
 	}

 	private async _getOrCreateWorkspaceStoragePath(): Promise<string> {
@@ -234,7 +235,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		let allPromises: Promise<void>[] = [];
 		try {
 			const allExtensions = this._registry.getAllExtensionDescriptions();
-			const allExtensionsIds = allExtensions.map(ext => ext.id);
+			const allExtensionsIds = allExtensions.map(ext => ext.identifier);
 			const activatedExtensions = allExtensionsIds.filter(id => this.isActivated(id));

 			allPromises = activatedExtensions.map((extensionId) => {
@@ -246,7 +247,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		await allPromises;
 	}

-	public isActivated(extensionId: string): boolean {
+	public isActivated(extensionId: CanonicalExtensionIdentifier): boolean {
 		if (this._barrier.isOpen()) {
 			return this._activator.isActivated(extensionId);
 		}
@@ -258,11 +259,11 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		return this._activator.activateByEvent(activationEvent, reason);
 	}

-	private _activateById(extensionId: string, reason: ExtensionActivationReason): Promise<void> {
+	private _activateById(extensionId: CanonicalExtensionIdentifier, reason: ExtensionActivationReason): Promise<void> {
 		return this._activator.activateById(extensionId, reason);
 	}

-	public activateByIdWithErrors(extensionId: string, reason: ExtensionActivationReason): Promise<void> {
+	public activateByIdWithErrors(extensionId: CanonicalExtensionIdentifier, reason: ExtensionActivationReason): Promise<void> {
 		return this._activateById(extensionId, reason).then(() => {
 			const extension = this._activator.getActivatedExtension(extensionId);
 			if (extension.activationFailed) {
@@ -277,7 +278,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		return this._barrier.wait().then(_ => this._registry);
 	}

-	public getExtensionExports(extensionId: string): IExtensionAPI {
+	public getExtensionExports(extensionId: CanonicalExtensionIdentifier): IExtensionAPI {
 		if (this._barrier.isOpen()) {
 			return this._activator.getActivatedExtension(extensionId).exports;
 		} else {
@@ -300,7 +301,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		return this._extensionPathIndex;
 	}

-	private _deactivate(extensionId: string): Promise<void> {
+	private _deactivate(extensionId: CanonicalExtensionIdentifier): Promise<void> {
 		let result = Promise.resolve(void 0);

 		if (!this._barrier.isOpen()) {
@@ -338,22 +339,22 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		return result;
 	}

-	public addMessage(extensionId: string, severity: Severity, message: string): void {
+	public addMessage(extensionId: CanonicalExtensionIdentifier, severity: Severity, message: string): void {
 		this._mainThreadExtensionsProxy.$addMessage(extensionId, severity, message);
 	}

 	// --- impl

 	private _activateExtension(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): Promise<ActivatedExtension> {
-		this._mainThreadExtensionsProxy.$onWillActivateExtension(extensionDescription.id);
+		this._mainThreadExtensionsProxy.$onWillActivateExtension(extensionDescription.identifier);
 		return this._doActivateExtension(extensionDescription, reason).then((activatedExtension) => {
 			const activationTimes = activatedExtension.activationTimes;
 			let activationEvent = (reason instanceof ExtensionActivatedByEvent ? reason.activationEvent : null);
-			this._mainThreadExtensionsProxy.$onDidActivateExtension(extensionDescription.id, activationTimes.startup, activationTimes.codeLoadingTime, activationTimes.activateCallTime, activationTimes.activateResolvedTime, activationEvent);
+			this._mainThreadExtensionsProxy.$onDidActivateExtension(extensionDescription.identifier, activationTimes.startup, activationTimes.codeLoadingTime, activationTimes.activateCallTime, activationTimes.activateResolvedTime, activationEvent);
 			this._logExtensionActivationTimes(extensionDescription, reason, 'success', activationTimes);
 			return activatedExtension;
 		}, (err) => {
-			this._mainThreadExtensionsProxy.$onExtensionActivationFailed(extensionDescription.id);
+			this._mainThreadExtensionsProxy.$onExtensionActivationFailed(extensionDescription.identifier);
 			this._logExtensionActivationTimes(extensionDescription, reason, 'failure');
 			throw err;
 		});
@@ -392,23 +393,23 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 			return Promise.resolve(new EmptyExtension(ExtensionActivationTimes.NONE));
 		}

-		this._extHostLogService.info(`ExtensionService#_doActivateExtension ${extensionDescription.id} ${JSON.stringify(reason)}`);
+		this._extHostLogService.info(`ExtensionService#_doActivateExtension ${extensionDescription.identifier.value} ${JSON.stringify(reason)}`);

 		const activationTimesBuilder = new ExtensionActivationTimesBuilder(reason.startup);
 		return Promise.all<any>([
 			loadCommonJSModule(this._extHostLogService, extensionDescription.main, activationTimesBuilder),
 			this._loadExtensionContext(extensionDescription)
 		]).then(values => {
-			return ExtHostExtensionService._callActivate(this._extHostLogService, extensionDescription.id, <IExtensionModule>values[0], <IExtensionContext>values[1], activationTimesBuilder);
+			return ExtHostExtensionService._callActivate(this._extHostLogService, extensionDescription.identifier, <IExtensionModule>values[0], <IExtensionContext>values[1], activationTimesBuilder);
 		});
 	}

 	private _loadExtensionContext(extensionDescription: IExtensionDescription): Promise<IExtensionContext> {

-		let globalState = new ExtensionMemento(extensionDescription.id, true, this._storage);
-		let workspaceState = new ExtensionMemento(extensionDescription.id, false, this._storage);
+		let globalState = new ExtensionMemento(extensionDescription.identifier.value, true, this._storage);
+		let workspaceState = new ExtensionMemento(extensionDescription.identifier.value, false, this._storage);

-		this._extHostLogService.trace(`ExtensionService#loadExtensionContext ${extensionDescription.id}`);
+		this._extHostLogService.trace(`ExtensionService#loadExtensionContext ${extensionDescription.identifier.value}`);
 		return Promise.all([
 			globalState.whenReady,
 			workspaceState.whenReady,
@@ -423,12 +424,12 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 				storagePath: this._storagePath.workspaceValue(extensionDescription),
 				get globalStoragePath(): string { checkProposedApiEnabled(extensionDescription); return that._storagePath.globalValue(extensionDescription); },
 				asAbsolutePath: (relativePath: string) => { return path.join(extensionDescription.extensionLocation.fsPath, relativePath); },
-				logPath: that._extHostLogService.getLogDirectory(extensionDescription.id)
+				logPath: that._extHostLogService.getLogDirectory(extensionDescription.identifier)
 			});
 		});
 	}

-	private static _callActivate(logService: ILogService, extensionId: string, extensionModule: IExtensionModule, context: IExtensionContext, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<ActivatedExtension> {
+	private static _callActivate(logService: ILogService, extensionId: CanonicalExtensionIdentifier, extensionModule: IExtensionModule, context: IExtensionContext, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<ActivatedExtension> {
 		// Make sure the extension's surface is not undefined
 		extensionModule = extensionModule || {
 			activate: undefined,
@@ -440,11 +441,11 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		});
 	}

-	private static _callActivateOptional(logService: ILogService, extensionId: string, extensionModule: IExtensionModule, context: IExtensionContext, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<IExtensionAPI> {
+	private static _callActivateOptional(logService: ILogService, extensionId: CanonicalExtensionIdentifier, extensionModule: IExtensionModule, context: IExtensionContext, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<IExtensionAPI> {
 		if (typeof extensionModule.activate === 'function') {
 			try {
 				activationTimesBuilder.activateCallStart();
-				logService.trace(`ExtensionService#_callActivateOptional ${extensionId}`);
+				logService.trace(`ExtensionService#_callActivateOptional ${extensionId.value}`);
 				const activateResult: Promise<IExtensionAPI> = extensionModule.activate.apply(global, [context]);
 				activationTimesBuilder.activateCallStop();

@@ -509,13 +510,13 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 			return Promise.resolve(void 0);
 		}

-		const fileNamePromise = Promise.all(fileNames.map((fileName) => this._activateIfFileName(workspace, desc.id, fileName))).then(() => { });
-		const globPatternPromise = this._activateIfGlobPatterns(desc.id, globPatterns);
+		const fileNamePromise = Promise.all(fileNames.map((fileName) => this._activateIfFileName(workspace, desc.identifier, fileName))).then(() => { });
+		const globPatternPromise = this._activateIfGlobPatterns(desc.identifier, globPatterns);

 		return Promise.all([fileNamePromise, globPatternPromise]).then(() => { });
 	}

-	private async _activateIfFileName(workspace: IWorkspaceData, extensionId: string, fileName: string): Promise<void> {
+	private async _activateIfFileName(workspace: IWorkspaceData, extensionId: CanonicalExtensionIdentifier, fileName: string): Promise<void> {

 		// find exact path
 		for (const { uri } of workspace.folders) {
@@ -531,8 +532,8 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		return undefined;
 	}

-	private async _activateIfGlobPatterns(extensionId: string, globPatterns: string[]): Promise<void> {
-		this._extHostLogService.trace(`extensionHostMain#activateIfGlobPatterns: fileSearch, extension: ${extensionId}, entryPoint: workspaceContains`);
+	private async _activateIfGlobPatterns(extensionId: CanonicalExtensionIdentifier, globPatterns: string[]): Promise<void> {
+		this._extHostLogService.trace(`extensionHostMain#activateIfGlobPatterns: fileSearch, extension: ${extensionId.value}, entryPoint: workspaceContains`);

 		if (globPatterns.length === 0) {
 			return Promise.resolve(void 0);
@@ -634,7 +635,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		throw new Error(`Not implemented`);
 	}

-	public $startExtensionHost(enabledExtensionIds: string[]): Promise<void> {
+	public $startExtensionHost(enabledExtensionIds: CanonicalExtensionIdentifier[]): Promise<void> {
 		this._registry.keepOnly(enabledExtensionIds);
 		return this._startExtensionHost();
 	}
@@ -678,7 +679,7 @@ function getTelemetryActivationEvent(extensionDescription: IExtensionDescription
 		}
 	*/
 	let event = {
-		id: extensionDescription.id,
+		id: extensionDescription.identifier.value,
 		name: extensionDescription.name,
 		extensionVersion: extensionDescription.version,
 		publisherDisplayName: extensionDescription.publisher,
--- a/src/vs/workbench/api/node/extHostLanguageFeatures.ts
+++ b/src/vs/workbench/api/node/extHostLanguageFeatures.ts
@@ -25,6 +25,7 @@ import { ISelection, Selection } from 'vs/editor/common/core/selection';
 import { IExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
 import { ILogService } from 'vs/platform/log/common/log';
 import { CancellationToken } from 'vs/base/common/cancellation';
+import { CanonicalExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

 // --- adapter

@@ -289,7 +290,7 @@ class CodeActionAdapter {
 		private readonly _diagnostics: ExtHostDiagnostics,
 		private readonly _provider: vscode.CodeActionProvider,
 		private readonly _logService: ILogService,
-		private readonly _extensionId: string
+		private readonly _extensionId: CanonicalExtensionIdentifier
 	) { }

 	provideCodeActions(resource: URI, rangeOrSelection: IRange | ISelection, context: modes.CodeActionContext, token: CancellationToken): Promise<CodeActionDto[]> {
@@ -330,9 +331,9 @@ class CodeActionAdapter {
 				} else {
 					if (codeActionContext.only) {
 						if (!candidate.kind) {
-							this._logService.warn(`${this._extensionId} - Code actions of kind '${codeActionContext.only.value} 'requested but returned code action does not have a 'kind'. Code action will be dropped. Please set 'CodeAction.kind'.`);
+							this._logService.warn(`${this._extensionId.value} - Code actions of kind '${codeActionContext.only.value} 'requested but returned code action does not have a 'kind'. Code action will be dropped. Please set 'CodeAction.kind'.`);
 						} else if (!codeActionContext.only.contains(candidate.kind)) {
-							this._logService.warn(`${this._extensionId} -Code actions of kind '${codeActionContext.only.value} 'requested but returned code action is of kind '${candidate.kind.value}'. Code action will be dropped. Please check 'CodeActionContext.only' to only return requested code actions.`);
+							this._logService.warn(`${this._extensionId.value} -Code actions of kind '${codeActionContext.only.value} 'requested but returned code action is of kind '${candidate.kind.value}'. Code action will be dropped. Please check 'CodeActionContext.only' to only return requested code actions.`);
 						}
 					}

@@ -975,14 +976,14 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
 			let t1: number;
 			if (data.extension) {
 				t1 = Date.now();
-				this._logService.trace(`[${data.extension.id}] INVOKE provider '${(ctor as any).name}'`);
+				this._logService.trace(`[${data.extension.identifier.value}] INVOKE provider '${(ctor as any).name}'`);
 			}
 			let p = callback(data.adapter);
 			if (data.extension) {
 				Promise.resolve(p).then(
-					() => this._logService.trace(`[${data.extension.id}] provider DONE after ${Date.now() - t1}ms`),
+					() => this._logService.trace(`[${data.extension.identifier.value}] provider DONE after ${Date.now() - t1}ms`),
 					err => {
-						this._logService.error(`[${data.extension.id}] provider FAILED`);
+						this._logService.error(`[${data.extension.identifier.value}] provider FAILED`);
 						this._logService.error(err);
 					}
 				);
@@ -1081,7 +1082,7 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {

 	// --- extra info

-	registerHoverProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.HoverProvider, extensionId?: string): vscode.Disposable {
+	registerHoverProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.HoverProvider, extensionId?: CanonicalExtensionIdentifier): vscode.Disposable {
 		const handle = this._addNewAdapter(new HoverAdapter(this._documents, provider), extension);
 		this._proxy.$registerHoverProvider(handle, this._transformDocumentSelector(selector));
 		return this._createDisposable(handle);
@@ -1118,7 +1119,7 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
 	// --- quick fix

 	registerCodeActionProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.CodeActionProvider, metadata?: vscode.CodeActionProviderMetadata): vscode.Disposable {
-		const handle = this._addNewAdapter(new CodeActionAdapter(this._documents, this._commands.converter, this._diagnostics, provider, this._logService, extension.id), extension);
+		const handle = this._addNewAdapter(new CodeActionAdapter(this._documents, this._commands.converter, this._diagnostics, provider, this._logService, extension.identifier), extension);
 		this._proxy.$registerQuickFixSupport(handle, this._transformDocumentSelector(selector), metadata && metadata.providedCodeActionKinds ? metadata.providedCodeActionKinds.map(kind => kind.value) : undefined);
 		return this._createDisposable(handle);
 	}
--- a/src/vs/workbench/api/node/extHostLogService.ts
+++ b/src/vs/workbench/api/node/extHostLogService.ts
@@ -9,6 +9,7 @@ import { createSpdLogService } from 'vs/platform/log/node/spdlogService';
 import { ExtHostLogServiceShape } from 'vs/workbench/api/node/extHost.protocol';
 import { ExtensionHostLogFileName } from 'vs/workbench/services/extensions/common/extensions';
 import { URI } from 'vs/base/common/uri';
+import { CanonicalExtensionIdentifier } from 'vs/platform/extensions/common/extensions';


 export class ExtHostLogService extends DelegatedLogService implements ILogService, ExtHostLogServiceShape {
@@ -29,7 +30,7 @@ export class ExtHostLogService extends DelegatedLogService implements ILogServic
 		this.setLevel(level);
 	}

-	getLogDirectory(extensionID: string): string {
-		return join(this._logsPath, extensionID);
+	getLogDirectory(extensionID: CanonicalExtensionIdentifier): string {
+		return join(this._logsPath, extensionID.value);
 	}
 }
--- a/src/vs/workbench/api/node/extHostQuickOpen.ts
+++ b/src/vs/workbench/api/node/extHostQuickOpen.ts
@@ -14,6 +14,7 @@ import { ExtHostQuickOpenShape, IMainContext, MainContext, MainThreadQuickOpenSh
 import { URI } from 'vs/base/common/uri';
 import { ThemeIcon, QuickInputButtons } from 'vs/workbench/api/node/extHostTypes';
 import { isPromiseCanceledError } from 'vs/base/common/errors';
+import { CanonicalExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

 export type Item = string | QuickPickItem;

@@ -169,13 +170,13 @@ export class ExtHostQuickOpen implements ExtHostQuickOpenShape {

 	// ---- QuickInput

-	createQuickPick<T extends QuickPickItem>(extensionId: string, enableProposedApi: boolean): QuickPick<T> {
+	createQuickPick<T extends QuickPickItem>(extensionId: CanonicalExtensionIdentifier, enableProposedApi: boolean): QuickPick<T> {
 		const session = new ExtHostQuickPick(this._proxy, extensionId, enableProposedApi, () => this._sessions.delete(session._id));
 		this._sessions.set(session._id, session);
 		return session;
 	}

-	createInputBox(extensionId: string): InputBox {
+	createInputBox(extensionId: CanonicalExtensionIdentifier): InputBox {
 		const session = new ExtHostInputBox(this._proxy, extensionId, () => this._sessions.delete(session._id));
 		this._sessions.set(session._id, session);
 		return session;
@@ -256,7 +257,7 @@ class ExtHostQuickInput implements QuickInput {
 		this._onDidChangeValueEmitter
 	];

-	constructor(protected _proxy: MainThreadQuickOpenShape, protected _extensionId: string, private _onDidDispose: () => void) {
+	constructor(protected _proxy: MainThreadQuickOpenShape, protected _extensionId: CanonicalExtensionIdentifier, private _onDidDispose: () => void) {
 	}

 	get title() {
@@ -479,7 +480,7 @@ class ExtHostQuickPick<T extends QuickPickItem> extends ExtHostQuickInput implem
 	private _selectedItems: T[] = [];
 	private _onDidChangeSelectionEmitter = new Emitter<T[]>();

-	constructor(proxy: MainThreadQuickOpenShape, extensionId: string, enableProposedApi: boolean, onDispose: () => void) {
+	constructor(proxy: MainThreadQuickOpenShape, extensionId: CanonicalExtensionIdentifier, enableProposedApi: boolean, onDispose: () => void) {
 		super(proxy, extensionId, onDispose);
 		this._disposables.push(
 			this._onDidChangeActiveEmitter,
@@ -580,7 +581,7 @@ class ExtHostInputBox extends ExtHostQuickInput implements InputBox {
 	private _prompt: string;
 	private _validationMessage: string;

-	constructor(proxy: MainThreadQuickOpenShape, extensionId: string, onDispose: () => void) {
+	constructor(proxy: MainThreadQuickOpenShape, extensionId: CanonicalExtensionIdentifier, onDispose: () => void) {
 		super(proxy, extensionId, onDispose);
 		this.update({ type: 'inputBox' });
 	}
--- a/src/vs/workbench/api/node/extHostSCM.ts
+++ b/src/vs/workbench/api/node/extHostSCM.ts
@@ -17,6 +17,7 @@ import * as vscode from 'vscode';
 import { ISplice } from 'vs/base/common/sequence';
 import { ILogService } from 'vs/platform/log/common/log';
 import { CancellationToken } from 'vs/base/common/cancellation';
+import { CanonicalExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

 type ProviderHandle = number;
 type GroupHandle = number;
@@ -178,7 +179,7 @@ export class ExtHostSCMInputBox implements vscode.SourceControlInputBox {

 	get validateInput(): IValidateInput {
 		if (!this._extension.enableProposedApi) {
-			throw new Error(`[${this._extension.id}]: Proposed API is only available when running out of dev or with the following command line switch: --enable-proposed-api ${this._extension.id}`);
+			throw new Error(`[${this._extension.identifier.value}]: Proposed API is only available when running out of dev or with the following command line switch: --enable-proposed-api ${this._extension.identifier.value}`);
 		}

 		return this._validateInput;
@@ -186,7 +187,7 @@ export class ExtHostSCMInputBox implements vscode.SourceControlInputBox {

 	set validateInput(fn: IValidateInput) {
 		if (!this._extension.enableProposedApi) {
-			throw new Error(`[${this._extension.id}]: Proposed API is only available when running out of dev or with the following command line switch: --enable-proposed-api ${this._extension.id}`);
+			throw new Error(`[${this._extension.identifier.value}]: Proposed API is only available when running out of dev or with the following command line switch: --enable-proposed-api ${this._extension.identifier.value}`);
 		}

 		if (fn && typeof fn !== 'function') {
@@ -584,24 +585,24 @@ export class ExtHostSCM implements ExtHostSCMShape {
 	}

 	createSourceControl(extension: IExtensionDescription, id: string, label: string, rootUri: vscode.Uri | undefined): vscode.SourceControl {
-		this.logService.trace('ExtHostSCM#createSourceControl', extension.id, id, label, rootUri);
+		this.logService.trace('ExtHostSCM#createSourceControl', extension.identifier.value, id, label, rootUri);

 		const handle = ExtHostSCM._handlePool++;
 		const sourceControl = new ExtHostSourceControl(extension, this._proxy, this._commands, id, label, rootUri);
 		this._sourceControls.set(handle, sourceControl);

-		const sourceControls = this._sourceControlsByExtension.get(extension.id) || [];
+		const sourceControls = this._sourceControlsByExtension.get(CanonicalExtensionIdentifier.toKey(extension.identifier)) || [];
 		sourceControls.push(sourceControl);
-		this._sourceControlsByExtension.set(extension.id, sourceControls);
+		this._sourceControlsByExtension.set(CanonicalExtensionIdentifier.toKey(extension.identifier), sourceControls);

 		return sourceControl;
 	}

 	// Deprecated
 	getLastInputBox(extension: IExtensionDescription): ExtHostSCMInputBox {
-		this.logService.trace('ExtHostSCM#getLastInputBox', extension.id);
+		this.logService.trace('ExtHostSCM#getLastInputBox', extension.identifier.value);

-		const sourceControls = this._sourceControlsByExtension.get(extension.id);
+		const sourceControls = this._sourceControlsByExtension.get(CanonicalExtensionIdentifier.toKey(extension.identifier));
 		const sourceControl = sourceControls && sourceControls[sourceControls.length - 1];
 		const inputBox = sourceControl && sourceControl.inputBox;

--- a/src/vs/workbench/api/node/extHostStatusBar.ts
+++ b/src/vs/workbench/api/node/extHostStatusBar.ts
@@ -7,6 +7,7 @@ import { StatusbarAlignment as MainThreadStatusBarAlignment } from 'vs/platform/
 import { StatusBarAlignment as ExtHostStatusBarAlignment, Disposable, ThemeColor } from './extHostTypes';
 import { StatusBarItem, StatusBarAlignment } from 'vscode';
 import { MainContext, MainThreadStatusBarShape, IMainContext } from './extHost.protocol';
+import { CanonicalExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

 export class ExtHostStatusBarEntry implements StatusBarItem {
 	private static ID_GEN = 0;
@@ -25,9 +26,9 @@ export class ExtHostStatusBarEntry implements StatusBarItem {
 	private _timeoutHandle: any;
 	private _proxy: MainThreadStatusBarShape;

-	private _extensionId: string;
+	private _extensionId: CanonicalExtensionIdentifier;

-	constructor(proxy: MainThreadStatusBarShape, extensionId: string, alignment: ExtHostStatusBarAlignment = ExtHostStatusBarAlignment.Left, priority?: number) {
+	constructor(proxy: MainThreadStatusBarShape, extensionId: CanonicalExtensionIdentifier, alignment: ExtHostStatusBarAlignment = ExtHostStatusBarAlignment.Left, priority?: number) {
 		this._id = ExtHostStatusBarEntry.ID_GEN++;
 		this._proxy = proxy;
 		this._alignment = alignment;
@@ -166,7 +167,7 @@ export class ExtHostStatusBar {
 		this._statusMessage = new StatusBarMessage(this);
 	}

-	createStatusBarEntry(extensionId: string, alignment?: ExtHostStatusBarAlignment, priority?: number): StatusBarItem {
+	createStatusBarEntry(extensionId: CanonicalExtensionIdentifier, alignment?: ExtHostStatusBarAlignment, priority?: number): StatusBarItem {
 		return new ExtHostStatusBarEntry(this._proxy, extensionId, alignment, priority);
 	}

--- a/src/vs/workbench/api/node/extHostTask.ts
+++ b/src/vs/workbench/api/node/extHostTask.ts
@@ -205,7 +205,7 @@ namespace TaskDTO {
 			definition,
 			name: value.name,
 			source: {
-				extensionId: extension.id,
+				extensionId: extension.identifier.value,
 				label: value.source,
 				scope: scope
 			},
--- a/src/vs/workbench/api/node/extHostTerminalService.ts
+++ b/src/vs/workbench/api/node/extHostTerminalService.ts
@@ -74,7 +74,7 @@ export class ExtHostTerminal extends BaseExtHostTerminal implements vscode.Termi
 	private _pidPromise: Promise<number>;
 	private _pidPromiseComplete: (value: number) => any;

-	private readonly _onData: Emitter<string> = new Emitter<string>();
+	private readonly _onData = new Emitter<string>();
 	public get onDidWriteData(): Event<string> {
 		// Tell the main side to start sending data if it's not already
 		this._idPromise.then(c => {
@@ -167,7 +167,7 @@ export class ExtHostTerminalRenderer extends BaseExtHostTerminal implements vsco
 		this._queueApiRequest(this._proxy.$terminalRendererSetName, [this._name]);
 	}

-	private readonly _onInput: Emitter<string> = new Emitter<string>();
+	private readonly _onInput = new Emitter<string>();
 	public get onDidAcceptInput(): Event<string> {
 		this._checkDisposed();
 		this._queueApiRequest(this._proxy.$terminalRendererRegisterOnInputListener, [this._id]);
--- a/src/vs/workbench/api/node/extHostUrls.ts
+++ b/src/vs/workbench/api/node/extHostUrls.ts
@@ -8,6 +8,7 @@ import { MainContext, IMainContext, ExtHostUrlsShape, MainThreadUrlsShape } from
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { toDisposable } from 'vs/base/common/lifecycle';
 import { onUnexpectedError } from 'vs/base/common/errors';
+import { CanonicalExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

 export class ExtHostUrls implements ExtHostUrlsShape {

@@ -23,18 +24,18 @@ export class ExtHostUrls implements ExtHostUrlsShape {
 		this._proxy = mainContext.getProxy(MainContext.MainThreadUrls);
 	}

-	registerUriHandler(extensionId: string, handler: vscode.UriHandler): vscode.Disposable {
-		if (this.handles.has(extensionId)) {
+	registerUriHandler(extensionId: CanonicalExtensionIdentifier, handler: vscode.UriHandler): vscode.Disposable {
+		if (this.handles.has(CanonicalExtensionIdentifier.toKey(extensionId))) {
 			throw new Error(`Protocol handler already registered for extension ${extensionId}`);
 		}

 		const handle = ExtHostUrls.HandlePool++;
-		this.handles.add(extensionId);
+		this.handles.add(CanonicalExtensionIdentifier.toKey(extensionId));
 		this.handlers.set(handle, handler);
 		this._proxy.$registerUriHandler(handle, extensionId);

 		return toDisposable(() => {
-			this.handles.delete(extensionId);
+			this.handles.delete(CanonicalExtensionIdentifier.toKey(extensionId));
 			this.handlers.delete(handle);
 			this._proxy.$unregisterUriHandler(handle);
 		});
--- a/src/vs/workbench/api/node/extHostWebview.ts
+++ b/src/vs/workbench/api/node/extHostWebview.ts
@@ -252,7 +252,7 @@ export class ExtHostWebviews implements ExtHostWebviewsShape {
 		};

 		const handle = ExtHostWebviews.newHandle();
-		this._proxy.$createWebviewPanel(handle, viewType, title, webviewShowOptions, options, extension.id, extension.extensionLocation);
+		this._proxy.$createWebviewPanel(handle, viewType, title, webviewShowOptions, options, extension.identifier, extension.extensionLocation);

 		const webview = new ExtHostWebview(handle, this._proxy, options);
 		const panel = new ExtHostWebviewPanel(handle, this._proxy, viewType, title, viewColumn, options, webview);
--- a/src/vs/workbench/api/node/extHostWorkspace.ts
+++ b/src/vs/workbench/api/node/extHostWorkspace.ts
@@ -24,6 +24,7 @@ import { ITextQueryBuilderOptions } from 'vs/workbench/parts/search/common/query
 import { IExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
 import * as vscode from 'vscode';
 import { ExtHostWorkspaceShape, IMainContext, IWorkspaceData, MainContext, MainThreadMessageServiceShape, MainThreadWorkspaceShape } from './extHost.protocol';
+import { CanonicalExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

 function isFolderEqual(folderA: URI, folderB: URI): boolean {
 	return isEqual(folderA, folderB, !isLinux);
@@ -345,8 +346,8 @@ export class ExtHostWorkspace implements ExtHostWorkspaceShape {

 	// --- search ---

-	findFiles(include: string | RelativePattern, exclude: vscode.GlobPattern, maxResults: number, extensionId: string, token: vscode.CancellationToken = CancellationToken.None): Promise<vscode.Uri[]> {
-		this._logService.trace(`extHostWorkspace#findFiles: fileSearch, extension: ${extensionId}, entryPoint: findFiles`);
+	findFiles(include: string | RelativePattern, exclude: vscode.GlobPattern, maxResults: number, extensionId: CanonicalExtensionIdentifier, token: vscode.CancellationToken = CancellationToken.None): Promise<vscode.Uri[]> {
+		this._logService.trace(`extHostWorkspace#findFiles: fileSearch, extension: ${extensionId.value}, entryPoint: findFiles`);

 		let includePattern: string;
 		let includeFolder: URI;
@@ -380,8 +381,8 @@ export class ExtHostWorkspace implements ExtHostWorkspaceShape {
 			.then(data => Array.isArray(data) ? data.map(URI.revive) : []);
 	}

-	findTextInFiles(query: vscode.TextSearchQuery, options: vscode.FindTextInFilesOptions, callback: (result: vscode.TextSearchResult) => void, extensionId: string, token: vscode.CancellationToken = CancellationToken.None): Promise<vscode.TextSearchComplete> {
-		this._logService.trace(`extHostWorkspace#findTextInFiles: textSearch, extension: ${extensionId}, entryPoint: findTextInFiles`);
+	findTextInFiles(query: vscode.TextSearchQuery, options: vscode.FindTextInFilesOptions, callback: (result: vscode.TextSearchResult) => void, extensionId: CanonicalExtensionIdentifier, token: vscode.CancellationToken = CancellationToken.None): Promise<vscode.TextSearchComplete> {
+		this._logService.trace(`extHostWorkspace#findTextInFiles: textSearch, extension: ${extensionId.value}, entryPoint: findTextInFiles`);

 		const requestId = this._requestIdProvider.getNext();