fix: Update code for new api

Author: CGNonofr

src/createLanguageClient.ts

@@ -1,8 +1,9 @@
 import { MessageReader, MessageWriter, Message, Event, DataCallback, Disposable, PartialMessageInfo } from 'vscode-jsonrpc'
 import { Uri } from 'monaco-editor'
 import {
-  MonacoLanguageClient, Middleware, ErrorHandler, IConnectionProvider, InitializeParams, RegistrationRequest, RegistrationParams, UnregistrationRequest, UnregistrationParams, LanguageClientOptions, MessageTransports, InitializeRequest
+  MonacoLanguageClient, Middleware, ErrorHandler, IConnectionProvider, LanguageClientOptions, MessageTransports
 } from 'monaco-languageclient'
+import { InitializeParams, InitializeRequest, RegistrationParams, RegistrationRequest, UnregistrationParams, UnregistrationRequest } from 'vscode-languageserver-protocol'
 import { registerExtensionFeatures } from './extensions'
 import { LanguageClientId } from './languageClientOptions'
 import { Infrastructure } from './infrastructure'

src/extensions.ts

@@ -1,10 +1,10 @@
 import { monaco, registerTextModelContentProvider } from '@codingame/monaco-editor-wrapper'
 import {
-  Disposable,
-  ServerCapabilities, DocumentSelector, MonacoLanguageClient, Services,
-  TextDocumentSyncOptions, TextDocument, DidSaveTextDocumentNotification, Emitter, DisposableCollection
+  Disposable, MonacoLanguageClient, DisposableCollection
 } from 'monaco-languageclient'
 import { StaticFeature, FeatureState, ProtocolRequestType } from 'vscode-languageclient/lib/common/api'
+import { DidSaveTextDocumentNotification, DocumentSelector, Emitter, ServerCapabilities, TextDocumentSyncOptions } from 'vscode-languageserver-protocol'
+import * as vscode from 'vscode'
 import { updateFile, willShutdownNotificationType, WillShutdownParams } from './customRequests'
 import { Infrastructure } from './infrastructure'
 import { LanguageClient, LanguageClientManager } from './languageClient'
@@ -28,22 +28,22 @@ export class InitializeTextDocumentFeature implements StaticFeature {
     }
 
     const languageClient = this.languageClient
