Implement completionItem/resolve and icon substitution

Author: krassowski

packages/completion-theme/src/index.ts

@@ -12,20 +12,24 @@ import {
   ILSPCompletionThemeManager,
   PLUGIN_ID,
   COMPLETER_THEME_PREFIX,
-  KernelKind
+  KernelKind,
+  CompletionItemKindStrings
 } from './types';
 import { render_themes_list } from './about';
 import '../style/index.css';
+import { ILSPLogConsole } from '@krassowski/jupyterlab-lsp';
 
 export class CompletionThemeManager implements ILSPCompletionThemeManager {
   protected current_icons: Map<string, LabIcon>;
   protected themes: Map<string, ICompletionTheme>;
   private current_theme_id: string;
   private icons_cache: Map<string, LabIcon>;
+  private icon_overrides: Record<string, CompletionItemKindStrings>;
 
   constructor(protected themeManager: IThemeManager) {
     this.themes = new Map();
     this.icons_cache = new Map();
+    this.icon_overrides = {};
     themeManager.themeChanged.connect(this.update_icons_set, this);
   }
 
@@ -78,12 +82,16 @@ export class CompletionThemeManager implements ILSPCompletionThemeManager {
     }
     let options = this.current_theme.icons.options || {};
     if (type) {
+      if (type in this.icon_overrides) {
+        type = this.icon_overrides[type];
+      }
       type =
         type.substring(0, 1).toUpperCase() + type.substring(1).toLowerCase();
     }
     if (this.current_icons.has(type)) {
       return this.current_icons.get(type).bindprops(options);
     }
+
     if (type === KernelKind) {
       return kernelIcon;
     }
@@ -144,13 +152,19 @@ export class CompletionThemeManager implements ILSPCompletionThemeManager {
       buttons: [Dialog.okButton()]
     }).catch(console.warn);
   }
+
+  set_icons_overrides(
+    iconOverrides: Record<string, CompletionItemKindStrings>
+  ) {
+    this.icon_overrides = iconOverrides;
+  }
 }
 
 const LSP_CATEGORY = 'Language server protocol';
 
 export const COMPLETION_THEME_MANAGER: JupyterFrontEndPlugin<ILSPCompletionThemeManager> = {
   id: PLUGIN_ID,
-  requires: [IThemeManager, ICommandPalette],
+  requires: [IThemeManager, ICommandPalette, ILSPLogConsole],
   activate: (
     app,
     themeManager: IThemeManager,

packages/completion-theme/src/types.ts

@@ -116,6 +116,10 @@ export interface ILSPCompletionThemeManager {
   get_iconset(
     theme: ICompletionTheme
   ): Map<keyof ICompletionIconSet, LabIcon.ILabIcon>;
+
+  set_icons_overrides(
+    map: Record<string, CompletionItemKindStrings | 'Kernel'>
+  ): void;
 }
 
 export const ILSPCompletionThemeManager = new Token<ILSPCompletionThemeManager>(

packages/jupyterlab-lsp/schema/completion.json

@@ -31,6 +31,54 @@
       "type": ["string", "null"],
       "default": "vscode",
       "description": "The identifier of a completer theme with icons which indicate the kind of completion. Set to null to disable icons."
+    },
+    "typesMap": {
+      "title": "Mapping of custom kernel types to valid completion kind names",
+      "description": "Mapping used for icon selection. Accepted values are the names of CompletionItemKind and 'Kernel' literal. The defaults aim to provide good initial experience for Julia, Python and R kernels.",
+      "type": "object",
+      "default": {
+        "<unknown>": "Kernel",
+        "instance": "Value",
+        "path": "File",
+        "param": "Variable",
+        "missing": "Constant",
+        "nothing": "Constant",
+        "undefinitializer": "Constant",
+        "base.devnull": "Constant"
+      },
+      "patternProperties": {
+        "^.*$": {
+          "type": "string",
+          "enum": [
+            "Kernel",
+            "Text",
+            "Method",
+            "Function",
+            "Constructor",
+            "Field",
+            "Variable",
+            "Class",
+            "Interface",
+            "Module",
+            "Property",
+            "Unit",
+            "Value",
+            "Enum",
+            "Keyword",
+            "Snippet",
+            "Color",
+            "File",
+            "Reference",
+            "Folder",
+            "EnumMember",
+            "Constant",
+            "Struct",
+            "Event",
+            "Operator",
+            "TypeParameter"
+          ]
+        }
+      }
     }
   },
   "jupyter.lab.shortcuts": []

packages/jupyterlab-lsp/src/connection.ts

@@ -4,10 +4,10 @@
 // Introduced modifications are BSD licenced, copyright JupyterLab development team.
 import * as lsProtocol from 'vscode-languageserver-protocol';
 import {
+  IDocumentInfo,
   ILspOptions,
   IPosition,
-  LspWsConnection,
-  IDocumentInfo
+  LspWsConnection
 } from 'lsp-ws-connection';
 import { until_ready } from './utils';
 
@@ -138,4 +138,21 @@ export class LSPConnection extends LspWsConnection {
     );
     documentInfo.version++;
   }
