Merge pull request #49 from CodinGame/refactor-client-extensions

Refactor client extensions, add java inlay hints

Author: CGNonofr

package-lock.json

@@ -26,7 +26,7 @@
     "@codingame/monaco-editor-wrapper": "^1.14.5",
     "@codingame/monaco-jsonrpc": "^0.4.0",
     "sweetalert": "^2.1.2",
-    "vscode": "npm:@codingame/monaco-vscode-api@^1.68.3",
+    "vscode": "npm:@codingame/monaco-vscode-api@^1.68.4",
     "vscode-languageserver-protocol": "^3.17.1"
   },
   "devDependencies": {

package.json

@@ -1,11 +1,10 @@
 import { MessageReader, MessageWriter, Message, Event, DataCallback, Disposable, PartialMessageInfo } from 'vscode-jsonrpc'
 import { Uri } from 'monaco-editor'
 import {
-  MonacoLanguageClient, Middleware, ErrorHandler, IConnectionProvider, LanguageClientOptions, MessageTransports
+  MonacoLanguageClient, Middleware, ErrorHandler, IConnectionProvider, MessageTransports
 } from 'monaco-languageclient'
 import { InitializeParams, InitializeRequest, RegistrationParams, RegistrationRequest, UnregistrationParams, UnregistrationRequest } from 'vscode-languageserver-protocol'
-import { registerExtensionFeatures } from './extensions'
-import { LanguageClientId } from './languageClientOptions'
+import { LanguageClientId, LanguageClientOptions } from './languageClientOptions'
 import { Infrastructure } from './infrastructure'
 
 interface MessageMiddleware {
@@ -141,7 +140,8 @@ function createLanguageClient (
   {
     documentSelector,
     synchronize,
-    initializationOptions
+    initializationOptions,
+    createAdditionalFeatures
   }: LanguageClientOptions,
   errorHandler: ErrorHandler,
   middleware?: Middleware
@@ -164,7 +164,9 @@ function createLanguageClient (
   client.registerProgressFeatures()
   client.registerTextDocumentSaveFeatures()
 
-  registerExtensionFeatures(client, id)
+  if (createAdditionalFeatures != null) {
+    client.registerFeatures(createAdditionalFeatures(client))
+  }
 
   return client
 }

src/createLanguageClient.ts

@@ -2,7 +2,7 @@ import { monaco, registerTextModelContentProvider } from '@codingame/monaco-edit
 import {
   Disposable, MonacoLanguageClient, DisposableCollection
 } from 'monaco-languageclient'
-import { StaticFeature, FeatureState, ProtocolRequestType } from 'vscode-languageclient/lib/common/api'
+import { StaticFeature, FeatureState } 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'
@@ -57,47 +57,6 @@ export class InitializeTextDocumentFeature implements StaticFeature {
   }
 }
 
-export const ResolveCobolSubroutineRequestType = new ProtocolRequestType<string, string, never, void, void>('cobol/resolveSubroutine')
-class CobolResolveSubroutineFeature implements StaticFeature {
-  private onRequestDisposable: Disposable | undefined
-  constructor (private languageClient: MonacoLanguageClient) {
-  }
-
-  fillClientCapabilities (): void {}
-
-  initialize (capabilities: ServerCapabilities, documentSelector: DocumentSelector): void {
-    this.onRequestDisposable = this.languageClient.onRequest(ResolveCobolSubroutineRequestType, (routineName: string): string => {
-      const constantRoutinePaths: Partial<Record<string, string>> = {
-        'assert-equals': `file:${vscode.workspace.rootPath ?? '/tmp/project'}/deps/assert-equals.cbl`
-      }
-      const contantRoutinePath = constantRoutinePaths[routineName.toLowerCase()]
-      if (contantRoutinePath != null) {
-        return contantRoutinePath
-      }
-      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.toString().localeCompare(b.uri.toString()))[0]?.uri.toString()
-    })
-  }
-
-  getState (): FeatureState {
-    return {
-      kind: 'static'
-    }
-  }
-
-  dispose (): void {
-    this.onRequestDisposable?.dispose()
-  }
-}
-
-export function registerExtensionFeatures (client: MonacoLanguageClient, language: string): void {
-  if (language === 'cobol') {
-    client.registerFeature(new CobolResolveSubroutineFeature(client))
-  }
-}
-
 export class WillDisposeFeature implements StaticFeature {
   constructor (private languageClient: MonacoLanguageClient, private onWillShutdownEmitter: Emitter<WillShutdownParams>) {}
   fillClientCapabilities (): void {}

src/extensions.ts

@@ -0,0 +1,41 @@
+import {
+  Disposable, MonacoLanguageClient
+} from 'monaco-languageclient'
+import { StaticFeature, FeatureState, ProtocolRequestType } from 'vscode-languageclient/lib/common/api'
+import { DocumentSelector, ServerCapabilities } from 'vscode-languageserver-protocol'
+import * as vscode from 'vscode'
+
+export const ResolveCobolSubroutineRequestType = new ProtocolRequestType<string, string, never, void, void>('cobol/resolveSubroutine')
+export class CobolResolveSubroutineFeature implements StaticFeature {
+  private onRequestDisposable: Disposable | undefined
+  constructor (private languageClient: MonacoLanguageClient) {
+  }
+
+  fillClientCapabilities (): void {}
+
+  initialize (capabilities: ServerCapabilities, documentSelector: DocumentSelector): void {
+    this.onRequestDisposable = this.languageClient.onRequest(ResolveCobolSubroutineRequestType, (routineName: string): string => {
+      const constantRoutinePaths: Partial<Record<string, string>> = {
+        'assert-equals': `file:${vscode.workspace.rootPath ?? '/tmp/project'}/deps/assert-equals.cbl`
+      }
+      const contantRoutinePath = constantRoutinePaths[routineName.toLowerCase()]
+      if (contantRoutinePath != null) {
+        return contantRoutinePath
+      }
+      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.toString().localeCompare(b.uri.toString()))[0]?.uri.toString()
+    })
+  }
+
+  getState (): FeatureState {
+    return {
+      kind: 'static'
+    }
+  }
+
+  dispose (): void {
+    this.onRequestDisposable?.dispose()
+  }
+}

src/extensions/cobol.ts

@@ -0,0 +1,80 @@
+import {
+  DisposableCollection, MonacoLanguageClient
+} from 'monaco-languageclient'
+import { StaticFeature, FeatureState } from 'vscode-languageclient/lib/common/api'
+import { InlayHint, InlayHintParams, InlayHintRefreshRequest, InlayHintRequest, WorkspaceEdit } from 'vscode-languageserver-protocol'
+import * as vscode from 'vscode'
+
+async function asInlayHints (values: InlayHint[] | undefined | null, client: MonacoLanguageClient): Promise<vscode.InlayHint[] | undefined> {
+  if (!Array.isArray(values)) {
+    return undefined
+  }
+  return values.map(lsHint => asInlayHint(lsHint, client))
+}
+
+function asInlayHint (value: InlayHint, client: MonacoLanguageClient): vscode.InlayHint {
+  const label = value.label as string
+  const result = new vscode.InlayHint(client.protocol2CodeConverter.asPosition(value.position), label)
+  result.paddingRight = true
+  result.kind = vscode.InlayHintKind.Parameter
+  return result
+}
+
+/**
+ * Comes from https://github.com/redhat-developer/vscode-java/blob/9b6046eecc65fd47507f309a3ccc9add45c6d3be/src/inlayHintsProvider.ts#L5
+ */
+class JavaInlayHintsProvider implements vscode.InlayHintsProvider {
+  private onDidChange = new vscode.EventEmitter<void>()
+  public onDidChangeInlayHints = this.onDidChange.event
+
+  constructor (private client: MonacoLanguageClient) {
+    this.client.onRequest(InlayHintRefreshRequest.type, async () => {
+      this.onDidChange.fire()
+    })
+  }
+
+  public async provideInlayHints (document: vscode.TextDocument, range: vscode.Range, token: vscode.CancellationToken): Promise<vscode.InlayHint[] | undefined> {
+    const requestParams: InlayHintParams = {
+      textDocument: this.client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+      range: this.client.code2ProtocolConverter.asRange(range)
+    }
+    try {
+      const values = await this.client.sendRequest(InlayHintRequest.type, requestParams, token)
+      if (token.isCancellationRequested) {
+        return []
+      }
+      return asInlayHints(values, this.client)
+    } catch (error) {
+      return this.client.handleFailedRequest(InlayHintRequest.type, token, error, [])
+    }
+  }
+}
+
+export class JavaExtensionFeature implements StaticFeature {
+  private disposables: DisposableCollection
+  constructor (private languageClient: MonacoLanguageClient) {
+    this.disposables = new DisposableCollection()
+  }
+
+  fillClientCapabilities (): void {}
+
+  initialize (): void {
+    // Comes from https://github.com/redhat-developer/vscode-java/blob/9b6046eecc65fd47507f309a3ccc9add45c6d3be/src/standardLanguageClient.ts#L321
+    this.disposables.push(vscode.commands.registerCommand('java.apply.workspaceEdit', async (obj: WorkspaceEdit) => {
+      const edit = await this.languageClient.protocol2CodeConverter.asWorkspaceEdit(obj)
+      return vscode.workspace.applyEdit(edit)
+    }))
+
+    this.disposables.push(vscode.languages.registerInlayHintsProvider(this.languageClient.clientOptions.documentSelector!, new JavaInlayHintsProvider(this.languageClient)))
+  }
+
+  getState (): FeatureState {
+    return {
+      kind: 'static'
+    }
+  }
+
+  dispose (): void {
+    this.disposables.dispose()
+  }
+}

src/extensions/java.ts

@@ -6,13 +6,14 @@ import { WillShutdownParams } from './customRequests'
 import { loadExtensionConfigurations } from './extensionConfiguration'
 import './hacks'
 import { createLanguageClientManager, LanguageClientManager, LanguageClientManagerOptions, StatusChangeEvent } from './languageClient'
-import { LanguageClientId, LanguageClientOptions, registerLanguageClient } from './languageClientOptions'
+import { getLanguageClientOptions, LanguageClientId, LanguageClientOptions, registerLanguageClient } from './languageClientOptions'
 import { StaticLanguageClientId } from './staticOptions'
 
 export {
   loadExtensionConfigurations,
   createLanguageClientManager,
   registerLanguageClient,
+  getLanguageClientOptions,
   LanguageClientManager,
   CodinGameInfrastructure
 }

src/index.ts

@@ -1,4 +1,5 @@
-import { Disposable, LanguageClientOptions as MonacoLanguageClientOptions } from 'monaco-languageclient'
+import { Disposable, LanguageClientOptions as MonacoLanguageClientOptions, MonacoLanguageClient } from 'monaco-languageclient'
+import { StaticFeature, DynamicFeature } from 'vscode-languageclient/lib/common/api'
 import staticOptions, { StaticLanguageClientId } from './staticOptions'
 
 export type LanguageClientOptions = Pick<MonacoLanguageClientOptions, 'documentSelector' | 'synchronize' | 'initializationOptions' | 'middleware'> & {
@@ -17,6 +18,8 @@ export type LanguageClientOptions = Pick<MonacoLanguageClientOptions, 'documentS
    * The language server will only be considered ready after this log message was received
    */
   readinessMessageMatcher?: RegExp
+
+  createAdditionalFeatures?(client: MonacoLanguageClient): (StaticFeature | DynamicFeature<unknown>)[]
 }
 
 const dynamicOptions: Partial<Record<string, LanguageClientOptions>> = {}

src/languageClientOptions.ts

@@ -1,8 +1,5 @@
 
 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'
@@ -13,25 +10,13 @@ interface CgMonacoServices extends Services {
   window: WatchableConsoleWindow
 }
 
-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)
-  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 services = {
   workspace: new CodinGameMonacoWorkspace('file:///tmp/project'),
   window: new WatchableConsoleWindow(),
   env: new CodinGameMonacoEnv()
 }
 
 Services.install(services)
