@codingame/monaco-vscode-api 13.1.7 → 14.0.0

package/vscode/src/vs/platform/extensionManagement/common/extensionsScannerService.js

@@ -14,11 +14,10 @@ import { language } from '../../../base/common/platform.js';
 import { joinPath, isEqual, basename as basename$1 } from '../../../base/common/resources.js';
 import { semverExports } from '../../../../../../_virtual/semver.js';
 import Severity$1 from '../../../base/common/severity.js';
-import { isEmptyObject } from '../../../base/common/types.js';
 import { URI } from '../../../base/common/uri.js';
 import { localize } from '../../../nls.js';
 import { IEnvironmentService } from '../../environment/common/environment.service.js';
-import { computeTargetPlatform, areSameExtensions, ExtensionKey, getGalleryExtensionId } from './extensionManagementUtil.js';
+import { computeTargetPlatform, areSameExtensions, getGalleryExtensionId } from './extensionManagementUtil.js';
 import { ExtensionType, ExtensionIdentifierMap, UNDEFINED_PUBLISHER, TargetPlatform, parseEnabledApiProposalNames, BUILTIN_MANIFEST_CACHE_FILE, USER_MANIFEST_CACHE_FILE } from '../../extensions/common/extensions.js';
 import { validateExtensionManifest } from '../../extensions/common/extensionValidator.js';
 import { toFileOperationResult, FileOperationResult } from '../../files/common/files.js';
@@ -75,10 +74,9 @@ let AbstractExtensionsScannerService = class AbstractExtensionsScannerService ex
         this.instantiationService = instantiationService;
         this._onDidChangeCache = this._register(( new Emitter()));
         this.onDidChangeCache = this._onDidChangeCache.event;
-        this.obsoleteFile = joinPath(this.userExtensionsLocation, '.obsolete');
-        this.systemExtensionsCachedScanner = this._register(this.instantiationService.createInstance(CachedExtensionsScanner, this.currentProfile, this.obsoleteFile));
-        this.userExtensionsCachedScanner = this._register(this.instantiationService.createInstance(CachedExtensionsScanner, this.currentProfile, this.obsoleteFile));
-        this.extensionsScanner = this._register(this.instantiationService.createInstance(ExtensionsScanner, this.obsoleteFile));
+        this.systemExtensionsCachedScanner = this._register(this.instantiationService.createInstance(CachedExtensionsScanner, this.currentProfile));
+        this.userExtensionsCachedScanner = this._register(this.instantiationService.createInstance(CachedExtensionsScanner, this.currentProfile));
+        this.extensionsScanner = this._register(this.instantiationService.createInstance(ExtensionsScanner));
         this.initializeDefaultProfileExtensionsPromise = undefined;
         this._register(this.systemExtensionsCachedScanner.onDidChangeCache(() => this._onDidChangeCache.fire(ExtensionType.System)));
         this._register(this.userExtensionsCachedScanner.onDidChangeCache(() => this._onDidChangeCache.fire(ExtensionType.User)));
@@ -89,27 +87,25 @@ let AbstractExtensionsScannerService = class AbstractExtensionsScannerService ex
         }
         return this._targetPlatformPromise;
     }