+
+  async getCompletionResolve(completionItem: lsProtocol.CompletionItem) {
+    if (!this.isReady || !this.isCompletionResolveProvider()) {
+      return;
+    }
+    return this.connection.sendRequest<lsProtocol.CompletionItem>(
+      'completionItem/resolve',
+      completionItem
+    );
+  }
+
+  /**
+   * Does support completionItem/resolve?.
+   */
+  public isCompletionResolveProvider(): boolean {
+    return this.serverCapabilities?.completionProvider?.resolveProvider;
+  }
 }

packages/jupyterlab-lsp/src/features/completion/completion.ts

@@ -7,8 +7,8 @@ import * as CodeMirror from 'codemirror';
 import { CodeMirrorIntegration } from '../../editor_integration/codemirror';
 import { JupyterFrontEnd } from '@jupyterlab/application';
 import { IEditorChangedData, WidgetAdapter } from '../../adapters/adapter';
-import { LSPConnector } from './completion_handler';
-import { ICompletionManager } from '@jupyterlab/completer';
+import { LazyCompletionItem, LSPConnector } from './completion_handler';
+import { CompletionHandler, ICompletionManager } from '@jupyterlab/completer';
 import { CodeEditor } from '@jupyterlab/codeeditor';
 import { IDocumentWidget } from '@jupyterlab/docregistry';
 import { NotebookPanel } from '@jupyterlab/notebook';
@@ -19,6 +19,8 @@ import { IDocumentConnectionData } from '../../connection_manager';
 import { ILSPAdapterManager, ILSPLogConsole } from '../../tokens';
 import { NotebookAdapter } from '../../adapters/notebook/notebook';
 import { ILSPCompletionThemeManager } from '@krassowski/completion-theme/lib/types';
