introduce IExtensionIdentifierWithVersion

src/vs/platform/extensionManagement/common/extensionManagement.ts

@@ -57,6 +57,12 @@ export interface IExtensionIdentifier {
 	uuid?: string;
 }
 
+export interface IExtensionIdentifierWithVersion extends IExtensionIdentifier {
+	id: string;
+	uuid?: string;
+	version: string;
+}
+
 export interface IGalleryExtensionIdentifier extends IExtensionIdentifier {
 	uuid: string;
 }

src/vs/platform/extensionManagement/common/extensionManagementUtil.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { ILocalExtension, IGalleryExtension, IExtensionIdentifier, IReportedExtension } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { ILocalExtension, IGalleryExtension, IExtensionIdentifier, IReportedExtension, IExtensionIdentifierWithVersion } from 'vs/platform/extensionManagement/common/extensionManagement';
 import { compareIgnoreCase } from 'vs/base/common/strings';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 
@@ -17,21 +17,28 @@ export function areSameExtensions(a: IExtensionIdentifier, b: IExtensionIdentifi
 	return compareIgnoreCase(a.id, b.id) === 0;
 }
 
-export class ExtensionIdentifierWithVersion {
+export class ExtensionIdentifierWithVersion implements IExtensionIdentifierWithVersion {
+
+	readonly id: string;
+	readonly uuid?: string;
+
 	constructor(
-		readonly identifier: IExtensionIdentifier,
+		identifier: IExtensionIdentifier,
 		readonly version: string
-	) { }
+	) {
+		this.id = identifier.id;
+		this.uuid = identifier.uuid;
+	}
 
 	key(): string {
-		return `${this.identifier.id}-${this.version}`;
+		return `${this.id}-${this.version}`;
 	}
 
 	equals(o: any): boolean {
 		if (!(o instanceof ExtensionIdentifierWithVersion)) {
 			return false;
 		}
-		return areSameExtensions(this.identifier, o.identifier) && this.version === o.version;
+		return areSameExtensions(this, o) && this.version === o.version;
 	}
 }
 

src/vs/platform/extensionManagement/node/extensionDownloader.ts

@@ -67,7 +67,7 @@ export class ExtensionsDownloader extends Disposable {
 						all.push([extension, stat]);
 					}
 				}
-				const byExtension = groupByExtension(all, ([extension]) => extension.identifier);
+				const byExtension = groupByExtension(all, ([extension]) => extension);
 				const distinct: IFileStatWithMetadata[] = [];
 				for (const p of byExtension) {
 					p.sort((a, b) => semver.rcompare(a[0].version, b[0].version));

src/vs/platform/extensionManagement/node/extensionManagementService.ts

@@ -237,10 +237,10 @@ export class ExtensionManagementService extends Disposable implements IExtension
 					this.logService.warn(`Cannot install packed extensions of extension:`, local.identifier.id, error.message);
 				}
 			}
-			this._onDidInstallExtension.fire({ identifier: identifierWithVersion.identifier, zipPath, local, operation });
+			this._onDidInstallExtension.fire({ identifier: identifierWithVersion, zipPath, local, operation });
 			return local;
 		} catch (error) {
-			this._onDidInstallExtension.fire({ identifier: identifierWithVersion.identifier, zipPath, operation, error });
+			this._onDidInstallExtension.fire({ identifier: identifierWithVersion, zipPath, operation, error });
 			throw error;
 		}
 	}
@@ -415,19 +415,18 @@ export class ExtensionManagementService extends Disposable implements IExtension
 			return null;
 		}
 
-		this.logService.trace('Removing the extension from uninstalled list:', identifierWithVersion.identifier.id);
+		this.logService.trace('Removing the extension from uninstalled list:', identifierWithVersion.id);
 		// If the same version of extension is marked as uninstalled, remove it from there and return the local.
 		await this.unsetUninstalled(identifierWithVersion);
-		this.logService.info('Removed the extension from uninstalled list:', identifierWithVersion.identifier.id);
+		this.logService.info('Removed the extension from uninstalled list:', identifierWithVersion.id);
 
 		const installed = await this.getInstalled(ExtensionType.User);
 		return installed.find(i => new ExtensionIdentifierWithVersion(i.identifier, i.manifest.version).equals(identifierWithVersion)) || null;
 	}
 
 	private async extractAndInstall({ zipPath, identifierWithVersion, metadata }: InstallableExtension, token: CancellationToken): Promise<ILocalExtension> {
-		const { identifier } = identifierWithVersion;
 		let local = await this.extensionsScanner.extractUserExtension(identifierWithVersion, zipPath, token);
-		this.logService.info('Installation completed.', identifier.id);
+		this.logService.info('Installation completed.', identifierWithVersion.id);
 		if (metadata) {
 			local = await this.extensionsScanner.saveMetadataForLocalExtension(local, metadata);
 		}

src/vs/platform/extensionManagement/node/extensionsScanner.ts

@@ -95,7 +95,6 @@ export class ExtensionsScanner extends Disposable {
 	}
 
 	async extractUserExtension(identifierWithVersion: ExtensionIdentifierWithVersion, zipPath: string, token: CancellationToken): Promise<ILocalExtension> {
-		const { identifier } = identifierWithVersion;
 		const folderName = identifierWithVersion.key();
 		const tempPath = path.join(this.extensionsPath, `.${folderName}`);
 		const extensionPath = path.join(this.extensionsPath, folderName);
@@ -106,12 +105,12 @@ export class ExtensionsScanner extends Disposable {
 			try {
 				await pfs.rimraf(extensionPath);
 			} catch (e) { /* ignore */ }
-			throw new ExtensionManagementError(localize('errorDeleting', "Unable to delete the existing folder '{0}' while installing the extension '{1}'. Please delete the folder manually and try again", extensionPath, identifier.id), INSTALL_ERROR_DELETING);
+			throw new ExtensionManagementError(localize('errorDeleting', "Unable to delete the existing folder '{0}' while installing the extension '{1}'. Please delete the folder manually and try again", extensionPath, identifierWithVersion.id), INSTALL_ERROR_DELETING);
 		}
 
-		await this.extractAtLocation(identifier, zipPath, tempPath, token);
+		await this.extractAtLocation(identifierWithVersion, zipPath, tempPath, token);
 		try {
-			await this.rename(identifier, tempPath, extensionPath, Date.now() + (2 * 60 * 1000) /* Retry for 2 minutes */);
+			await this.rename(identifierWithVersion, tempPath, extensionPath, Date.now() + (2 * 60 * 1000) /* Retry for 2 minutes */);
 			this.logService.info('Renamed to', extensionPath);
 		} catch (error) {
 			this.logService.info('Rename failed. Deleting from extracted location', tempPath);