-    async scanAllExtensions(systemScanOptions, userScanOptions, includeExtensionsUnderDev) {
+    async scanAllExtensions(systemScanOptions, userScanOptions) {
         const [system, user] = await Promise.all([
             this.scanSystemExtensions(systemScanOptions),
             this.scanUserExtensions(userScanOptions),
         ]);
-        const development = includeExtensionsUnderDev ? await this.scanExtensionsUnderDevelopment(systemScanOptions, [...system, ...user]) : [];
-        return this.dedupExtensions(system, user, development, await this.getTargetPlatform(), true);
+        return this.dedupExtensions(system, user, [], await this.getTargetPlatform(), true);
     }
     async scanSystemExtensions(scanOptions) {
         const promises = [];
-        promises.push(this.scanDefaultSystemExtensions(!!scanOptions.useCache, scanOptions.language));
+        promises.push(this.scanDefaultSystemExtensions(scanOptions.language));
         promises.push(this.scanDevSystemExtensions(scanOptions.language, !!scanOptions.checkControlFile));
         const [defaultSystemExtensions, devSystemExtensions] = await Promise.all(promises);
-        return this.applyScanOptions([...defaultSystemExtensions, ...devSystemExtensions], ExtensionType.System, scanOptions, false);
+        return this.applyScanOptions([...defaultSystemExtensions, ...devSystemExtensions], ExtensionType.System, { pickLatest: false });
     }
     async scanUserExtensions(scanOptions) {
-        const location = scanOptions.profileLocation ?? this.userExtensionsLocation;
-        this.logService.trace('Started scanning user extensions', location);
+        this.logService.trace('Started scanning user extensions', scanOptions.profileLocation);
         const profileScanOptions = this.uriIdentityService.extUri.isEqual(scanOptions.profileLocation, this.userDataProfilesService.defaultProfile.extensionsResource) ? { bailOutWhenFileNotFound: true } : undefined;
-        const extensionsScannerInput = await this.createExtensionScannerInput(location, !!scanOptions.profileLocation, ExtensionType.User, !scanOptions.includeUninstalled, scanOptions.language, true, profileScanOptions, scanOptions.productVersion ?? this.getProductVersion());
-        const extensionsScanner = scanOptions.useCache && !extensionsScannerInput.devMode && extensionsScannerInput.excludeObsolete ? this.userExtensionsCachedScanner : this.extensionsScanner;
+        const extensionsScannerInput = await this.createExtensionScannerInput(scanOptions.profileLocation, true, ExtensionType.User, scanOptions.language, true, profileScanOptions, scanOptions.productVersion ?? this.getProductVersion());
+        const extensionsScanner = scanOptions.useCache && !extensionsScannerInput.devMode ? this.userExtensionsCachedScanner : this.extensionsScanner;
         let extensions;
         try {
             extensions = await extensionsScanner.scanExtensions(extensionsScannerInput);
@@ -123,15 +119,20 @@ let AbstractExtensionsScannerService = class AbstractExtensionsScannerService ex
                 throw error;
             }
         }
-        extensions = await this.applyScanOptions(extensions, ExtensionType.User, scanOptions, true);
+        extensions = await this.applyScanOptions(extensions, ExtensionType.User, { includeInvalid: scanOptions.includeInvalid, pickLatest: true });
         this.logService.trace('Scanned user extensions:', extensions.length);
         return extensions;
     }
