fix: Use a feature to handle file management

Author: CGNonofr

src/extensions.ts

@@ -1,10 +1,13 @@
+import { monaco, registerTextModelContentProvider } from '@codingame/monaco-editor-wrapper'
 import {
   Disposable,
   ServerCapabilities, DocumentSelector, MonacoLanguageClient, StaticFeature, Services,
-  TextDocumentSyncOptions, TextDocument, DidSaveTextDocumentNotification, Emitter
+  TextDocumentSyncOptions, TextDocument, DidSaveTextDocumentNotification, Emitter, DisposableCollection
 } from 'monaco-languageclient'
 import { updateFile, willShutdownNotificationType, WillShutdownParams } from './customRequests'
-import { LanguageClient } from './languageClient'
+import { Infrastructure } from './infrastructure'
+import { LanguageClient, LanguageClientManager } from './languageClient'
+import { getServices } from './services'
 
 interface ResolvedTextDocumentSyncCapabilities {
   resolvedTextDocumentSync?: TextDocumentSyncOptions
@@ -92,3 +95,38 @@ export class WillDisposeFeature implements StaticFeature {
 
   dispose (): void {}
 }
+
+export class FileSystemFeature implements StaticFeature {
+  private disposable: Disposable | undefined
+
+  constructor (private infrastructure: Infrastructure, private languageClientManager: LanguageClientManager) {}
+
+  private registerFileHandlers (): Disposable {
+    const disposableCollection = new DisposableCollection()
+    const infrastructure = this.infrastructure
+    const languageClientManager = this.languageClientManager
+    disposableCollection.push(registerTextModelContentProvider('file', {
+      async provideTextContent (resource: monaco.Uri): Promise<monaco.editor.ITextModel | null> {
+        return await infrastructure.getFileContent(resource, languageClientManager)
+      }
+    }))
+    disposableCollection.push(getServices().workspace.registerSaveDocumentHandler({
+      async saveTextContent (textDocument, reason) {
+        await infrastructure.saveFileContent?.(textDocument, reason, languageClientManager)
+      }
+    }))
+    return disposableCollection
+  }
+
+  fillClientCapabilities (): void {}
+
+  initialize (): void {
+    this.dispose()
+    this.disposable = this.registerFileHandlers()
+  }
+
+  dispose (): void {
+    this.disposable?.dispose()
+    this.disposable = undefined
+  }
+}

src/languageClient.ts

@@ -1,14 +1,12 @@
 import * as monaco from 'monaco-editor'
 import {
-  CloseAction, ErrorAction, MonacoLanguageClient, Emitter, Event, TextDocument, Services, State, DisposableCollection, CancellationToken, RequestType, NotificationType, LogMessageNotification, Disposable
+  CloseAction, ErrorAction, MonacoLanguageClient, Emitter, Event, TextDocument, Services, State, DisposableCollection, CancellationToken, RequestType, NotificationType, LogMessageNotification
 } from 'monaco-languageclient'
 import delay from 'delay'
-import { Uri } from 'monaco-editor'
-import { registerTextModelContentProvider } from '@codingame/monaco-editor-wrapper'
-import { getServices, installServices } from './services'
+import { installServices } from './services'
 import createLanguageClient from './createLanguageClient'
 import { WillShutdownParams } from './customRequests'
-import { InitializeTextDocumentFeature, WillDisposeFeature } from './extensions'
+import { FileSystemFeature, InitializeTextDocumentFeature, WillDisposeFeature } from './extensions'
 import { loadExtensionConfigurations } from './extensionConfiguration'
 import { getLanguageClientOptions, LanguageClientId, LanguageClientOptions } from './languageClientOptions'
 import { Infrastructure } from './infrastructure'
@@ -205,7 +203,6 @@ export class LanguageClientManager implements LanguageClient {
     this.languageClient = languageClient
 
     let readyPromise: Promise<void> | null = null
-    let fileHandlerRegistration: Disposable | null = null
     languageClient.onDidChangeState(async (state) => {
       switch (state.newState) {
         case State.Starting: {
@@ -242,7 +239,6 @@ export class LanguageClientManager implements LanguageClient {
           break
         }
         case State.Running: {
-          fileHandlerRegistration = this.registerFileHandlers()
           this.updateStatus('connected')
 
           await readyPromise
@@ -251,9 +247,6 @@ export class LanguageClientManager implements LanguageClient {
           break
         }
         case State.Stopped: {
-          fileHandlerRegistration?.dispose()
-          fileHandlerRegistration = null
-
           this.updateStatus('closed')
           break
         }
@@ -262,6 +255,8 @@ export class LanguageClientManager implements LanguageClient {
 
     this.languageClient.registerFeature(new WillDisposeFeature(this.languageClient, this.onWillShutdownEmitter))
 
+    this.languageClient.registerFeature(new FileSystemFeature(this.infrastructure, this))
+
     if (!this.infrastructure.automaticTextDocumentUpdate) {
       this.languageClient.registerFeature(new InitializeTextDocumentFeature(this))
     }
@@ -276,22 +271,6 @@ export class LanguageClientManager implements LanguageClient {
   sendRequest<P, R, E> (type: RequestType<P, R, E>, params: P): Promise<R> {
     return this.languageClient!.sendRequest<P, R, E>(type, params)
   }
-
-  private registerFileHandlers (): Disposable {
-    const disposableCollection = new DisposableCollection()
-    const languageClientManager = this
-    disposableCollection.push(registerTextModelContentProvider('file', {
-      async provideTextContent (resource: Uri): Promise<monaco.editor.ITextModel | null> {
-        return await languageClientManager.infrastructure.getFileContent(resource, languageClientManager)
-      }
-    }))
-    disposableCollection.push(getServices().workspace.registerSaveDocumentHandler({
-      async saveTextContent (textDocument, reason) {
-        await languageClientManager.infrastructure.saveFileContent?.(textDocument, reason, languageClientManager)
-      }
-    }))
-    return disposableCollection
-  }
 }
 
 /**