move extensionValidator to common

src/vs/code/electron-browser/sharedProcess/sharedProcessMain.ts

@@ -55,6 +55,8 @@ import { FileService } from 'vs/platform/files/common/fileService';
 import { IFileService } from 'vs/platform/files/common/files';
 import { DiskFileSystemProvider } from 'vs/platform/files/electron-browser/diskFileSystemProvider';
 import { Schemas } from 'vs/base/common/network';
+import { IProductService } from 'vs/platform/product/common/product';
+import { ProductService } from 'vs/platform/product/node/productService';
 
 export interface ISharedProcessConfiguration {
 	readonly machineId: string;
@@ -114,6 +116,7 @@ async function main(server: Server, initData: ISharedProcessInitData, configurat
 	services.set(IConfigurationService, configurationService);
 	services.set(IRequestService, new SyncDescriptor(RequestService));
 	services.set(IDownloadService, new SyncDescriptor(DownloadService));
+	services.set(IProductService, new SyncDescriptor(ProductService));
 
 	const mainProcessService = new MainProcessService(server, mainRouter);
 	services.set(IMainProcessService, mainProcessService);

src/vs/code/node/cliProcessMain.ts

@@ -46,6 +46,8 @@ import { FileService } from 'vs/platform/files/common/fileService';
 import { IFileService } from 'vs/platform/files/common/files';
 import { DiskFileSystemProvider } from 'vs/platform/files/node/diskFileSystemProvider';
 import { DisposableStore } from 'vs/base/common/lifecycle';
+import { IProductService } from 'vs/platform/product/common/product';
+import { ProductService } from 'vs/platform/product/node/productService';
 
 const notFound = (id: string) => localize('notFound', "Extension '{0}' not found.", id);
 const notInstalled = (id: string) => localize('notInstalled', "Extension '{0}' is not installed.", id);
@@ -301,6 +303,7 @@ export async function main(argv: ParsedArgs): Promise<void> {
 	services.set(ILogService, logService);
 	services.set(IConfigurationService, configurationService);
 	services.set(IStateService, new SyncDescriptor(StateService));
+	services.set(IProductService, new SyncDescriptor(ProductService));
 
 	// Files
 	const fileService = new FileService(logService);

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

@@ -11,7 +11,7 @@ import { assign, getOrDefault } from 'vs/base/common/objects';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { IPager } from 'vs/base/common/paging';
 import { IRequestService, IRequestOptions, IRequestContext, asJson, asText } from 'vs/platform/request/common/request';
-import { isEngineValid } from 'vs/platform/extensions/node/extensionValidator';
+import { isEngineValid } from 'vs/platform/extensions/common/extensionValidator';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { generateUuid, isUUID } from 'vs/base/common/uuid';
 import { values } from 'vs/base/common/map';
@@ -338,7 +338,7 @@ export class ExtensionGalleryService implements IExtensionGalleryService {
 		@IEnvironmentService private readonly environmentService: IEnvironmentService,
 		@ITelemetryService private readonly telemetryService: ITelemetryService,
 		@IFileService private readonly fileService: IFileService,
-		@IProductService productService: IProductService,
+		@IProductService private readonly productService: IProductService,
 	) {
 		const config = productService.extensionsGallery;
 		this.extensionsGalleryUrl = config && config.serviceUrl;
@@ -356,7 +356,7 @@ export class ExtensionGalleryService implements IExtensionGalleryService {
 
 	getCompatibleExtension(arg1: IExtensionIdentifier | IGalleryExtension, version?: string): Promise<IGalleryExtension | null> {
 		const extension: IGalleryExtension | null = isIExtensionIdentifier(arg1) ? null : arg1;
-		if (extension && extension.properties.engine && isEngineValid(extension.properties.engine)) {
+		if (extension && extension.properties.engine && isEngineValid(extension.properties.engine, this.productService.version)) {
 			return Promise.resolve(extension);
 		}
 		const { id, uuid } = extension ? extension.identifier : <IExtensionIdentifier>arg1;
@@ -382,7 +382,7 @@ export class ExtensionGalleryService implements IExtensionGalleryService {
 					const versionAsset = rawExtension.versions.filter(v => v.version === version)[0];
 					if (versionAsset) {
 						const extension = toExtension(rawExtension, versionAsset, 0, query);
-						if (extension.properties.engine && isEngineValid(extension.properties.engine)) {
+						if (extension.properties.engine && isEngineValid(extension.properties.engine, this.productService.version)) {
 							return extension;
 						}
 					}
@@ -615,7 +615,7 @@ export class ExtensionGalleryService implements IExtensionGalleryService {
 		return this.queryGallery(query, CancellationToken.None).then(({ galleryExtensions }) => {
 			if (galleryExtensions.length) {
 				if (compatible) {
-					return Promise.all(galleryExtensions[0].versions.map(v => this.getEngine(v).then(engine => isEngineValid(engine) ? v : null)))
+					return Promise.all(galleryExtensions[0].versions.map(v => this.getEngine(v).then(engine => isEngineValid(engine, this.productService.version) ? v : null)))
 						.then(versions => versions
 							.filter(v => !!v)
 							.map(v => ({ version: v!.version, date: v!.lastUpdated })));
@@ -701,7 +701,7 @@ export class ExtensionGalleryService implements IExtensionGalleryService {
 			if (!engine) {
 				return null;
 			}
-			if (isEngineValid(engine)) {
+			if (isEngineValid(engine, this.productService.version)) {
 				return Promise.resolve(version);
 			}
 		}
@@ -733,7 +733,7 @@ export class ExtensionGalleryService implements IExtensionGalleryService {
 		const version = versions[0];
 		return this.getEngine(version)
 			.then(engine => {
-				if (!isEngineValid(engine)) {
+				if (!isEngineValid(engine, this.productService.version)) {
 					return this.getLastValidExtensionVersionRecursively(extension, versions.slice(1));
 				}
 

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

@@ -35,7 +35,7 @@ import { ExtensionsManifestCache } from 'vs/platform/extensionManagement/node/ex
 import { ExtensionsLifecycle } from 'vs/platform/extensionManagement/node/extensionLifecycle';
 import { toErrorMessage } from 'vs/base/common/errorMessage';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-import { isEngineValid } from 'vs/platform/extensions/node/extensionValidator';
+import { isEngineValid } from 'vs/platform/extensions/common/extensionValidator';
 import { tmpdir } from 'os';
 import { generateUuid } from 'vs/base/common/uuid';
 import { IDownloadService } from 'vs/platform/download/common/download';
@@ -197,7 +197,7 @@ export class ExtensionManagementService extends Disposable implements IExtension
 					.then(manifest => {
 						const identifier = { id: getGalleryExtensionId(manifest.publisher, manifest.name) };
 						let operation: InstallOperation = InstallOperation.Install;
-						if (manifest.engines && manifest.engines.vscode && !isEngineValid(manifest.engines.vscode)) {
+						if (manifest.engines && manifest.engines.vscode && !isEngineValid(manifest.engines.vscode, pkg.version)) {
 							return Promise.reject(new Error(nls.localize('incompatible', "Unable to install extension '{0}' as it is not compatible with VS Code '{1}'.", identifier.id, pkg.version)));
 						}
 						const identifierWithVersion = new ExtensionIdentifierWithVersion(identifier, manifest.version);

src/vs/platform/extensions/node/extensionValidator.ts → src/vs/platform/extensions/common/extensionValidator.ts

@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as nls from 'vs/nls';
-import pkg from 'vs/platform/product/node/package';
 
 export interface IParsedVersion {
 	hasCaret: boolean;
@@ -222,9 +221,9 @@ export function isValidExtensionVersion(version: string, extensionDesc: IReduced
 	return isVersionValid(version, extensionDesc.engines.vscode, notices);
 }
 
-export function isEngineValid(engine: string): boolean {
+export function isEngineValid(engine: string, version: string): boolean {
 	// TODO@joao: discuss with alex '*' doesn't seem to be a valid engine version
-	return engine === '*' || isVersionValid(pkg.version, engine);
+	return engine === '*' || isVersionValid(version, engine);
 }
 
 export function isVersionValid(currentVersion: string, requestedVersion: string, notices: string[] = []): boolean {

src/vs/platform/extensions/test/node/extensionValidator.test.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 import * as assert from 'assert';
-import { INormalizedVersion, IParsedVersion, IReducedExtensionDescription, isValidExtensionVersion, isValidVersion, isValidVersionStr, normalizeVersion, parseVersion } from 'vs/platform/extensions/node/extensionValidator';
+import { INormalizedVersion, IParsedVersion, IReducedExtensionDescription, isValidExtensionVersion, isValidVersion, isValidVersionStr, normalizeVersion, parseVersion } from 'vs/platform/extensions/common/extensionValidator';
 
 suite('Extension Version Validator', () => {
 

src/vs/workbench/services/extensions/node/extensionPoints.ts

@@ -13,7 +13,7 @@ import * as types from 'vs/base/common/types';
 import { URI } from 'vs/base/common/uri';
 import * as pfs from 'vs/base/node/pfs';
 import { getGalleryExtensionId, groupByExtension, ExtensionIdentifierWithVersion } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
-import { isValidExtensionVersion } from 'vs/platform/extensions/node/extensionValidator';
+import { isValidExtensionVersion } from 'vs/platform/extensions/common/extensionValidator';
 import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import { Translations, ILog } from 'vs/workbench/services/extensions/common/extensionPoints';