-installCommands()
 
 function updateServices (infrastructure: Infrastructure): void {
   services.workspace.initialize(

src/services.ts

@@ -52,12 +52,35 @@ class WatchableOutputChannel implements vscode.OutputChannel {
   }
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isMessageItem (item: any): item is vscode.MessageItem {
+  return item != null && item.title
+}
+
+function getMessage (item: string | vscode.MessageItem) {
+  return isMessageItem(item) ? item.title : item
+}
+
 export default class WatchableConsoleWindow implements Window {
   protected readonly onDidChangeChannelsEmitter = new monaco.Emitter<void>()
   protected readonly channels = new Map<string, WatchableOutputChannel>()
 
   async showMessage<T extends vscode.MessageOptions | string | vscode.MessageItem> (type: Severity, message: string, ...actions: T[]): Promise<T | undefined> {
-    const displayedMessage = message + '\n' + actions.map(action => `- ${(action as vscode.MessageItem).title}`).join('\n')
+    const optionsOrFirstItem = actions[0]
+    let items: (string | vscode.MessageItem)[]
+
+    let options: vscode.MessageOptions | undefined
+    if (typeof optionsOrFirstItem === 'string' || isMessageItem(optionsOrFirstItem)) {
+      items = actions as (string | vscode.MessageItem)[]
+    } else {
+      options = optionsOrFirstItem
+      items = actions.slice(1) as (string | vscode.MessageItem)[]
+    }
+
+    let displayedMessage = message
+    if (items.length > 0) {
+      displayedMessage = `${displayedMessage}\nActions:\n${items.map(action => `- ${getMessage(action)}`).join('\n')}`
+    }
 
     if (type === Severity.Error) {
       console.error('[LSP]', displayedMessage)
@@ -69,20 +92,25 @@ export default class WatchableConsoleWindow implements Window {
       console.info('[LSP]', displayedMessage)
     }
 
-    if (actions.length > 1) {
-      return swal({
-        text: message,
-        buttons: actions.reduce((acc, action, index) => ({
+    const defaultAction = items.find(item => isMessageItem(item) && (item.isCloseAffordance ?? false)) as T | undefined ?? actions[0]
+
+    if (items.length > 1) {
+      return (await swal({
+        title: message,
+        text: options?.detail,
+        closeOnEsc: true,
+        closeOnClickOutside: true,
+        buttons: items.reduce((acc, action, index) => ({
           ...acc,
           [`option-${index}`]: {
-            text: (action as vscode.MessageItem).title,
+            text: getMessage(action),
             value: action
           }
         }), {})
-      })
+      })) ?? defaultAction
     }
 
-    return actions[0]
+    return defaultAction
   }
 
   createOutputChannel (name: string): vscode.OutputChannel {