fix!: update code according to monaco update

Author: Loïc Mangeonjean

rollup.config.ts

@@ -111,7 +111,7 @@ export default rollup.defineConfig({
         '@babel/plugin-proposal-optional-chaining'
       ],
       babelHelpers: 'bundled',
-      exclude: /node_modules\/(?!monaco-languageclient|vscode-languageserver-types|vscode-languageclient)/
+      exclude: /node_modules\/(?!vscode-languageserver-types|vscode-languageclient)/
     }),
     visualizer(),
     alias({

src/createLanguageClient.ts

@@ -1,7 +1,8 @@
 import { MessageReader, MessageWriter, Message, Event, DataCallback, Disposable, PartialMessageInfo } from 'vscode-jsonrpc'
 import {
-  MonacoLanguageClient, Middleware, ErrorHandler, IConnectionProvider, MessageTransports
-} from 'monaco-languageclient'
+  Middleware, ErrorHandler, MessageTransports, BaseLanguageClient
+  , LanguageClientOptions as BaseLanguageClientOptions
+} from 'vscode-languageclient'
 import { InitializeParams, InitializeRequest } from 'vscode-languageserver-protocol'
 import { LanguageClientId, LanguageClientOptions } from './languageClientOptions'
 import { Infrastructure } from './infrastructure'
@@ -59,6 +60,20 @@ class MiddlewareMessageReader implements MessageReader {
   }
 }
 
+interface IConnectionProvider {
+    get(encoding: string): Promise<MessageTransports>
+}
+
+export class MonacoLanguageClient extends BaseLanguageClient {
+  constructor (id: string, name: string, clientOptions: BaseLanguageClientOptions, protected readonly connectionProvider: IConnectionProvider) {
+    super(id, name, clientOptions)
+  }
+
+  protected override createMessageTransports (encoding: string): Promise<MessageTransports> {
+    return this.connectionProvider.get(encoding)
+  }
+}
+
 /**
  * Add some hacks on transform for:
  * - Fix paths on windows
@@ -143,10 +158,9 @@ async function createLanguageClient (
     }
   }
 
-  const client = new _MonacoLanguageClient({
-    id: `${id}-languageclient`,
-    name: `CodinGame ${id} Language Client`,
-    clientOptions: {
+  const client = new _MonacoLanguageClient(
+    `${id}-languageclient`, `CodinGame ${id} Language Client`,
+    {
       // use a language id as a document selector
       documentSelector,
       // disable the default error handler
@@ -155,11 +169,9 @@ async function createLanguageClient (
       synchronize,
       initializationOptions: allInitializationOptions
     },
-    connectionProvider: new CGLSPConnectionProvider(id, infrastructure)
-  })
-  client.registerConfigurationFeatures()
-  client.registerProgressFeatures()
-  client.registerTextDocumentSaveFeatures()
+    new CGLSPConnectionProvider(id, infrastructure)
+  )
+  client.registerProposedFeatures()
 
   if (createAdditionalFeatures != null) {
     client.registerFeatures(await createAdditionalFeatures(client))

src/extensionConfiguration.ts

@@ -1,23 +1,10 @@
-import { loadConfigurationForExtension } from '@codingame/monaco-editor-wrapper/features/extensionConfigurations'
 import { registerDefaultConfigurations } from '@codingame/monaco-editor-wrapper'
 import { LanguageClientOptions } from './languageClientOptions'
 
 /**
  * Load the configuration schemas from vscode extensions
  * @param forLanguageClientIds Load the extensions related to these language client ids
- * @param useMutualizedProxy The language server proxy is used, so we only need to load configurations for language servers which are not mutualized
  */