-    async scanExtensionsUnderDevelopment(scanOptions, existingExtensions) {
+    async scanAllUserExtensions(scanOptions = { includeInvalid: true, includeAllVersions: true }) {
+        const extensionsScannerInput = await this.createExtensionScannerInput(this.userExtensionsLocation, false, ExtensionType.User, undefined, true, undefined, this.getProductVersion());
+        const extensions = await this.extensionsScanner.scanExtensions(extensionsScannerInput);
+        return this.applyScanOptions(extensions, ExtensionType.User, { includeAllVersions: scanOptions.includeAllVersions, includeInvalid: scanOptions.includeInvalid });
+    }
+    async scanExtensionsUnderDevelopment(existingExtensions, scanOptions) {
         if (this.environmentService.isExtensionDevelopment && this.environmentService.extensionDevelopmentLocationURI) {
             const extensions = (await Promise.all(( this.environmentService.extensionDevelopmentLocationURI.filter(extLoc => extLoc.scheme === Schemas.file)
                 .map(async (extensionDevelopmentLocationURI) => {
-                const input = await this.createExtensionScannerInput(extensionDevelopmentLocationURI, false, ExtensionType.User, true, scanOptions.language, false , undefined, scanOptions.productVersion ?? this.getProductVersion());
+                const input = await this.createExtensionScannerInput(extensionDevelopmentLocationURI, false, ExtensionType.User, scanOptions.language, false , undefined, this.getProductVersion());
                 const extensions = await this.extensionsScanner.scanOneOrMultipleExtensions(input);
                 return ( extensions.map(extension => {
                     extension.type = existingExtensions.find(e => areSameExtensions(e.identifier, extension.identifier))?.type ?? extension.type;
@@ -139,12 +140,12 @@ let AbstractExtensionsScannerService = class AbstractExtensionsScannerService ex
                 }));
             }))))
                 .flat();
-            return this.applyScanOptions(extensions, 'development', scanOptions, true);
+            return this.applyScanOptions(extensions, 'development', { includeInvalid: scanOptions.includeInvalid, pickLatest: true });
         }
         return [];
     }
     async scanExistingExtension(extensionLocation, extensionType, scanOptions) {
-        const extensionsScannerInput = await this.createExtensionScannerInput(extensionLocation, false, extensionType, true, scanOptions.language, true, undefined, scanOptions.productVersion ?? this.getProductVersion());
+        const extensionsScannerInput = await this.createExtensionScannerInput(extensionLocation, false, extensionType, scanOptions.language, true, undefined, this.getProductVersion());
         const extension = await this.extensionsScanner.scanExtension(extensionsScannerInput);
         if (!extension) {
             return null;
@@ -155,9 +156,9 @@ let AbstractExtensionsScannerService = class AbstractExtensionsScannerService ex
         return extension;
     }
     async scanOneOrMultipleExtensions(extensionLocation, extensionType, scanOptions) {
-        const extensionsScannerInput = await this.createExtensionScannerInput(extensionLocation, false, extensionType, true, scanOptions.language, true, undefined, scanOptions.productVersion ?? this.getProductVersion());
+        const extensionsScannerInput = await this.createExtensionScannerInput(extensionLocation, false, extensionType, scanOptions.language, true, undefined, this.getProductVersion());
         const extensions = await this.extensionsScanner.scanOneOrMultipleExtensions(extensionsScannerInput);
-        return this.applyScanOptions(extensions, extensionType, scanOptions, true);
+        return this.applyScanOptions(extensions, extensionType, { includeInvalid: scanOptions.includeInvalid, pickLatest: true });
     }
     async scanMultipleExtensions(extensionLocations, extensionType, scanOptions) {
         const extensions = [];
@@ -165,13 +166,7 @@ let AbstractExtensionsScannerService = class AbstractExtensionsScannerService ex
             const scannedExtensions = await this.scanOneOrMultipleExtensions(extensionLocation, extensionType, scanOptions);
             extensions.push(...scannedExtensions);
         })));
-        return this.applyScanOptions(extensions, extensionType, scanOptions, true);
-    }
-    async scanMetadata(extensionLocation) {
-        const manifestLocation = joinPath(extensionLocation, 'package.json');
-        const content = ( (await this.fileService.readFile(manifestLocation)).value.toString());
-        const manifest = JSON.parse(content);
-        return manifest.__metadata;
+        return this.applyScanOptions(extensions, extensionType, { includeInvalid: scanOptions.includeInvalid, pickLatest: true });
     }
     async updateMetadata(extensionLocation, metaData) {
         const manifestLocation = joinPath(extensionLocation, 'package.json');
@@ -204,7 +199,7 @@ let AbstractExtensionsScannerService = class AbstractExtensionsScannerService ex
             this.initializeDefaultProfileExtensionsPromise = (async () => {
                 try {
                     this.logService.info('Started initializing default profile extensions in extensions installation folder.', ( this.userExtensionsLocation.toString()));
-                    const userExtensions = await this.scanUserExtensions({ includeInvalid: true });
+                    const userExtensions = await this.scanAllUserExtensions({ includeInvalid: true });
                     if (userExtensions.length) {
                         await this.extensionsProfileScannerService.addExtensionsToProfile(( userExtensions.map(e => [e, e.metadata])), this.userDataProfilesService.defaultProfile.extensionsResource);
                     }
@@ -230,9 +225,9 @@ let AbstractExtensionsScannerService = class AbstractExtensionsScannerService ex
         }
         return this.initializeDefaultProfileExtensionsPromise;
     }
-    async applyScanOptions(extensions, type, scanOptions, pickLatest) {
+    async applyScanOptions(extensions, type, scanOptions = {}) {
         if (!scanOptions.includeAllVersions) {
-            extensions = this.dedupExtensions(type === ExtensionType.System ? extensions : undefined, type === ExtensionType.User ? extensions : undefined, type === 'development' ? extensions : undefined, await this.getTargetPlatform(), pickLatest);
+            extensions = this.dedupExtensions(type === ExtensionType.System ? extensions : undefined, type === ExtensionType.User ? extensions : undefined, type === 'development' ? extensions : undefined, await this.getTargetPlatform(), !!scanOptions.pickLatest);
         }
         if (!scanOptions.includeInvalid) {
             extensions = extensions.filter(extension => extension.isValid);
@@ -304,10 +299,10 @@ let AbstractExtensionsScannerService = class AbstractExtensionsScannerService ex
         });
         return [...( result.values())];
     }
-    async scanDefaultSystemExtensions(useCache, language) {
+    async scanDefaultSystemExtensions(language) {
         this.logService.trace('Started scanning system extensions');
-        const extensionsScannerInput = await this.createExtensionScannerInput(this.systemExtensionsLocation, false, ExtensionType.System, true, language, true, undefined, this.getProductVersion());
-        const extensionsScanner = useCache && !extensionsScannerInput.devMode ? this.systemExtensionsCachedScanner : this.extensionsScanner;
+        const extensionsScannerInput = await this.createExtensionScannerInput(this.systemExtensionsLocation, false, ExtensionType.System, language, true, undefined, this.getProductVersion());
+        const extensionsScanner = extensionsScannerInput.devMode ? this.extensionsScanner : this.systemExtensionsCachedScanner;
         const result = await extensionsScanner.scanExtensions(extensionsScannerInput);
         this.logService.trace('Scanned system extensions:', result.length);
         return result;
@@ -335,7 +330,7 @@ let AbstractExtensionsScannerService = class AbstractExtensionsScannerService ex
             }
         }
         const result = await Promise.all(( devSystemExtensionsLocations.map(
-            async (location) => this.extensionsScanner.scanExtension((await this.createExtensionScannerInput(location, false, ExtensionType.System, true, language, true, undefined, this.getProductVersion())))
+            async (location) => this.extensionsScanner.scanExtension((await this.createExtensionScannerInput(location, false, ExtensionType.System, language, true, undefined, this.getProductVersion())))
         )));
         this.logService.trace('Scanned dev system extensions:', result.length);
         return coalesce(result);
@@ -349,7 +344,7 @@ let AbstractExtensionsScannerService = class AbstractExtensionsScannerService ex
             return {};
         }
     }