-    async function saveFile (textDocument: TextDocument) {
-      if (Services.get().languages.match(documentSelector!, textDocument)) {
-        await updateFile(textDocument.uri, textDocument.getText(), languageClient)
+    async function saveFile (textDocument: vscode.TextDocument) {
+      if (documentSelector != null && vscode.languages.match(documentSelector, textDocument) > 0) {
+        await updateFile(textDocument.uri.toString(), textDocument.getText(), languageClient)
 
         // Always send notification even if the server doesn't support it (because csharp register the didSave feature too late)
-        languageClient.sendNotification(DidSaveTextDocumentNotification.type, {
+        await languageClient.sendNotification(DidSaveTextDocumentNotification.type, {
           textDocument: {
-            uri: textDocument.uri
+            uri: textDocument.uri.toString()
           },
           text: textDocument.getText()
         })
       }
     }
 
-    this.didOpenTextDocumentDisposable = Services.get().workspace.onDidOpenTextDocument(saveFile)
-    Services.get().workspace.textDocuments.forEach(saveFile)
+    this.didOpenTextDocumentDisposable = vscode.workspace.onDidOpenTextDocument(saveFile)
+    vscode.workspace.textDocuments.forEach(saveFile)
   }
 
   getState (): FeatureState {
@@ -66,18 +66,18 @@ class CobolResolveSubroutineFeature implements StaticFeature {
   fillClientCapabilities (): void {}
 
   initialize (capabilities: ServerCapabilities, documentSelector: DocumentSelector): void {
-    this.onRequestDisposable = this.languageClient.onRequest(ResolveCobolSubroutineRequestType, (routineName: string) => {
+    this.onRequestDisposable = this.languageClient.onRequest(ResolveCobolSubroutineRequestType, (routineName: string): string => {
       const constantRoutinePaths: Partial<Record<string, string>> = {
-        'assert-equals': `${Services.get().workspace.rootUri ?? 'file:/tmp/project'}/deps/assert-equals.cbl`
+        'assert-equals': `file:${vscode.workspace.rootPath ?? '/tmp/project'}/deps/assert-equals.cbl`
       }
       const contantRoutinePath = constantRoutinePaths[routineName.toLowerCase()]
       if (contantRoutinePath != null) {
         return contantRoutinePath
       }
-      return Services.get().workspace.textDocuments
-        .filter(textDocument => Services.get().languages.match(documentSelector, textDocument))
+      return vscode.workspace.textDocuments
+        .filter(textDocument => vscode.languages.match(documentSelector, textDocument))
         .filter(document => document.getText().match(new RegExp(`PROGRAM-ID\\.\\W+${routineName}\\.`, 'gi')))
-        .sort((a, b) => a.uri.localeCompare(b.uri))[0]?.uri
+        .sort((a, b) => a.uri.toString().localeCompare(b.uri.toString()))[0]?.uri.toString()
     })
   }
 
@@ -131,9 +131,9 @@ export class FileSystemFeature implements StaticFeature {
       }
     }))
     disposableCollection.push(getServices().workspace.registerSaveDocumentHandler({
-      async saveTextContent (textDocument, reason) {
-        if (languageClientManager.isModelManaged(textDocument)) {
-          await infrastructure.saveFileContent?.(textDocument, reason, languageClientManager)
+      async saveTextContent (document, reason) {
+        if (languageClientManager.isModelManaged(document)) {
+          await infrastructure.saveFileContent?.(document, reason, languageClientManager)
         }
       }
     }))

src/index.ts

@@ -1,4 +1,4 @@
-import { MessageTransports, TextDocument, TextDocumentSaveReason } from 'monaco-languageclient'
+import { MessageTransports } from 'monaco-languageclient'
 import 'proxy-polyfill'
 import type { WorkspaceFolder } from 'vscode'
 import { CodinGameInfrastructure, Infrastructure } from './infrastructure'
@@ -24,8 +24,6 @@ export type {
   WillShutdownParams,
   Infrastructure,
   WorkspaceFolder,
-  TextDocument,
-  TextDocumentSaveReason,
   LanguageClientOptions,
   LanguageClientManagerOptions,
   MessageTransports

src/infrastructure.ts

@@ -1,7 +1,9 @@
 import { IWebSocket, WebSocketMessageReader, WebSocketMessageWriter, toSocket } from '@codingame/monaco-jsonrpc'
-import { MessageTransports, TextDocument, TextDocumentSaveReason } from 'monaco-languageclient'
+import { MessageTransports } from 'monaco-languageclient'
 import * as monaco from 'monaco-editor'
 import type * as vscode from 'vscode'
+import { TextDocument } from 'vscode-languageserver-textdocument'
+import { TextDocumentSaveReason } from 'vscode-languageserver-protocol'
 import { getFile, updateFile } from './customRequests'
 import { LanguageClientManager } from './languageClient'
 import { LanguageClientId, LanguageClientOptions } from './languageClientOptions'
@@ -33,7 +35,7 @@ export interface Infrastructure {
    * @param reason The reason of the save
    * @param languageClient The languageclient we're trying to save the file to
    */
-  saveFileContent? (document: TextDocument, reason: TextDocumentSaveReason, languageClient: LanguageClientManager): Promise<void>
+  saveFileContent? (document: vscode.TextDocument, reason: vscode.TextDocumentSaveReason, languageClient: LanguageClientManager): Promise<void>
   /**
    * Get a text file content as a model
    * @param resource the Uri of the file
@@ -96,7 +98,7 @@ export abstract class CodinGameInfrastructure implements Infrastructure {
     name: 'main'
   }]
 
-  public async saveFileContent (document: TextDocument, reason: TextDocumentSaveReason, languageClient: LanguageClientManager): Promise<void> {
+  public async saveFileContent (document: vscode.TextDocument, reason: TextDocumentSaveReason, languageClient: LanguageClientManager): Promise<void> {
     if (languageClient.isConnected()) {
       await updateFile(document.uri.toString(), document.getText(), languageClient)
     }

src/languageClient.ts

@@ -1,8 +1,10 @@
 import * as monaco from 'monaco-editor'
 import {
-  CloseAction, ErrorAction, MonacoLanguageClient, Emitter, Event, TextDocument, Services, State, DisposableCollection, CancellationToken, RequestType, NotificationType, LogMessageNotification
+  CloseAction, ErrorAction, MonacoLanguageClient, State, DisposableCollection
 } from 'monaco-languageclient'
 import delay from 'delay'
+import { CancellationToken, Emitter, NotificationType, RequestType, Event, LogMessageNotification } from 'vscode-languageserver-protocol'
+import * as vscode from 'vscode'
 import { updateServices } from './services'
 import createLanguageClient from './createLanguageClient'
 import { WillShutdownParams } from './customRequests'
@@ -12,7 +14,7 @@ import { getLanguageClientOptions, LanguageClientId, LanguageClientOptions } fro
 import { Infrastructure } from './infrastructure'
 
 export interface LanguageClient {
-  sendNotification<P>(type: NotificationType<P>, params?: P): void
+  sendNotification<P>(type: NotificationType<P>, params?: P): Promise<void>
   sendRequest<P, R, E> (request: RequestType<P, R, E>, params: P, token?: CancellationToken): Promise<R>
 }
 
@@ -94,11 +96,11 @@ export class LanguageClientManager implements LanguageClient {
     return this.onErrorEmitter.event
   }
 
-  isModelManaged (document: TextDocument): boolean {
+  isModelManaged (document: vscode.TextDocument): boolean {
     if (this.clientOptions.documentSelector == null) {
       return false
     }
-    return Services.get().languages.match(this.clientOptions.documentSelector, document)
+    return vscode.languages.match(this.clientOptions.documentSelector, document) > 0
   }
 
   isDisposed (): boolean {

src/services.ts

@@ -1,47 +1,37 @@
 
-import * as monaco from 'monaco-editor'
-import {
-  Services, MonacoToProtocolConverter, ProtocolToMonacoConverter, MonacoLanguages, MonacoCommands
-} from 'monaco-languageclient'
-import { RenameFile, CreateFile, WorkspaceEdit, Disposable } from 'vscode-languageserver-protocol'
+import { Services } from 'vscode/services'
+import { WorkspaceEdit, Disposable } from 'vscode-languageserver-protocol'
+import * as vscode from 'vscode'
+import { createConverter as createProtocolConverter } from 'vscode-languageclient/lib/common/protocolConverter'
 import WatchableConsoleWindow from './services/WatchableConsoleWindow'
 import CodinGameMonacoWorkspace from './services/CodinGameMonacoWorkspace'
 import { Infrastructure } from './infrastructure'
 import CodinGameMonacoEnv from './services/CodinGameMonacoEnv'
 
 interface CgMonacoServices extends Services {
-  commands: MonacoCommands
-  languages: MonacoLanguages
   workspace: CodinGameMonacoWorkspace
   window: WatchableConsoleWindow
 }
 
-function installCommands (services: CgMonacoServices): Disposable {
+function installCommands (): Disposable {
   // Comes from https://github.com/redhat-developer/vscode-java/blob/9b0f0aca80cbefabad4c034fb5dd365d029f6170/src/extension.ts#L155-L160
   // Other commands needs to be implemented as well?
   // (https://github.com/eclipse/eclipse.jdt.ls/issues/376#issuecomment-333923685)
-  return services.commands.registerCommand('java.apply.workspaceEdit', (edit: WorkspaceEdit) => {
-    if (edit.documentChanges != null && edit.documentChanges.some(change => RenameFile.is(change) || CreateFile.is(change))) {
-      alert('Unimplemented command')
-      return
-    }
-
-    return services.workspace.applyEdit(edit)
+  const protocolConverter = createProtocolConverter(undefined, true, true)
+  return vscode.commands.registerCommand('java.apply.workspaceEdit', async (obj: WorkspaceEdit) => {
+    const edit = await protocolConverter.asWorkspaceEdit(obj)
+    return vscode.workspace.applyEdit(edit)
   })
 }
 
-const m2p = new MonacoToProtocolConverter(monaco)
-const p2m = new ProtocolToMonacoConverter(monaco)
 const services = {
-  commands: new MonacoCommands(monaco),
-  languages: new MonacoLanguages(monaco, p2m, m2p),
-  workspace: new CodinGameMonacoWorkspace(p2m, m2p, 'file:///tmp/project'),
+  workspace: new CodinGameMonacoWorkspace('file:///tmp/project'),
   window: new WatchableConsoleWindow(),
   env: new CodinGameMonacoEnv()
 }
 
-installCommands(services)
 Services.install(services)
+installCommands()
 
 function updateServices (infrastructure: Infrastructure): void {
   services.workspace.initialize(

src/services/CodinGameMonacoEnv.ts

@@ -1,6 +1,6 @@
 import {
   Env
-} from 'monaco-languageclient'
+} from 'vscode/services'
 
 /**
  * This function comes from vscode: https://github.com/microsoft/vscode/blob/85bf8af5b9661b0c7f9587d33b3cb61499f6e4b8/src/vs/base/browser/dom.ts#L1282

src/services/CodinGameMonacoWorkspace.ts

@@ -1,40 +1,43 @@
 import {
-  MonacoWorkspace, TextDocument, TextDocumentSaveReason,
-  ProtocolToMonacoConverter, MonacoToProtocolConverter, Emitter, Event, TextDocumentWillSaveEvent, Disposable, DisposableCollection
+  Disposable, DisposableCollection
 } from 'monaco-languageclient'
 import * as monaco from 'monaco-editor'
-import type * as vscode from 'vscode'
+import * as vscode from 'vscode'
+import { Workspace } from 'vscode/services'
+import { Event, Emitter, TextDocumentSaveReason } from 'vscode-languageserver-protocol'
 import Configuration from './Configuration'
 
 export interface ITextModelContentSaveHandler {
-  saveTextContent(document: TextDocument, reason: TextDocumentSaveReason): Promise<void>
+  saveTextContent(document: vscode.TextDocument, reason: TextDocumentSaveReason): Promise<void>
 }
 
-export default class CodinGameMonacoWorkspace extends MonacoWorkspace {
-  protected readonly onWillSaveTextDocumentEmitter = new Emitter<TextDocumentWillSaveEvent>()
+export default class CodinGameMonacoWorkspace implements Workspace {
+  protected readonly onWillSaveTextDocumentEmitter = new Emitter<vscode.TextDocumentWillSaveEvent>()
   private readonly savehandlers: ITextModelContentSaveHandler[] = []
-  protected readonly onDidSaveTextDocumentEmitter = new Emitter<TextDocument>()
+  protected readonly onDidSaveTextDocumentEmitter = new Emitter<vscode.TextDocument>()
 
-  configurations = new Configuration()
+  private configuration = new Configuration()
+
+  getConfiguration = (section?: string | undefined): vscode.WorkspaceConfiguration => {
+    return this.configuration.getConfiguration(section)
+  }
+
+  onDidChangeConfiguration = this.configuration.onDidChangeConfiguration
 
   private autoSaveModelDisposable: Disposable | undefined
 
   public workspaceFolders: typeof vscode.workspace.workspaceFolders
 
   constructor (
-    p2m: ProtocolToMonacoConverter,
-    m2p: MonacoToProtocolConverter,
-    rootUri: string | null = null
+    public readonly rootUri: string | null = null
   ) {
-    super(monaco, p2m, m2p, rootUri)
   }
 
   public initialize (
     rootUri: string | null = null,
     workspaceFolders: typeof vscode.workspace.workspaceFolders,
     autoSaveModels: boolean
   ): void {
-    this._rootUri = rootUri
     if (workspaceFolders != null) {
       this.workspaceFolders = workspaceFolders
     } else if (rootUri != null) {
@@ -53,11 +56,11 @@ export default class CodinGameMonacoWorkspace extends MonacoWorkspace {
     }
   }
 
-  get onWillSaveTextDocument (): Event<TextDocumentWillSaveEvent> {
+  get onWillSaveTextDocument (): Event<vscode.TextDocumentWillSaveEvent> {
     return this.onWillSaveTextDocumentEmitter.event
   }
 
-  get onDidSaveTextDocument (): Event<TextDocument> {
+  get onDidSaveTextDocument (): Event<vscode.TextDocument> {
     return this.onDidSaveTextDocumentEmitter.event
   }
 
@@ -71,10 +74,13 @@ export default class CodinGameMonacoWorkspace extends MonacoWorkspace {
     })
   }
 
-  async saveDocument (document: TextDocument, reason: TextDocumentSaveReason): Promise<void> {
+  async saveDocument (document: vscode.TextDocument, reason: TextDocumentSaveReason): Promise<void> {
     this.onWillSaveTextDocumentEmitter.fire({
-      textDocument: document,
-      reason
+      document,
+      reason,
+      waitUntil () {
+        // Ignored
+      }
     })
 
     try {
@@ -93,16 +99,17 @@ export default class CodinGameMonacoWorkspace extends MonacoWorkspace {
   private autoSaveModels (): Disposable {
     const disposableCollection = new DisposableCollection()
     const timeoutMap = new Map<string, number>()
-    disposableCollection.push(this.onDidChangeTextDocument(e => {
-      const timeout = timeoutMap.get(e.textDocument.uri)
+    disposableCollection.push(vscode.workspace.onDidChangeTextDocument(e => {
+      const uri = e.document.uri.toString()
+      const timeout = timeoutMap.get(uri)
       if (timeout != null) {
         window.clearTimeout(timeout)
-        timeoutMap.delete(e.textDocument.uri)
+        timeoutMap.delete(uri)
       }
-      timeoutMap.set(e.textDocument.uri, window.setTimeout(() => {
-        timeoutMap.delete(e.textDocument.uri)
-        this.saveDocument(e.textDocument, TextDocumentSaveReason.AfterDelay).catch((error: Error) => {
-          monaco.errorHandler.onUnexpectedError(new Error(`[LSP] Unable to save the document ${e.textDocument.uri.toString()}`, {
+      timeoutMap.set(uri, window.setTimeout(() => {
+        timeoutMap.delete(uri)
+        this.saveDocument(e.document, TextDocumentSaveReason.AfterDelay).catch((error: Error) => {
+          monaco.errorHandler.onUnexpectedError(new Error(`[LSP] Unable to save the document ${uri}`, {
             cause: error
           }))
         })
@@ -116,10 +123,9 @@ export default class CodinGameMonacoWorkspace extends MonacoWorkspace {
     return disposableCollection
   }
 
-  override dispose (): void {
-    super.dispose()
+  dispose (): void {
     this.autoSaveModelDisposable?.dispose()
-    this.configurations.dispose()
+    this.configuration.dispose()
     this.onWillSaveTextDocumentEmitter.dispose()
     this.onDidSaveTextDocumentEmitter.dispose()
   }