-export async function loadExtensionConfigurations (clientOptions: LanguageClientOptions[], useMutualizedProxy: boolean): Promise<void> {
-  const extensionConfigurationToLoad = new Set<string>()
-  for (const clientOption of clientOptions) {
-    if (!clientOption.mutualizable || !useMutualizedProxy) {
-      clientOption.vscodeExtensionIds?.forEach(extensionId => {
-        extensionConfigurationToLoad.add(extensionId)
-      })
-    }
-  }
-
-  await Promise.all(Array.from(extensionConfigurationToLoad).map(extensionId => loadConfigurationForExtension(extensionId)))
-
+export async function loadExtensionConfigurations (clientOptions: LanguageClientOptions[]): Promise<void> {
   registerDefaultConfigurations(clientOptions.map(clientOption => clientOption.defaultConfigurationOverride).filter(<T> (v: T): v is Exclude<T, null | undefined> => v != null))
 }

src/extensions.ts

@@ -1,14 +1,14 @@
-import { monaco, registerTextModelContentProvider } from '@codingame/monaco-editor-wrapper'
-import {
-  MonacoLanguageClient, DisposableCollection
-} from 'monaco-languageclient'
+import { monaco } from '@codingame/monaco-editor-wrapper'
+import { FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, FileType, IFileSystemProviderWithFileReadWriteCapability, IStat, registerFileSystemOverlay } from '@codingame/monaco-vscode-files-service-override'
 import { StaticFeature, FeatureState } from 'vscode-languageclient/lib/common/api'
 import { DidSaveTextDocumentNotification, Disposable, DocumentSelector, Emitter, ServerCapabilities, TextDocumentSyncOptions } from 'vscode-languageserver-protocol'
 import * as vscode from 'vscode'
+import { IDisposable } from 'monaco-editor'
+import { DisposableStore } from 'vscode/monaco'
 import { willShutdownNotificationType, WillShutdownParams } from './customRequests'
 import { Infrastructure } from './infrastructure'
 import { LanguageClientManager } from './languageClient'
-import { getServices } from './services'
+import { MonacoLanguageClient } from './createLanguageClient'
 
 interface ResolvedTextDocumentSyncCapabilities {
   resolvedTextDocumentSync?: TextDocumentSyncOptions
@@ -31,7 +31,7 @@ export class InitializeTextDocumentFeature implements StaticFeature {
     const languageClient = this.languageClient
     async function saveFile (textDocument: vscode.TextDocument) {
       if (documentSelector != null && vscode.languages.match(documentSelector, textDocument) > 0 && textDocument.uri.scheme === 'file') {
-        await infrastructure.saveFileContent?.(textDocument, vscode.TextDocumentSaveReason.Manual, languageClient)
+        await infrastructure.saveFileContent?.(textDocument.uri, textDocument.getText(), languageClient)
 
         // Always send notification even if the server doesn't support it (because csharp register the didSave feature too late)
         await languageClient.sendNotification(DidSaveTextDocumentNotification.type, {
@@ -53,7 +53,7 @@ export class InitializeTextDocumentFeature implements StaticFeature {
     }
   }
 
-  dispose (): void {
+  clear (): void {
     this.didOpenTextDocumentDisposable?.dispose()
   }
 }
@@ -73,7 +73,78 @@ export class WillDisposeFeature implements StaticFeature {
     }
   }
 
-  dispose (): void {}
+  clear (): void {}
+}
+
+const encoder = new TextEncoder()
+const decoder = new TextDecoder()
+class InfrastructureTextFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
+  capabilities = FileSystemProviderCapabilities.FileReadWrite | FileSystemProviderCapabilities.PathCaseSensitive | FileSystemProviderCapabilities.Readonly
+  constructor (private infrastructure: Infrastructure, private languageClientManager: LanguageClientManager) {
+  }
+
+  private cachedContent: Map<string, Promise<string | undefined>> = new Map()
+  private async getFileContent (resource: monaco.Uri): Promise<string | undefined> {
+    if (!this.cachedContent.has(resource.toString()) && resource.toString().includes('.')) {
+      this.cachedContent.set(resource.toString(), this.infrastructure.getFileContent!(resource, this.languageClientManager))
+    }
+    return await this.cachedContent.get(resource.toString())
+  }
+
+  async readFile (resource: monaco.Uri): Promise<Uint8Array> {
+    if (!resource.toString().startsWith(this.infrastructure.rootUri)) {
+      throw FileSystemProviderError.create('file not found', FileSystemProviderErrorCode.FileNotFound)
+    }
+    const content = await this.getFileContent(resource)
+    return encoder.encode(content)
+  }
+
+  async writeFile (): Promise<void> {
+    throw FileSystemProviderError.create('not allowed', FileSystemProviderErrorCode.NoPermissions)
+  }
+
+  onDidChangeCapabilities = new vscode.EventEmitter<never>().event
+  onDidChangeFile = new vscode.EventEmitter<never>().event
+  watch (): IDisposable {
+    return {
+      dispose () {}
+    }
+  }
+
+  async stat (resource: monaco.Uri): Promise<IStat> {
+    if (!resource.toString().startsWith(this.infrastructure.rootUri)) {
+      throw FileSystemProviderError.create('file not found', FileSystemProviderErrorCode.FileNotFound)
+    }
+    try {
+      const content = await this.getFileContent(resource)
+      if (content != null) {
+        return {
+          type: FileType.File,
+          size: encoder.encode(content).length,
+          mtime: Date.now(),
+          ctime: Date.now()
+        }
+      }
+    } catch (err) {
+      throw FileSystemProviderError.create(err as Error, FileSystemProviderErrorCode.Unknown)
+    }
+    throw FileSystemProviderError.create('file not found', FileSystemProviderErrorCode.FileNotFound)
+  }
+
+  async mkdir (): Promise<void> {
+  }
+
+  async readdir () {
+    return []
+  }
+
+  delete (): Promise<void> {
+    throw new Error('Method not implemented.')
+  }
+
+  rename (): Promise<void> {
+    throw new Error('Method not implemented.')
+  }
 }
 
 export class FileSystemFeature implements StaticFeature {
@@ -82,22 +153,27 @@ export class FileSystemFeature implements StaticFeature {
   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 (document, reason) {
-        if (languageClientManager.isModelManaged(document) && document.uri.scheme === 'file') {
-          await infrastructure.saveFileContent?.(document, reason, languageClientManager)
+    const disposables = new DisposableStore()
+
+    // Register readonly file system overlay to access remote files
+    if (this.infrastructure.getFileContent != null) {
+      disposables.add(registerFileSystemOverlay(-1, new InfrastructureTextFileSystemProvider(this.infrastructure, this.languageClientManager)))
+    }
+
+    if (this.infrastructure.saveFileContent != null) {
+      const watcher = vscode.workspace.createFileSystemWatcher(new vscode.RelativePattern(vscode.Uri.parse(this.infrastructure.rootUri), '**/*'))
+      disposables.add(watcher)
+      const onFileChange = async (uri: vscode.Uri) => {
+        if ((await vscode.workspace.fs.stat(uri)).type === vscode.FileType.File) {
+          const content = await vscode.workspace.fs.readFile(uri)
+          await this.infrastructure.saveFileContent?.(uri, decoder.decode(content), this.languageClientManager)
         }
       }
-    }))
-    return disposableCollection
+      watcher.onDidChange(onFileChange)
+      watcher.onDidCreate(onFileChange)
+    }
+
+    return disposables
   }
 
   fillClientCapabilities (): void {}
@@ -117,4 +193,8 @@ export class FileSystemFeature implements StaticFeature {
     this.disposable?.dispose()
     this.disposable = undefined
   }
+
+  clear (): void {
+    this.dispose()
+  }
 }

src/extensions/cobol.ts

@@ -1,8 +1,7 @@
-import { MonacoLanguageClient } from 'monaco-languageclient'
-import { ProtocolRequestType } from 'vscode-languageclient/lib/common/api'
-import { DocumentSelector, ServerCapabilities } from 'vscode-languageserver-protocol'
+import { ProtocolRequestType, DocumentSelector, ServerCapabilities } from 'vscode-languageserver-protocol'
 import * as vscode from 'vscode'
 import { ExtensionFeature } from './tools'
+import { MonacoLanguageClient } from '../createLanguageClient'
 
 export const ResolveCobolSubroutineRequestType = new ProtocolRequestType<string, string | undefined, never, void, void>('cobol/resolveSubroutine')
 export class CobolResolveSubroutineFeature extends ExtensionFeature {

src/extensions/csharp.ts

@@ -1,7 +1,7 @@
-import { MonacoLanguageClient } from 'monaco-languageclient'
 import { Uri, ExtensionContext, workspace, CancellationToken } from 'vscode'
 import { ProtocolRequestType } from 'vscode-languageserver-protocol'
 import { ExtensionFeature } from './tools'
+import { MonacoLanguageClient } from '../createLanguageClient'
 
 const OmnisharpMetadataRequestType = new ProtocolRequestType<{
   Timeout: number

src/extensions/java.ts

@@ -1,4 +1,3 @@
-import { MonacoLanguageClient } from 'monaco-languageclient'
 import { commands, Uri, languages, ExtensionContext, workspace, CancellationToken } from 'vscode'
 import { Position as LSPosition, Location as LSLocation } from 'vscode-languageclient'
 import { JavaInlayHintsProvider } from 'extensions/java/inlayHintsProvider'
@@ -7,6 +6,7 @@ import { Commands } from 'extensions/java/commands'
 import { applyWorkspaceEdit } from 'extensions/java/extension'
 import { ClassFileContentsRequest } from 'extensions/java/protocol'
 import { ExtensionFeature } from './tools'
+import { MonacoLanguageClient } from '../createLanguageClient'
 
 export class JavaExtensionFeature extends ExtensionFeature {
   constructor (private languageClient: MonacoLanguageClient) {

src/extensions/tools.ts

@@ -1,4 +1,3 @@
-
 import { ExtensionContext } from 'vscode'
 import { FeatureState, StaticFeature } from 'vscode-languageclient/lib/browser/main'
 import { Disposable, DocumentSelector, ServerCapabilities } from 'vscode-languageserver-protocol'
@@ -46,6 +45,8 @@ class SimpleExtensionContext implements ExtensionContext, Disposable {
   get logPath () { return unsupported() }
   get extensionMode () { return unsupported() }
   get extension () { return unsupported() }
+  get extensionRuntime () { return unsupported() }
+  messagePassingProtocol = undefined
 }
 
 export abstract class ExtensionFeature implements StaticFeature {
@@ -64,7 +65,7 @@ export abstract class ExtensionFeature implements StaticFeature {
 
   protected abstract activate (context: ExtensionContext, capabilities: ServerCapabilities, documentSelector: DocumentSelector): void
 
-  dispose (): void {
+  clear (): void {
     this.context.dispose()
   }
 }

src/hacks.ts

@@ -1,8 +1,11 @@
+import { initializePromise } from '@codingame/monaco-editor-wrapper'
 import * as monaco from 'monaco-editor'
 
-monaco.editor.onWillDisposeModel(model => {
+void initializePromise.then(() => {
+  monaco.editor.onWillDisposeModel(model => {
   // We need to do it in a timeout or else the marker change event is delayed
-  setTimeout(() => {
-    monaco.editor.setModelMarkers(model, 'default', [])
+    setTimeout(() => {
+      monaco.editor.setModelMarkers(model, 'default', [])
+    })
   })
 })

src/index.ts

@@ -1,4 +1,4 @@
-import { MessageTransports } from 'monaco-languageclient'
+import { MessageTransports } from 'vscode-languageclient'
 import 'proxy-polyfill'
 import type { WorkspaceFolder } from 'vscode'
 import { CodinGameInfrastructure, Infrastructure } from './infrastructure'