+import { LSPCompletionRenderer } from './renderer';
+import { IRenderMime, IRenderMimeRegistry } from '@jupyterlab/rendermime';
 
 export class CompletionCM extends CodeMirrorIntegration {
   private _completionCharacters: string[];
@@ -75,21 +77,44 @@ export class CompletionCM extends CodeMirrorIntegration {
 export class CompletionLabIntegration implements IFeatureLabIntegration {
   // TODO: maybe instead of creating it each time, keep a hash map instead?
   protected current_completion_connector: LSPConnector;
-  protected current_completion_handler: ICompletionManager.ICompletableAttributes;
+  protected current_completion_handler: CompletionHandler;
   protected current_adapter: WidgetAdapter<IDocumentWidget> = null;
+  protected renderer: LSPCompletionRenderer;
+  private markdown_renderer: IRenderMime.IRenderer;
 
   constructor(
     private app: JupyterFrontEnd,
     private completionManager: ICompletionManager,
     public settings: FeatureSettings<LSPCompletionSettings>,
     private adapterManager: ILSPAdapterManager,
     private completionThemeManager: ILSPCompletionThemeManager,
-    private console: ILSPLogConsole
+    private console: ILSPLogConsole,
+    private renderMimeRegistry: IRenderMimeRegistry
   ) {
+    this.renderer = new LSPCompletionRenderer({ integrator: this });
+    this.renderer.activeChanged.connect(this.active_completion_changed, this);
     adapterManager.adapterChanged.connect(this.swap_adapter, this);
     settings.changed.connect(() => {
       completionThemeManager.set_theme(this.settings.composite.theme);
+      completionThemeManager.set_icons_overrides(
+        this.settings.composite.typesMap
+      );
     });
+
+    this.markdown_renderer = this.renderMimeRegistry.createRenderer(
+      'text/markdown'
+    );
+  }
+
+  active_completion_changed(
+    renderer: LSPCompletionRenderer,
+    item: LazyCompletionItem
+  ) {
+    if (item.needsResolution()) {
+      item.fetchDocumentation();
+    } else if (item.isResolved()) {
+      this.refresh_doc_panel(item);
+    }
   }
 
   private swap_adapter(
@@ -130,11 +155,14 @@ export class CompletionLabIntegration implements IFeatureLabIntegration {
       return;
     }
     this.set_completion_connector(adapter, editor);
-    this.current_completion_handler = this.completionManager.register({
-      connector: this.current_completion_connector,
-      editor: editor,
-      parent: adapter.widget
-    });
+    this.current_completion_handler = this.completionManager.register(
+      {
+        connector: this.current_completion_connector,
+        editor: editor,
+        parent: adapter.widget
+      },
+      this.renderer
+    ) as CompletionHandler;
   }
 
   invoke_completer(kind: ExtendedCompletionTriggerKind) {
@@ -162,9 +190,53 @@ export class CompletionLabIntegration implements IFeatureLabIntegration {
     }
     this.set_completion_connector(adapter, editor_changed.editor);
     this.current_completion_handler.editor = editor_changed.editor;
+    // @ts-ignore
     this.current_completion_handler.connector = this.current_completion_connector;
   }
 
+  refresh_doc_panel(item: LazyCompletionItem) {
+    // TODO upstream: make completer public?
+    let completer = this.current_completion_handler.completer;
+
+    // TODO upstream: allow to get completionItems() without markup
+    //   (note: not trivial as _markup() does filtering too)
+    const items = completer.model.completionItems();
+
+    // TODO upstream: Completer will have getActiveItem()
+    // @ts-ignore
+    const index = completer._activeIndex;
+    const active: CompletionHandler.ICompletionItem = items[index];
+
+    if (active.insertText != item.insertText) {
+      return;
+    }
+
+    if (item.documentation) {
+      let docPanel = completer.node.querySelector('.jp-Completer-docpanel');
+
+      // TODO upstream: renderer should take care of the documentation rendering
+      //  sent PR: https://github.com/jupyterlab/jupyterlab/pull/9663
+      if (item.isDocumentationMarkdown) {
+        this.markdown_renderer
+          .renderModel({
+            data: {
+              'text/markdown': item.documentation
+            },
+            trusted: false,
+            metadata: {},
+            setData(options: IRenderMime.IMimeModel.ISetDataOptions) {}
+          })
+          .catch(this.console.warn);
+        // remove all children
+        docPanel.textContent = '';
+        docPanel.appendChild(this.markdown_renderer.node);
+      } else {
+        docPanel.textContent = item.documentation;
+      }
+      docPanel.setAttribute('style', '');
+    }
+  }
+
   private set_completion_connector(
     adapter: WidgetAdapter<IDocumentWidget>,
     editor: CodeEditor.IEditor
@@ -178,6 +250,7 @@ export class CompletionLabIntegration implements IFeatureLabIntegration {
       connections: this.current_adapter.connection_manager.connections,
       virtual_editor: this.current_adapter.virtual_editor,
       settings: this.settings,
+      labIntegration: this,
       // it might or might not be a notebook panel (if it is not, the sessionContext and session will just be undefined)
       session: (this.current_adapter.widget as NotebookPanel)?.sessionContext
         ?.session,