-    async createExtensionScannerInput(location, profile, type, excludeObsolete, language$1, validate, profileScanOptions, productVersion) {
+    async createExtensionScannerInput(location, profile, type, language$1, validate, profileScanOptions, productVersion) {
         const translations = await this.getTranslations(language$1 ?? language);
         const mtime = await this.getMtime(location);
         const applicationExtensionsLocation = profile && !this.uriIdentityService.extUri.isEqual(location, this.userDataProfilesService.defaultProfile.extensionsResource) ? this.userDataProfilesService.defaultProfile.extensionsResource : undefined;
@@ -362,7 +357,6 @@ let AbstractExtensionsScannerService = class AbstractExtensionsScannerService ex
             profile,
             profileScanOptions,
             type,
-            excludeObsolete,
             validate,
             productVersion.version,
             productVersion.date,
@@ -401,7 +395,7 @@ AbstractExtensionsScannerService = ( __decorate([
     ( __param(11, IInstantiationService))
 ], AbstractExtensionsScannerService));
 class ExtensionScannerInput {
-    constructor(location, mtime, applicationExtensionslocation, applicationExtensionslocationMtime, profile, profileScanOptions, type, excludeObsolete, validate, productVersion, productDate, productCommit, devMode, language, translations) {
+    constructor(location, mtime, applicationExtensionslocation, applicationExtensionslocationMtime, profile, profileScanOptions, type, validate, productVersion, productDate, productCommit, devMode, language, translations) {
         this.location = location;
         this.mtime = mtime;
         this.applicationExtensionslocation = applicationExtensionslocation;
@@ -409,7 +403,6 @@ class ExtensionScannerInput {
         this.profile = profile;
         this.profileScanOptions = profileScanOptions;
         this.type = type;
-        this.excludeObsolete = excludeObsolete;
         this.validate = validate;
         this.productVersion = productVersion;
         this.productDate = productDate;
@@ -434,7 +427,6 @@ class ExtensionScannerInput {
             && a.profile === b.profile
             && equals(a.profileScanOptions, b.profileScanOptions)
             && a.type === b.type
-            && a.excludeObsolete === b.excludeObsolete
             && a.validate === b.validate
             && a.productVersion === b.productVersion
             && a.productDate === b.productDate
@@ -455,7 +447,7 @@ let ExtensionManifestTranslator = class ExtensionManifestTranslator extends Disp
         const reportErrors = (localized, errors) => {
             errors.forEach((error) => {
                 this.logService.error(this.formatMessage(extensionLocation, ( localize(
-                    1714,
+                    1749,
                     "Failed to parse {0}: {1}.",
                     localized?.path,
                     getParseErrorMessage(error.error)
@@ -463,7 +455,7 @@ let ExtensionManifestTranslator = class ExtensionManifestTranslator extends Disp
             });
         };
         const reportInvalidFormat = (localized) => {
-            this.logService.error(this.formatMessage(extensionLocation, ( localize(1715, "Invalid format {0}: JSON object expected.", localized?.path))));
+            this.logService.error(this.formatMessage(extensionLocation, ( localize(1750, "Invalid format {0}: JSON object expected.", localized?.path))));
         };
         const translationId = `${extensionManifest.publisher}.${extensionManifest.name}`;
         const translationPath = nlsConfiguration.translations[translationId];
@@ -533,7 +525,7 @@ let ExtensionManifestTranslator = class ExtensionManifestTranslator extends Disp
                 if (errors.length > 0) {
                     errors.forEach((error) => {
                         this.logService.error(this.formatMessage(extensionLocation, ( localize(
-                            1714,
+                            1749,
                             "Failed to parse {0}: {1}.",
                             localizedMessages.default?.path,
                             getParseErrorMessage(error.error)
@@ -543,7 +535,7 @@ let ExtensionManifestTranslator = class ExtensionManifestTranslator extends Disp
                 }
                 else if (getNodeType(localizedMessages) !== 'object') {
                     this.logService.error(this.formatMessage(extensionLocation, ( localize(
-                        1715,
+                        1750,
                         "Invalid format {0}: JSON object expected.",
                         localizedMessages.default?.path
                     ))));
@@ -601,25 +593,17 @@ ExtensionManifestTranslator = ( __decorate([
     ( __param(1, ILogService))
 ], ExtensionManifestTranslator));
 let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTranslator {
-    constructor(obsoleteFile, extensionsProfileScannerService, uriIdentityService, fileService, productService, environmentService, logService) {
+    constructor(extensionsProfileScannerService, uriIdentityService, fileService, productService, environmentService, logService) {
         super(fileService, logService);
-        this.obsoleteFile = obsoleteFile;
         this.extensionsProfileScannerService = extensionsProfileScannerService;
         this.uriIdentityService = uriIdentityService;
         this.environmentService = environmentService;
         this.extensionsEnabledWithApiProposalVersion = productService.extensionsEnabledWithApiProposalVersion?.map(id => id.toLowerCase()) ?? [];
     }
     async scanExtensions(input) {
-        const extensions = input.profile ? await this.scanExtensionsFromProfile(input) : await this.scanExtensionsFromLocation(input);
-        let obsolete = {};
-        if (input.excludeObsolete && input.type === ExtensionType.User) {
-            try {
-                const raw = ( (await this.fileService.readFile(this.obsoleteFile)).value.toString());
-                obsolete = JSON.parse(raw);
-            }
-            catch (error) {  }
-        }
-        return isEmptyObject(obsolete) ? extensions : extensions.filter(e => !obsolete[( ExtensionKey.create(e).toString())]);
+        return input.profile
+            ? this.scanExtensionsFromProfile(input)
+            : this.scanExtensionsFromLocation(input);
     }
     async scanExtensionsFromLocation(input) {
         const stat = await this.fileService.resolve(input.location);
@@ -641,7 +625,6 @@ let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTransla
                 input.profile,
                 input.profileScanOptions,
                 input.type,
-                input.excludeObsolete,
                 input.validate,
                 input.productVersion,
                 input.productDate,
@@ -679,7 +662,6 @@ let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTransla
                     input.profile,
                     input.profileScanOptions,
                     input.type,
-                    input.excludeObsolete,
                     input.validate,
                     input.productVersion,
                     input.productDate,
@@ -688,7 +670,7 @@ let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTransla
                     input.language,
                     input.translations
                 ));
-                return this.scanExtension(extensionScannerInput, extensionInfo.metadata);
+                return this.scanExtension(extensionScannerInput, extensionInfo);
             }
             return null;
         })));
@@ -709,55 +691,74 @@ let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTransla
             return [];
         }
     }
-    async scanExtension(input, metadata) {
+    async scanExtension(input, scannedProfileExtension) {
+        const validations = [];
+        let isValid = true;
+        let manifest;
         try {
-            let manifest = await this.scanExtensionManifest(input.location);
-            if (manifest) {
-                if (!manifest.publisher) {
-                    manifest.publisher = UNDEFINED_PUBLISHER;
-                }
-                metadata = metadata ?? manifest.__metadata;
-                if (metadata && !metadata?.size && manifest.__metadata?.size) {
-                    metadata.size = manifest.__metadata?.size;
-                }
-                delete manifest.__metadata;
-                const id = getGalleryExtensionId(manifest.publisher, manifest.name);
-                const identifier = metadata?.id ? { id, uuid: metadata.id } : { id };
-                const type = metadata?.isSystem ? ExtensionType.System : input.type;
-                const isBuiltin = type === ExtensionType.System || !!metadata?.isBuiltin;
-                manifest = await this.translateManifest(input.location, manifest, ExtensionScannerInput.createNlsConfiguration(input));
-                let extension = {
-                    type,
-                    identifier,
-                    manifest,
-                    location: input.location,
-                    isBuiltin,
-                    targetPlatform: metadata?.targetPlatform ?? TargetPlatform.UNDEFINED,
-                    publisherDisplayName: metadata?.publisherDisplayName,
-                    metadata,
-                    isValid: true,
-                    validations: [],
-                    preRelease: !!metadata?.preRelease,
+            manifest = await this.scanExtensionManifest(input.location);
+        }
+        catch (e) {
+            if (scannedProfileExtension) {
+                validations.push([Severity$1.Error, getErrorMessage(e)]);
+                isValid = false;
+                const [publisher, name] = scannedProfileExtension.identifier.id.split('.');
+                manifest = {
+                    name,
+                    publisher,
+                    version: scannedProfileExtension.version,
+                    engines: { vscode: '' }
                 };
-                if (input.validate) {
-                    extension = this.validate(extension, input);
-                }
-                if (manifest.enabledApiProposals && (!this.environmentService.isBuilt || this.extensionsEnabledWithApiProposalVersion.includes(id.toLowerCase()))) {
-                    manifest.originalEnabledApiProposals = manifest.enabledApiProposals;
-                    manifest.enabledApiProposals = parseEnabledApiProposalNames([...manifest.enabledApiProposals]);
+            }
+            else {
+                if (input.type !== ExtensionType.System) {
+                    this.logService.error(e);
                 }
-                return extension;
+                return null;
             }
         }
-        catch (e) {
-            if (input.type !== ExtensionType.System) {
-                this.logService.error(e);
-            }
+        if (!manifest.publisher) {
+            manifest.publisher = UNDEFINED_PUBLISHER;
         }
-        return null;
+        const metadata = scannedProfileExtension?.metadata ?? manifest.__metadata;
+        if (metadata && !metadata?.size && manifest.__metadata?.size) {
+            metadata.size = manifest.__metadata?.size;
+        }
+        delete manifest.__metadata;
+        const id = getGalleryExtensionId(manifest.publisher, manifest.name);
+        const identifier = metadata?.id ? { id, uuid: metadata.id } : { id };
+        const type = metadata?.isSystem ? ExtensionType.System : input.type;
+        const isBuiltin = type === ExtensionType.System || !!metadata?.isBuiltin;
+        try {
+            manifest = await this.translateManifest(input.location, manifest, ExtensionScannerInput.createNlsConfiguration(input));
+        }
+        catch (error) {
+            this.logService.warn('Failed to translate manifest', getErrorMessage(error));
+        }
+        let extension = {
+            type,
+            identifier,
+            manifest,
+            location: input.location,
+            isBuiltin,
+            targetPlatform: metadata?.targetPlatform ?? TargetPlatform.UNDEFINED,
+            publisherDisplayName: metadata?.publisherDisplayName,
+            metadata,
+            isValid,
+            validations,
+            preRelease: !!metadata?.preRelease,
+        };
+        if (input.validate) {
+            extension = this.validate(extension, input);
+        }
+        if (manifest.enabledApiProposals && (!this.environmentService.isBuilt || this.extensionsEnabledWithApiProposalVersion.includes(id.toLowerCase()))) {
+            manifest.originalEnabledApiProposals = manifest.enabledApiProposals;
+            manifest.enabledApiProposals = parseEnabledApiProposalNames([...manifest.enabledApiProposals]);
+        }
+        return extension;
     }
     validate(extension, input) {
-        let isValid = true;
+        let isValid = extension.isValid;
         const validateApiVersion = this.environmentService.isBuilt && this.extensionsEnabledWithApiProposalVersion.includes(extension.identifier.id.toLowerCase());
         const validations = validateExtensionManifest(input.productVersion, input.productDate, input.location, extension.manifest, extension.isBuiltin, validateApiVersion);
         for (const [severity, message] of validations) {
@@ -767,7 +768,7 @@ let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTransla
             }
         }
         extension.isValid = isValid;
-        extension.validations = validations;
+        extension.validations = [...extension.validations, ...validations];
         return extension;
     }
     async scanExtensionManifest(extensionLocation) {
@@ -778,9 +779,9 @@ let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTransla
         }
         catch (error) {
             if (toFileOperationResult(error) !== FileOperationResult.FILE_NOT_FOUND) {
-                this.logService.error(this.formatMessage(extensionLocation, ( localize(1716, "Cannot read file {0}: {1}.", manifestLocation.path, error.message))));
+                this.logService.error(this.formatMessage(extensionLocation, ( localize(1751, "Cannot read file {0}: {1}.", manifestLocation.path, error.message))));
             }
-            return null;
+            throw error;
         }
         let manifest;
         try {
@@ -791,7 +792,7 @@ let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTransla
             parse(content, errors);
             for (const e of errors) {
                 this.logService.error(this.formatMessage(extensionLocation, ( localize(
-                    1717,
+                    1752,
                     "Failed to parse {0}: [{1}, {2}] {3}.",
                     manifestLocation.path,
                     e.offset,
@@ -799,30 +800,31 @@ let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTransla
                     getParseErrorMessage(e.error)
                 ))));
             }
-            return null;
+            throw err;
         }
         if (getNodeType(manifest) !== 'object') {
-            this.logService.error(this.formatMessage(extensionLocation, ( localize(
-                1718,
+            const errorMessage = this.formatMessage(extensionLocation, ( localize(
+                1753,
                 "Invalid manifest file {0}: Not a JSON object.",
                 manifestLocation.path
-            ))));
-            return null;
+            )));
+            this.logService.error(errorMessage);
+            throw ( new Error(errorMessage));
         }
         return manifest;
     }
 };
 ExtensionsScanner = ( __decorate([
-    ( __param(1, IExtensionsProfileScannerService)),
-    ( __param(2, IUriIdentityService)),
-    ( __param(3, IFileService)),
-    ( __param(4, IProductService)),
-    ( __param(5, IEnvironmentService)),
-    ( __param(6, ILogService))
+    ( __param(0, IExtensionsProfileScannerService)),
+    ( __param(1, IUriIdentityService)),
+    ( __param(2, IFileService)),
+    ( __param(3, IProductService)),
+    ( __param(4, IEnvironmentService)),
+    ( __param(5, ILogService))
 ], ExtensionsScanner));
 let CachedExtensionsScanner = class CachedExtensionsScanner extends ExtensionsScanner {
-    constructor(currentProfile, obsoleteFile, userDataProfilesService, extensionsProfileScannerService, uriIdentityService, fileService, productService, environmentService, logService) {
-        super(obsoleteFile, extensionsProfileScannerService, uriIdentityService, fileService, productService, environmentService, logService);
+    constructor(currentProfile, userDataProfilesService, extensionsProfileScannerService, uriIdentityService, fileService, productService, environmentService, logService) {
+        super(extensionsProfileScannerService, uriIdentityService, fileService, productService, environmentService, logService);
         this.currentProfile = currentProfile;
         this.userDataProfilesService = userDataProfilesService;
         this.cacheValidatorThrottler = this._register(( new ThrottledDelayer(3000)));
@@ -905,13 +907,13 @@ let CachedExtensionsScanner = class CachedExtensionsScanner extends ExtensionsSc
     }
 };
 CachedExtensionsScanner = ( __decorate([
-    ( __param(2, IUserDataProfilesService)),
-    ( __param(3, IExtensionsProfileScannerService)),
-    ( __param(4, IUriIdentityService)),
-    ( __param(5, IFileService)),
-    ( __param(6, IProductService)),
-    ( __param(7, IEnvironmentService)),
-    ( __param(8, ILogService))
+    ( __param(1, IUserDataProfilesService)),
+    ( __param(2, IExtensionsProfileScannerService)),
+    ( __param(3, IUriIdentityService)),
+    ( __param(4, IFileService)),
+    ( __param(5, IProductService)),
+    ( __param(6, IEnvironmentService)),
+    ( __param(7, ILogService))
 ], CachedExtensionsScanner));
 
 export { AbstractExtensionsScannerService, ExtensionManifestTranslator, ExtensionScannerInput, Translations };

package/vscode/src/vs/platform/extensionManagement/common/extensionsScannerService.service.d.ts

@@ -1,23 +1,22 @@
 import { Event } from "../../../base/common/event.js";
 import { URI } from "../../../base/common/uri.js";
-import { ExtensionType, TargetPlatform } from "../../extensions/common/extensions.js";
+import { ExtensionType } from "../../extensions/common/extensions.js";
 import { Metadata } from "./extensionManagement.js";
-import { ScanOptions, IScannedExtension } from "./extensionsScannerService.js";
+import { SystemExtensionsScanOptions, UserExtensionsScanOptions, IScannedExtension, ScanOptions } from "./extensionsScannerService.js";
 export declare const IExtensionsScannerService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IExtensionsScannerService>;
 export interface IExtensionsScannerService {
     readonly _serviceBrand: undefined;
     readonly systemExtensionsLocation: URI;
     readonly userExtensionsLocation: URI;
     readonly onDidChangeCache: Event<ExtensionType>;
-    getTargetPlatform(): Promise<TargetPlatform>;
-    scanAllExtensions(systemScanOptions: ScanOptions, userScanOptions: ScanOptions, includeExtensionsUnderDev: boolean): Promise<IScannedExtension[]>;
-    scanSystemExtensions(scanOptions: ScanOptions): Promise<IScannedExtension[]>;
-    scanUserExtensions(scanOptions: ScanOptions): Promise<IScannedExtension[]>;
-    scanExtensionsUnderDevelopment(scanOptions: ScanOptions, existingExtensions: IScannedExtension[]): Promise<IScannedExtension[]>;
+    scanAllExtensions(systemScanOptions: SystemExtensionsScanOptions, userScanOptions: UserExtensionsScanOptions): Promise<IScannedExtension[]>;
+    scanSystemExtensions(scanOptions: SystemExtensionsScanOptions): Promise<IScannedExtension[]>;
+    scanUserExtensions(scanOptions: UserExtensionsScanOptions): Promise<IScannedExtension[]>;
+    scanAllUserExtensions(): Promise<IScannedExtension[]>;
+    scanExtensionsUnderDevelopment(existingExtensions: IScannedExtension[], scanOptions: ScanOptions): Promise<IScannedExtension[]>;
     scanExistingExtension(extensionLocation: URI, extensionType: ExtensionType, scanOptions: ScanOptions): Promise<IScannedExtension | null>;
-    scanOneOrMultipleExtensions(extensionLocation: URI, extensionType: ExtensionType, scanOptions: ScanOptions): Promise<IScannedExtension[]>;
     scanMultipleExtensions(extensionLocations: URI[], extensionType: ExtensionType, scanOptions: ScanOptions): Promise<IScannedExtension[]>;
-    scanMetadata(extensionLocation: URI): Promise<Metadata | undefined>;
+    scanOneOrMultipleExtensions(extensionLocation: URI, extensionType: ExtensionType, scanOptions: ScanOptions): Promise<IScannedExtension[]>;
     updateMetadata(extensionLocation: URI, metadata: Partial<Metadata>): Promise<void>;
     initializeDefaultProfileExtensions(): Promise<void>;
 }