Fix microsoft#103405

Author: sandy081

src/vs/platform/extensions/common/extensions.ts

@@ -274,6 +274,10 @@ export function isLanguagePackExtension(manifest: IExtensionManifest): boolean {
 	return manifest.contributes && manifest.contributes.localizations ? manifest.contributes.localizations.length > 0 : false;
 }
 
+export function isAuthenticaionProviderExtension(manifest: IExtensionManifest): boolean {
+	return manifest.contributes && manifest.contributes.authentication ? manifest.contributes.authentication.length > 0 : false;
+}
+
 export interface IScannedExtension {
 	readonly identifier: IExtensionIdentifier;
 	readonly location: URI;

src/vs/workbench/contrib/extensions/browser/extensionsActions.ts

@@ -970,7 +970,7 @@ export class DisableForWorkspaceAction extends ExtensionAction {
 		if (this.extension && this.extension.local && this.runningExtensions.some(e => areSameExtensions({ id: e.identifier.value, uuid: e.uuid }, this.extension!.identifier) && this.workspaceContextService.getWorkbenchState() !== WorkbenchState.EMPTY)) {
 			this.enabled = this.extension.state === ExtensionState.Installed
 				&& (this.extension.enablementState === EnablementState.EnabledGlobally || this.extension.enablementState === EnablementState.EnabledWorkspace)
-				&& this.extensionEnablementService.canChangeEnablement(this.extension.local);
+				&& this.extensionEnablementService.canChangeWorkspaceEnablement(this.extension.local);
 		}
 	}
 

src/vs/workbench/services/extensionManagement/common/extensionEnablementService.ts

@@ -12,13 +12,14 @@ import { areSameExtensions } from 'vs/platform/extensionManagement/common/extens
 import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
 import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
 import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
-import { ExtensionType, IExtension } from 'vs/platform/extensions/common/extensions';
+import { ExtensionType, IExtension, isAuthenticaionProviderExtension, isLanguagePackExtension } from 'vs/platform/extensions/common/extensions';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { getExtensionKind } from 'vs/workbench/services/extensions/common/extensionsUtil';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 import { IProductService } from 'vs/platform/product/common/productService';
 import { StorageManager } from 'vs/platform/extensionManagement/common/extensionEnablementService';
 import { webWorkerExtHostConfig } from 'vs/workbench/services/extensions/common/extensions';
+import { IUserDataSyncAccountService } from 'vs/platform/userDataSync/common/userDataSyncAccount';
 
 const SOURCE = 'IWorkbenchExtensionEnablementService';
 
@@ -40,6 +41,7 @@ export class ExtensionEnablementService extends Disposable implements IWorkbench
 		@IConfigurationService private readonly configurationService: IConfigurationService,
 		@IExtensionManagementServerService private readonly extensionManagementServerService: IExtensionManagementServerService,
 		@IProductService private readonly productService: IProductService,
+		@IUserDataSyncAccountService private readonly userDataSyncAccountService: IUserDataSyncAccountService,
 	) {
 		super();
 		this.storageManger = this._register(new StorageManager(storageService));
@@ -66,7 +68,9 @@ export class ExtensionEnablementService extends Disposable implements IWorkbench
 	}
 
 	canChangeEnablement(extension: IExtension): boolean {
-		if (extension.manifest && extension.manifest.contributes && extension.manifest.contributes.localizations && extension.manifest.contributes.localizations.length) {
+		try {
+			this.throwErrorIfCannotChangeEnablement(extension);
+		} catch (error) {
 			return false;
 		}
 		const enablementState = this.getEnablementState(extension);
@@ -76,11 +80,47 @@ export class ExtensionEnablementService extends Disposable implements IWorkbench
 		return true;
 	}
 
+	private throwErrorIfCannotChangeEnablement(extension: IExtension): void {
+		if (isLanguagePackExtension(extension.manifest)) {
+			throw new Error(localize('cannot disable language pack extension', "Cannot disable {0} extension because it contributes language packs.", extension.manifest.displayName || extension.identifier.id));
+		}
+
+		if (this.userDataSyncAccountService.account &&
+			isAuthenticaionProviderExtension(extension.manifest) && extension.manifest.contributes!.authentication!.some(a => a.id === this.userDataSyncAccountService.account!.authenticationProviderId)) {
+			throw new Error(localize('cannot disable auth extension', "Cannot disable {0} extension because Settings Sync depends on it.", extension.manifest.displayName || extension.identifier.id));
+		}
+	}
+
+	canChangeWorkspaceEnablement(extension: IExtension): boolean {
+		if (!this.canChangeEnablement(extension)) {
+			return false;
+		}
+		try {
+			this.throwErrorIfCannotChangeWorkspaceEnablement(extension);
+		} catch (error) {
+			return false;
+		}
+		return true;
+	}
+
+	private throwErrorIfCannotChangeWorkspaceEnablement(extension: IExtension): void {
+		if (!this.hasWorkspace) {
+			throw new Error(localize('noWorkspace', "No workspace."));
+		}
+		if (isAuthenticaionProviderExtension(extension.manifest)) {
+			throw new Error(localize('cannot disable auth extension in workspace', "Cannot disable {0} extension in workspace because it contributes authentication providers", extension.manifest.displayName || extension.identifier.id));
+		}
+	}
+
 	async setEnablement(extensions: IExtension[], newState: EnablementState): Promise<boolean[]> {
 
 		const workspace = newState === EnablementState.DisabledWorkspace || newState === EnablementState.EnabledWorkspace;
-		if (workspace && !this.hasWorkspace) {
-			return Promise.reject(new Error(localize('noWorkspace', "No workspace.")));
+		for (const extension of extensions) {
+			if (workspace) {
+				this.throwErrorIfCannotChangeWorkspaceEnablement(extension);
+			} else {
+				this.throwErrorIfCannotChangeEnablement(extension);
+			}
 		}
 
 		const result = await Promise.all(extensions.map(e => this._setEnablement(e, newState)));
@@ -316,4 +356,4 @@ export class ExtensionEnablementService extends Disposable implements IWorkbench
 	}
 }
 
-registerSingleton(IWorkbenchExtensionEnablementService, ExtensionEnablementService, true);
+registerSingleton(IWorkbenchExtensionEnablementService, ExtensionEnablementService);

src/vs/workbench/services/extensionManagement/common/extensionManagement.ts

@@ -58,6 +58,11 @@ export interface IWorkbenchExtensionEnablementService {
 	 */
 	canChangeEnablement(extension: IExtension): boolean;
 
+	/**
+	 * Returns `true` if the enablement can be changed.
+	 */
+	canChangeWorkspaceEnablement(extension: IExtension): boolean;
+
 	/**
 	 * Returns `true` if the given extension identifier is enabled.
 	 */

src/vs/workbench/services/extensionManagement/test/browser/extensionEnablementService.test.ts

@@ -23,6 +23,7 @@ import { assign } from 'vs/base/common/objects';
 import { TestConfigurationService } from 'vs/platform/configuration/test/common/testConfigurationService';
 import { productService } from 'vs/workbench/test/browser/workbenchTestServices';
 import { GlobalExtensionEnablementService } from 'vs/platform/extensionManagement/common/extensionEnablementService';
+import { IUserDataSyncAccountService, UserDataSyncAccountService } from 'vs/platform/userDataSync/common/userDataSyncAccount';
 
 function createStorageService(instantiationService: TestInstantiationService): IStorageService {
 	let service = instantiationService.get(IStorageService);
@@ -51,7 +52,8 @@ export class TestExtensionEnablementService extends ExtensionEnablementService {
 			extensionManagementService,
 			instantiationService.get(IConfigurationService),
 			extensionManagementServerService,
-			productService
+			productService,
+			instantiationService.get(IUserDataSyncAccountService) || instantiationService.stub(IUserDataSyncAccountService, UserDataSyncAccountService)
 		);
 	}
 
@@ -371,6 +373,39 @@ suite('ExtensionEnablementService Test', () => {
 		assert.equal(testObject.canChangeEnablement(aLocalExtension('pub.a', { localizations: [{ languageId: 'gr', translations: [{ id: 'vscode', path: 'path' }] }] })), false);
 	});
 
+	test('test canChangeEnablement return true for auth extension', () => {
+		assert.equal(testObject.canChangeEnablement(aLocalExtension('pub.a', { authentication: [{ id: 'a', label: 'a' }] })), true);
+	});
+
+	test('test canChangeEnablement return true for auth extension when user data sync account does not depends on it', () => {
+		instantiationService.stub(IUserDataSyncAccountService, <Partial<IUserDataSyncAccountService>>{
+			account: { authenticationProviderId: 'b' }
+		});
+		testObject = new TestExtensionEnablementService(instantiationService);
+		assert.equal(testObject.canChangeEnablement(aLocalExtension('pub.a', { authentication: [{ id: 'a', label: 'a' }] })), true);
+	});
+
+	test('test canChangeEnablement return false for auth extension and user data sync account depends on it', () => {
+		instantiationService.stub(IUserDataSyncAccountService, <Partial<IUserDataSyncAccountService>>{
+			account: { authenticationProviderId: 'a' }
+		});
+		testObject = new TestExtensionEnablementService(instantiationService);
+		assert.equal(testObject.canChangeEnablement(aLocalExtension('pub.a', { authentication: [{ id: 'a', label: 'a' }] })), false);
+	});
+
+	test('test canChangeWorkspaceEnablement return true', () => {
+		assert.equal(testObject.canChangeWorkspaceEnablement(aLocalExtension('pub.a')), true);
+	});
+
+	test('test canChangeWorkspaceEnablement return false if there is no workspace', () => {
+		instantiationService.stub(IWorkspaceContextService, 'getWorkbenchState', WorkbenchState.EMPTY);
+		assert.equal(testObject.canChangeWorkspaceEnablement(aLocalExtension('pub.a')), false);
+	});
+
+	test('test canChangeWorkspaceEnablement return false for auth extension', () => {
+		assert.equal(testObject.canChangeWorkspaceEnablement(aLocalExtension('pub.a', { authentication: [{ id: 'a', label: 'a' }] })), false);
+	});
+
 	test('test canChangeEnablement return false when extensions are disabled in environment', () => {
 		instantiationService.stub(IWorkbenchEnvironmentService, { disableExtensions: true } as IWorkbenchEnvironmentService);
 		testObject = new TestExtensionEnablementService(instantiationService);