Add implicit activation events when scanning extensions

alexdima · alexdima · commit c783d5201410 · 2022-11-11T20:30:51.000+01:00
diff --git a/src/vs/platform/extensionManagement/common/extensionsScannerService.ts b/src/vs/platform/extensionManagement/common/extensionsScannerService.ts
@@ -36,6 +36,7 @@ import { IExtensionsProfileScannerService, IScannedProfileExtension } from 'vs/p
 import { IUserDataProfilesService } from 'vs/platform/userDataProfile/common/userDataProfile';
 import { IUriIdentityService } from 'vs/platform/uriIdentity/common/uriIdentity';
 import { localizeManifest } from 'vs/platform/extensionManagement/common/extensionNls';
+import { ImplicitActivationEvents } from 'vs/platform/extensionManagement/common/implicitActivationEvents';
 
 export type IScannedExtensionManifest = IRelaxedExtensionManifest & { __metadata?: Metadata };
 
@@ -577,6 +578,7 @@ class ExtensionsScanner extends Disposable {
 				const identifier = metadata?.id ? { id, uuid: metadata.id } : { id };
 				const type = metadata?.isSystem ? ExtensionType.System : input.type;
 				const isBuiltin = type === ExtensionType.System || !!metadata?.isBuiltin;
+				ImplicitActivationEvents.updateManifest(manifest);
 				manifest = await this.translateManifest(input.location, manifest, ExtensionScannerInput.createNlsConfiguration(input));
 				const extension = {
 					type,
diff --git a/src/vs/platform/extensionManagement/common/implicitActivationEvents.ts b/src/vs/platform/extensionManagement/common/implicitActivationEvents.ts
@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { onUnexpectedError } from 'vs/base/common/errors';
+import { IExtensionManifest } from 'vs/platform/extensions/common/extensions';
+
+export interface IActivationEventsGenerator<T> {
+	(contribution: T, result: { push(item: string): void }): void;
+}
+
+export class ImplicitActivationEventsImpl {
+
+	private readonly _generators = new Map<string, IActivationEventsGenerator<any>>();
+
+	public register<T>(extensionPointName: string, generator: IActivationEventsGenerator<T>): void {
+		this._generators.set(extensionPointName, generator);
+	}
+
+	public updateManifest(manifest: IExtensionManifest) {
+		if (!Array.isArray(manifest.activationEvents) || !manifest.contributes) {
+			return;
+		}
+		if (typeof manifest.main === 'undefined' && typeof manifest.browser === 'undefined') {
+			return;
+		}
+
+		for (const extPointName in manifest.contributes) {
+			const generator = this._generators.get(extPointName);
+			if (!generator) {
+				// There's no generator for this extension point
+				continue;
+			}
+			const contrib = (manifest.contributes as any)[extPointName];
+			const contribArr = Array.isArray(contrib) ? contrib : [contrib];
+			try {
+				generator(contribArr, manifest.activationEvents);
+			} catch (err) {
+				onUnexpectedError(err);
+			}
+		}
+	}
+}
+
+export const ImplicitActivationEvents: ImplicitActivationEventsImpl = new ImplicitActivationEventsImpl();
diff --git a/src/vs/platform/extensions/common/extensions.ts b/src/vs/platform/extensions/common/extensions.ts
@@ -399,8 +399,7 @@ export interface IRelaxedExtensionDescription extends IRelaxedExtensionManifest
 	browserNlsBundleUris?: { [language: string]: URI };
 }
 
-type MutableByKey<T extends {}, K extends keyof T> = Pick<T, K> & Readonly<Omit<T, K>>;
-export type IExtensionDescription = MutableByKey<IRelaxedExtensionDescription, 'activationEvents'>;
+export type IExtensionDescription = Readonly<IRelaxedExtensionDescription>;
 
 export function isApplicationScopedExtension(manifest: IExtensionManifest): boolean {
 	return isLanguagePackExtension(manifest);
diff --git a/src/vs/workbench/contrib/notebook/browser/notebookExtensionPoint.ts b/src/vs/workbench/contrib/notebook/browser/notebookExtensionPoint.ts
@@ -232,7 +232,14 @@ const notebookPreloadContribution: IJSONSchema = {
 
 export const notebooksExtensionPoint = ExtensionsRegistry.registerExtensionPoint<INotebookEditorContribution[]>({
 	extensionPoint: 'notebooks',
-	jsonSchema: notebookProviderContribution
+	jsonSchema: notebookProviderContribution,
+	activationEventsGenerator: (contribs: INotebookEditorContribution[], result: { push(item: string): void }) => {
+		for (const contrib of contribs) {
+			if (contrib.type) {
+				result.push(`onNotebookSerializer:${contrib.type}`);
+			}
+		}
+	}
 });
 
 export const notebookRendererExtensionPoint = ExtensionsRegistry.registerExtensionPoint<INotebookRendererContribution[]>({
diff --git a/src/vs/workbench/contrib/notebook/browser/services/notebookServiceImpl.ts b/src/vs/workbench/contrib/notebook/browser/services/notebookServiceImpl.ts
@@ -100,9 +100,7 @@ export class NotebookProviderInfoStore extends Disposable {
 			builtinProvidersFromCache.set(builtin.id, this.add(builtin));
 		});
 
-
 		for (const extension of extensions) {
-			const implicitActivationEvents: string[] = [];
 			for (const notebookContribution of extension.value) {
 
 				if (!notebookContribution.type) {
@@ -122,8 +120,6 @@ export class NotebookProviderInfoStore extends Disposable {
 					}
 				}
 
-				implicitActivationEvents.push(`onNotebookSerializer:${notebookContribution.type}`);
-
 				this.add(new NotebookProviderInfo({
 					extension: extension.description.identifier,
 					id: notebookContribution.type,
@@ -133,9 +129,7 @@ export class NotebookProviderInfoStore extends Disposable {
 					providerDisplayName: extension.description.displayName ?? extension.description.identifier.value,
 					exclusive: false
 				}));
-
 			}
-			extension.implicitActivationEventsCollector.addImplicitActivationEvents(implicitActivationEvents);
 		}
 
 		const mementoObject = this._memento.getMemento(StorageScope.PROFILE, StorageTarget.MACHINE);
diff --git a/src/vs/workbench/contrib/terminal/common/terminal.ts b/src/vs/workbench/contrib/terminal/common/terminal.ts
@@ -8,7 +8,7 @@ import { Event } from 'vs/base/common/event';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { IProcessEnvironment, OperatingSystem } from 'vs/base/common/platform';
 import { IExtensionPointDescriptor } from 'vs/workbench/services/extensions/common/extensionsRegistry';
-import { IProcessDataEvent, IProcessReadyEvent, IShellLaunchConfig, ITerminalChildProcess, ITerminalLaunchError, ITerminalProfile, ITerminalProfileObject, ITerminalsLayoutInfo, ITerminalsLayoutInfoById, TerminalIcon, TerminalLocationString, IProcessProperty, TitleEventSource, ProcessPropertyType, IFixedTerminalDimensions, IExtensionTerminalProfile, ICreateContributedTerminalProfileOptions, IProcessPropertyMap, ITerminalEnvironment, ITerminalProcessOptions } from 'vs/platform/terminal/common/terminal';
+import { IProcessDataEvent, IProcessReadyEvent, IShellLaunchConfig, ITerminalChildProcess, ITerminalLaunchError, ITerminalProfile, ITerminalProfileObject, ITerminalsLayoutInfo, ITerminalsLayoutInfoById, TerminalIcon, TerminalLocationString, IProcessProperty, TitleEventSource, ProcessPropertyType, IFixedTerminalDimensions, IExtensionTerminalProfile, ICreateContributedTerminalProfileOptions, IProcessPropertyMap, ITerminalEnvironment, ITerminalProcessOptions, ITerminalContributions } from 'vs/platform/terminal/common/terminal';
 import { IEnvironmentVariableInfo } from 'vs/workbench/contrib/terminal/common/environmentVariable';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { URI } from 'vs/base/common/uri';
@@ -710,7 +710,7 @@ export const DEFAULT_COMMANDS_TO_SKIP_SHELL: string[] = [
 	'workbench.action.toggleMaximizedPanel'
 ];
 
-export const terminalContributionsDescriptor: IExtensionPointDescriptor = {
+export const terminalContributionsDescriptor: IExtensionPointDescriptor<ITerminalContributions> = {
 	extensionPoint: 'terminal',
 	defaultExtensionKind: ['workspace'],
 	jsonSchema: {
diff --git a/src/vs/workbench/services/actions/common/menusExtensionPoint.ts b/src/vs/workbench/services/actions/common/menusExtensionPoint.ts
@@ -623,7 +623,14 @@ const _commandRegistrations = new DisposableStore();
 
 export const commandsExtensionPoint = ExtensionsRegistry.registerExtensionPoint<schema.IUserFriendlyCommand | schema.IUserFriendlyCommand[]>({
 	extensionPoint: 'commands',
-	jsonSchema: schema.commandsContribution
+	jsonSchema: schema.commandsContribution,
+	activationEventsGenerator: (contribs: schema.IUserFriendlyCommand[], result: { push(item: string): void }) => {
+		for (const contrib of contribs) {
+			if (contrib.command) {
+				result.push(`onCommand:${contrib.command}`);
+			}
+		}
+	}
 });
 
 commandsExtensionPoint.setHandler(extensions => {
@@ -662,8 +669,6 @@ commandsExtensionPoint.setHandler(extensions => {
 			precondition: ContextKeyExpr.deserialize(enablement),
 			icon: absoluteIcon
 		}));
-
-		extension.implicitActivationEventsCollector.addImplicitActivationEvents([`onCommand:${command}`]);
 	}
 
 	// remove all previous command registrations
diff --git a/src/vs/workbench/services/extensionManagement/browser/builtinExtensionsScannerService.ts b/src/vs/workbench/services/extensionManagement/browser/builtinExtensionsScannerService.ts
@@ -15,6 +15,7 @@ import { IExtensionResourceLoaderService } from 'vs/platform/extensionResourceLo
 import { IProductService } from 'vs/platform/product/common/productService';
 import { ITranslations, localizeManifest } from 'vs/platform/extensionManagement/common/extensionNls';
 import { ILogService } from 'vs/platform/log/common/log';
+import { ImplicitActivationEvents } from 'vs/platform/extensionManagement/common/implicitActivationEvents';
 
 interface IBundledExtension {
 	extensionPath: string;
@@ -74,6 +75,7 @@ export class BuiltinExtensionsScannerService implements IBuiltinExtensionsScanne
 						}
 						browserNlsBundleUris.en = uriIdentityService.extUri.resolvePath(builtinExtensionsServiceUrl!, e.browserNlsMetadataPath);
 					}
+					ImplicitActivationEvents.updateManifest(e.packageJSON);
 					return {
 						identifier: { id },
 						location: uriIdentityService.extUri.joinPath(builtinExtensionsServiceUrl!, e.extensionPath),
diff --git a/src/vs/workbench/services/extensionManagement/browser/webExtensionsScannerService.ts b/src/vs/workbench/services/extensionManagement/browser/webExtensionsScannerService.ts
@@ -43,6 +43,7 @@ import { IStringDictionary } from 'vs/base/common/collections';
 import { IUserDataProfileService } from 'vs/workbench/services/userDataProfile/common/userDataProfile';
 import { IUserDataProfilesService } from 'vs/platform/userDataProfile/common/userDataProfile';
 import { IUriIdentityService } from 'vs/platform/uriIdentity/common/uriIdentity';
+import { ImplicitActivationEvents } from 'vs/platform/extensionManagement/common/implicitActivationEvents';
 
 type GalleryExtensionInfo = { readonly id: string; preRelease?: boolean; migrateStorageFrom?: string };
 type ExtensionInfo = { readonly id: string; preRelease: boolean };
@@ -679,6 +680,8 @@ export class WebExtensionsScannerService extends Disposable implements IWebExten
 			};
 		}
 
+		ImplicitActivationEvents.updateManifest(manifest);
+
 		const packageNLSUri = webExtension.packageNLSUris?.get(Language.value().toLowerCase());
 		if (packageNLSUri || webExtension.fallbackPackageNLSUri) {
 			manifest = packageNLSUri
diff --git a/src/vs/workbench/services/extensions/common/abstractExtensionService.ts b/src/vs/workbench/services/extensions/common/abstractExtensionService.ts
@@ -15,8 +15,8 @@ import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementServ
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { INotificationService, Severity } from 'vs/platform/notification/common/notification';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-import { ActivationTimes, ExtensionPointContribution, IExtensionService, IExtensionsStatus, IMessage, IWillActivateEvent, IResponsiveStateChangeEvent, toExtension, IExtensionHost, ActivationKind, ExtensionHostKind, ExtensionRunningLocation, extensionHostKindToString, ExtensionActivationReason, IInternalExtensionService, RemoteRunningLocation, LocalProcessRunningLocation, LocalWebWorkerRunningLocation, IImplicitActivationEvents } from 'vs/workbench/services/extensions/common/extensions';
-import { ExtensionActivationEventsCollector, ExtensionMessageCollector, ExtensionPoint, ExtensionsRegistry, IExtensionPoint, IExtensionPointUser } from 'vs/workbench/services/extensions/common/extensionsRegistry';
+import { ActivationTimes, ExtensionPointContribution, IExtensionService, IExtensionsStatus, IMessage, IWillActivateEvent, IResponsiveStateChangeEvent, toExtension, IExtensionHost, ActivationKind, ExtensionHostKind, ExtensionRunningLocation, extensionHostKindToString, ExtensionActivationReason, IInternalExtensionService, RemoteRunningLocation, LocalProcessRunningLocation, LocalWebWorkerRunningLocation } from 'vs/workbench/services/extensions/common/extensions';
+import { ExtensionMessageCollector, ExtensionPoint, ExtensionsRegistry, IExtensionPoint, IExtensionPointUser } from 'vs/workbench/services/extensions/common/extensionsRegistry';
 import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/common/extensionDescriptionRegistry';
 import { ResponsiveState } from 'vs/workbench/services/extensions/common/rpcProtocol';
 import { createExtensionHostManager, IExtensionHostManager } from 'vs/workbench/services/extensions/common/extensionHostManager';
@@ -153,7 +153,6 @@ export abstract class AbstractExtensionService extends Disposable implements IEx
 	private readonly _installedExtensionsReady: Barrier;
 	private readonly _isDev: boolean;
 	private readonly _extensionsMessages: Map<string, IMessage[]>;
-	private readonly _extensionsImplicitActivationEvents: Map<string, Set<string>>;
 	private readonly _allRequestedActivateEvents = new Set<string>();
 	private readonly _proposedApiController: ProposedApiController;
 	private readonly _isExtensionDevHost: boolean;
@@ -207,7 +206,6 @@ export abstract class AbstractExtensionService extends Disposable implements IEx
 		this._installedExtensionsReady = new Barrier();
 		this._isDev = !this._environmentService.isBuilt || this._environmentService.isExtensionDevelopment;
 		this._extensionsMessages = new Map<string, IMessage[]>();
-		this._extensionsImplicitActivationEvents = new Map<string, Set<string>>();
 		this._proposedApiController = _instantiationService.createInstance(ProposedApiController);
 
 		this._extensionHostManagers = [];
@@ -1213,47 +1211,17 @@ export abstract class AbstractExtensionService extends Disposable implements IEx
 		}
 
 		const messageHandler = (msg: IMessage) => this._handleExtensionPointMessage(msg);
-		const implicitActivationEventsHandler = (info: IImplicitActivationEvents) => this._handleImplicitExtensionActivationEvents(info);
 		const availableExtensions = this._registry.getAllExtensionDescriptions();
 		const extensionPoints = ExtensionsRegistry.getExtensionPoints();
 		perf.mark('code/willHandleExtensionPoints');
 		for (const extensionPoint of extensionPoints) {
 			if (affectedExtensionPoints[extensionPoint.name]) {
 				perf.mark(`code/willHandleExtensionPoint/${extensionPoint.name}`);
-				AbstractExtensionService._handleExtensionPoint(extensionPoint, availableExtensions, messageHandler, implicitActivationEventsHandler);
+				AbstractExtensionService._handleExtensionPoint(extensionPoint, availableExtensions, messageHandler);
 				perf.mark(`code/didHandleExtensionPoint/${extensionPoint.name}`);
 			}
 		}
-		this._combineImplicitExtensionActivationEvents();
 		perf.mark('code/didHandleExtensionPoints');
-		this._registry.set(availableExtensions);
-	}
-
-	private _combineImplicitExtensionActivationEvents() {
-		for (const [extensionKey, implicitActivationEvents] of this._extensionsImplicitActivationEvents.entries()) {
-			const extensionDescription = this._registry.getExtensionDescription(extensionKey);
-			if (!extensionDescription) {
-				continue;
-			}
-
-			for (const activationEvents of (extensionDescription?.activationEvents ?? [])) {
-				implicitActivationEvents.add(activationEvents);
-			}
-			extensionDescription.activationEvents = Array.from(implicitActivationEvents);
-		}
-	}
-
-	private _handleImplicitExtensionActivationEvents(extensionActivationEventsInfo: IImplicitActivationEvents) {
-		const extensionKey = ExtensionIdentifier.toKey(extensionActivationEventsInfo.extensionId);
-
-		if (!this._extensionsImplicitActivationEvents.has(extensionKey)) {
-			this._extensionsImplicitActivationEvents.set(extensionKey, new Set());
-		}
-		const implicitActivationEvents = this._extensionsImplicitActivationEvents.get(extensionKey);
-
-		for (const activationEvent of extensionActivationEventsInfo.implicitActivationEvents) {
-			implicitActivationEvents?.add(activationEvent);
-		}
 	}
 
 	private _handleExtensionPointMessage(msg: IMessage) {
@@ -1305,15 +1273,14 @@ export abstract class AbstractExtensionService extends Disposable implements IEx
 		}
 	}
 
-	private static _handleExtensionPoint<T extends IExtensionContributions[keyof IExtensionContributions]>(extensionPoint: ExtensionPoint<T>, availableExtensions: IExtensionDescription[], messageHandler: (msg: IMessage) => void, implicitActivationEventsHandler: (info: IImplicitActivationEvents) => void): void {
+	private static _handleExtensionPoint<T extends IExtensionContributions[keyof IExtensionContributions]>(extensionPoint: ExtensionPoint<T>, availableExtensions: IExtensionDescription[], messageHandler: (msg: IMessage) => void): void {
 		const users: IExtensionPointUser<T>[] = [];
 		for (const desc of availableExtensions) {
 			if (desc.contributes && hasOwnProperty.call(desc.contributes, extensionPoint.name)) {
 				users.push({
 					description: desc,
 					value: desc.contributes[extensionPoint.name as keyof typeof desc.contributes] as T,
-					collector: new ExtensionMessageCollector(messageHandler, desc, extensionPoint.name),
-					implicitActivationEventsCollector: new ExtensionActivationEventsCollector(implicitActivationEventsHandler, desc),
+					collector: new ExtensionMessageCollector(messageHandler, desc, extensionPoint.name)
 				});
 			}
 		}
diff --git a/src/vs/workbench/services/extensions/common/extensions.ts b/src/vs/workbench/services/extensions/common/extensions.ts
@@ -40,11 +40,6 @@ export interface IMessage {
 	extensionPointId: string;
 }
 
-export interface IImplicitActivationEvents {
-	implicitActivationEvents: string[];
-	extensionId: ExtensionIdentifier;
-}
-
 export class LocalProcessRunningLocation {
 	public readonly kind = ExtensionHostKind.LocalProcess;
 	constructor(
@@ -561,12 +556,6 @@ export interface IExtensionService {
 	 * @param env New properties for the remote extension host
 	 */
 	setRemoteEnvironment(env: { [key: string]: string | null }): Promise<void>;
-
-	/**
-	 * Please do not use!
-	 * (This is public such that the extension host process can coordinate with and call back in the IExtensionService)
-	 */
-	_activateById(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
 }
 
 export interface IInternalExtensionService {
@@ -631,5 +620,4 @@ export class NullExtensionService implements IExtensionService {
 	async setRemoteEnvironment(_env: { [key: string]: string | null }): Promise<void> { }
 	canAddExtension(): boolean { return false; }
 	canRemoveExtension(): boolean { return false; }
-	_activateById(_extensionId: ExtensionIdentifier, _reason: ExtensionActivationReason): Promise<void> { return Promise.resolve(); }
 }
diff --git a/src/vs/workbench/services/extensions/common/extensionsRegistry.ts b/src/vs/workbench/services/extensions/common/extensionsRegistry.ts

Original file line number	Diff line number	Diff line change
`@@ -399,8 +399,7 @@ export interface IRelaxedExtensionDescription extends IRelaxedExtensionManifest`
`399`	`399`	`browserNlsBundleUris?: { [language: string]: URI };`
`400`	`400`	`}`
`401`	`401`
`402`		`-type MutableByKey<T extends {}, K extends keyof T> = Pick<T, K> & Readonly<Omit<T, K>>;`
`403`		`-export type IExtensionDescription = MutableByKey<IRelaxedExtensionDescription, 'activationEvents'>;`
	`402`	`+export type IExtensionDescription = Readonly<IRelaxedExtensionDescription>;`
`404`	`403`
`405`	`404`	`export function isApplicationScopedExtension(manifest: IExtensionManifest): boolean {`
`406`	`405`	`return isLanguagePackExtension(manifest);`
Original file line number	Diff line number	Diff line change
`@@ -100,9 +100,7 @@ export class NotebookProviderInfoStore extends Disposable {`
`100`	`100`	`builtinProvidersFromCache.set(builtin.id, this.add(builtin));`
`101`	`101`	`});`
`102`	`102`
`103`		`-`
`104`	`103`	`for (const extension of extensions) {`
`105`		`- const implicitActivationEvents: string[] = [];`
`106`	`104`	`for (const notebookContribution of extension.value) {`
`107`	`105`
`108`	`106`	`if (!notebookContribution.type) {`
`@@ -122,8 +120,6 @@ export class NotebookProviderInfoStore extends Disposable {`
`122`	`120`	`}`
`123`	`121`	`}`
`124`	`122`
`125`		- implicitActivationEvents.push(`onNotebookSerializer:${notebookContribution.type}`);
`126`		`-`
`127`	`123`	`this.add(new NotebookProviderInfo({`
`128`	`124`	`extension: extension.description.identifier,`
`129`	`125`	`id: notebookContribution.type,`
`@@ -133,9 +129,7 @@ export class NotebookProviderInfoStore extends Disposable {`
`133`	`129`	`providerDisplayName: extension.description.displayName ?? extension.description.identifier.value,`
`134`	`130`	`exclusive: false`
`135`	`131`	`}));`
`136`		`-`
`137`	`132`	`}`
`138`		`- extension.implicitActivationEventsCollector.addImplicitActivationEvents(implicitActivationEvents);`
`139`	`133`	`}`
`140`	`134`
`141`	`135`	`const mementoObject = this._memento.getMemento(StorageScope.PROFILE, StorageTarget.MACHINE);`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ import { IExtensionResourceLoaderService } from 'vs/platform/extensionResourceLo`
`15`	`15`	`import { IProductService } from 'vs/platform/product/common/productService';`
`16`	`16`	`import { ITranslations, localizeManifest } from 'vs/platform/extensionManagement/common/extensionNls';`
`17`	`17`	`import { ILogService } from 'vs/platform/log/common/log';`
	`18`	`+import { ImplicitActivationEvents } from 'vs/platform/extensionManagement/common/implicitActivationEvents';`
`18`	`19`
`19`	`20`	`interface IBundledExtension {`
`20`	`21`	`extensionPath: string;`
`@@ -74,6 +75,7 @@ export class BuiltinExtensionsScannerService implements IBuiltinExtensionsScanne`
`74`	`75`	`}`
`75`	`76`	`browserNlsBundleUris.en = uriIdentityService.extUri.resolvePath(builtinExtensionsServiceUrl!, e.browserNlsMetadataPath);`
`76`	`77`	`}`
	`78`	`+ ImplicitActivationEvents.updateManifest(e.packageJSON);`
`77`	`79`	`return {`
`78`	`80`	`identifier: { id },`
`79`	`81`	`location: uriIdentityService.extUri.joinPath(builtinExtensionsServiceUrl!, e.extensionPath),`