Introduce the concept of a ConfigurationDependentRegistration

Abstract out a registration that depends on config. Use ConfigurationDependentRegistration for formatting registration

extensions/typescript-language-features/src/features/formatting.ts

@@ -4,12 +4,12 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-
 import * as Proto from '../protocol';
 import { ITypeScriptServiceClient } from '../typescriptService';
+import { ConfigurationDependentRegistration } from '../utils/dependentRegistration';
 import * as typeConverters from '../utils/typeConverters';
 import FileConfigurationManager from './fileConfigurationManager';
-import { disposeAll } from '../utils/dispose';
+
 
 class TypeScriptFormattingProvider implements vscode.DocumentRangeFormattingEditProvider, vscode.OnTypeFormattingEditProvider {
 	private enabled: boolean = true;
@@ -117,54 +117,17 @@ class TypeScriptFormattingProvider implements vscode.DocumentRangeFormattingEdit
 	}
 }
 
-class FormattingProviderManager {
-	private formattingProviderRegistration: vscode.Disposable | undefined;
-	private disposables: vscode.Disposable[] = [];
-	constructor(
-		private readonly modeId: string,
-		private readonly formattingProvider: TypeScriptFormattingProvider,
-		private readonly selector: vscode.DocumentSelector
-	) {
-		vscode.workspace.onDidChangeConfiguration(() => this.updateConfiguration(), null, this.disposables);
-	}
-
-	public dispose() {
-		disposeAll(this.disposables);
-
-		if (this.formattingProviderRegistration) {
-			this.formattingProviderRegistration.dispose();
-			this.formattingProviderRegistration = undefined;
-		}
-	}
-
-	public updateConfiguration(): void {
-		const config = vscode.workspace.getConfiguration(this.modeId);
-		this.formattingProvider.updateConfiguration(config);
-
-		if (!this.formattingProvider.isEnabled() && this.formattingProviderRegistration) {
-			this.formattingProviderRegistration.dispose();
-			this.formattingProviderRegistration = undefined;
-		} else if (this.formattingProvider.isEnabled() && !this.formattingProviderRegistration) {
-			this.formattingProviderRegistration = vscode.languages.registerDocumentRangeFormattingEditProvider(this.selector, this.formattingProvider);
-		}
-	}
-}
-
 export function register(
 	selector: vscode.DocumentSelector,
 	modeId: string,
-	config: vscode.WorkspaceConfiguration,
 	client: ITypeScriptServiceClient,
 	fileConfigurationManager: FileConfigurationManager
 ) {
-	const disposables: vscode.Disposable[] = [];
-	const formattingProvider = new TypeScriptFormattingProvider(client, fileConfigurationManager);
-	formattingProvider.updateConfiguration(config);
-	disposables.push(vscode.languages.registerOnTypeFormattingEditProvider(selector, formattingProvider, ';', '}', '\n'));
-
-	const formattingProviderManager = new FormattingProviderManager(modeId, formattingProvider, selector);
-	formattingProviderManager.updateConfiguration();
-	disposables.push(formattingProviderManager);
-
-	return vscode.Disposable.from(...disposables);
+	return new ConfigurationDependentRegistration(modeId, 'format.enable', () => {
+		const formattingProvider = new TypeScriptFormattingProvider(client, fileConfigurationManager);
+		return vscode.Disposable.from(
+			vscode.languages.registerOnTypeFormattingEditProvider(selector, formattingProvider, ';', '}', '\n'),
+			vscode.languages.registerDocumentRangeFormattingEditProvider(selector, formattingProvider),
+		);
+	});
 }
\ No newline at end of file

extensions/typescript-language-features/src/languageProvider.ts

@@ -96,7 +96,6 @@ export default class LanguageProvider {
 		typingsStatus: TypingsStatus
 	): Promise<void> {
 		const selector = this.documentSelector;
-		const config = vscode.workspace.getConfiguration(this.id);
 
 		const cachedResponse = new CachedNavTreeResponse();
 
@@ -106,7 +105,7 @@ export default class LanguageProvider {
 		this.disposables.push((await import('./features/documentHighlight')).register(selector, client));
 		this.disposables.push((await import('./features/documentSymbol')).register(selector, client));
 		this.disposables.push((await import('./features/folding')).register(selector, client));
-		this.disposables.push((await import('./features/formatting')).register(selector, this.description.id, config, client, this.fileConfigurationManager));
+		this.disposables.push((await import('./features/formatting')).register(selector, this.description.id, client, this.fileConfigurationManager));
 		this.disposables.push((await import('./features/hover')).register(selector, client));
 		this.disposables.push((await import('./features/implementations')).register(selector, client));
 		this.disposables.push((await import('./features/implementationsCodeLens')).register(selector, this.description.id, client, cachedResponse));

extensions/typescript-language-features/src/utils/dependentRegistration.ts

@@ -38,7 +38,6 @@ class ConditionalRegistration {
 
 export class VersionDependentRegistration {
 	private readonly _registration: ConditionalRegistration;
-
 	private readonly _disposables: vscode.Disposable[] = [];
 
 	constructor(
@@ -64,3 +63,33 @@ export class VersionDependentRegistration {
 		this._registration.update(api.gte(this.minVersion));
 	}
 }
+
+
+export class ConfigurationDependentRegistration {
+	private readonly _registration: ConditionalRegistration;
+	private readonly _disposables: vscode.Disposable[] = [];
+
+	constructor(
+		private readonly language: string,
+		private readonly configValue: string,
+		register: () => vscode.Disposable,
+	) {
+		this._registration = new ConditionalRegistration(register);
+
+		this.update();
+
+		vscode.workspace.onDidChangeConfiguration(() => {
+			this.update();
+		}, null, this._disposables);
+	}
+
+	public dispose() {
+		disposeAll(this._disposables);
+		this._registration.dispose();
+	}
+
+	private update() {
+		const config = vscode.workspace.getConfiguration(this.language);
+		this._registration.update(!!config.get<boolean>(this.configValue));
+	}
+}