Support resolveCompletionItem for Jedi docstrings in data science (microsoft#9718)

Author: IanMatthewHuff

news/2 Fixes/8706.md

@@ -0,0 +1 @@
+Support resolveCompletionItem so that we can get Jedi docstrings in Notebook Editor and Interactive Window.

src/client/activation/jedi.ts

@@ -168,6 +168,13 @@ export class JediExtensionActivator implements ILanguageServerActivator {
  return this.completionProvider.provideCompletionItems(document, position, token);
  }
  }
+
+ public resolveCompletionItem(item: CompletionItem, token: CancellationToken): ProviderResult<CompletionItem> {
+ if (this.completionProvider) {
+ return this.completionProvider.resolveCompletionItem(item, token);
+ }
+ }
+
  public get onDidChangeCodeLenses(): Event<void> | undefined {
  return this.codeLensProvider ? this.codeLensProvider.onDidChangeCodeLenses : undefined;
  }

src/client/activation/refCountedLanguageServer.ts

@@ -89,6 +89,11 @@ export class RefCountedLanguageServer implements ILanguageServerActivator {
  ): ProviderResult<CompletionItem[] | CompletionList> {
  return this.impl.provideCompletionItems(document, position, token, context);
  }
+ public resolveCompletionItem(item: CompletionItem, token: CancellationToken): ProviderResult<CompletionItem> {
+ if (this.impl.resolveCompletionItem) {
+ return this.impl.resolveCompletionItem(item, token);
+ }
+ }
  public provideCodeLenses(document: TextDocument, token: CancellationToken): ProviderResult<CodeLens[]> {
  return this.impl.provideCodeLenses(document, token);
  }

src/client/datascience/interactive-common/intellisense/conversion.ts

@@ -68,6 +68,35 @@ const mapCompletionItemKind: Map<number, number> = new Map<number, number>([
  [vscode.CompletionItemKind.TypeParameter, monacoCompletionItemKind.TypeParameter] // TypeParameter
 ]);
 
+// Left side is the monaco value.
+const reverseMapCompletionItemKind: Map<number, vscode.CompletionItemKind> = new Map<number, vscode.CompletionItemKind>([
+ [monacoCompletionItemKind.Text, vscode.CompletionItemKind.Text], // Text
+ [monacoCompletionItemKind.Method, vscode.CompletionItemKind.Method], // Method
+ [monacoCompletionItemKind.Function, vscode.CompletionItemKind.Function], // Function
+ [monacoCompletionItemKind.Constructor, vscode.CompletionItemKind.Constructor], // Constructor
+ [monacoCompletionItemKind.Field, vscode.CompletionItemKind.Field], // Field
+ [monacoCompletionItemKind.Variable, vscode.CompletionItemKind.Variable], // Variable
+ [monacoCompletionItemKind.Class, vscode.CompletionItemKind.Class], // Class
+ [monacoCompletionItemKind.Interface, vscode.CompletionItemKind.Interface], // Interface
+ [monacoCompletionItemKind.Module, vscode.CompletionItemKind.Module], // Module
+ [monacoCompletionItemKind.Property, vscode.CompletionItemKind.Property], // Property
+ [monacoCompletionItemKind.Unit, vscode.CompletionItemKind.Unit], // Unit
+ [monacoCompletionItemKind.Value, vscode.CompletionItemKind.Value], // Value
+ [monacoCompletionItemKind.Enum, vscode.CompletionItemKind.Enum], // Enum
+ [monacoCompletionItemKind.Keyword, vscode.CompletionItemKind.Keyword], // Keyword
+ [monacoCompletionItemKind.Snippet, vscode.CompletionItemKind.Snippet], // Snippet
+ [monacoCompletionItemKind.Color, vscode.CompletionItemKind.Color], // Color
+ [monacoCompletionItemKind.File, vscode.CompletionItemKind.File], // File
+ [monacoCompletionItemKind.Reference, vscode.CompletionItemKind.Reference], // Reference
+ [monacoCompletionItemKind.Folder, vscode.CompletionItemKind.Folder], // Folder
+ [monacoCompletionItemKind.EnumMember, vscode.CompletionItemKind.EnumMember], // EnumMember
+ [monacoCompletionItemKind.Constant, vscode.CompletionItemKind.Constant], // Constant
+ [monacoCompletionItemKind.Struct, vscode.CompletionItemKind.Struct], // Struct
+ [monacoCompletionItemKind.Event, vscode.CompletionItemKind.Event], // Event
+ [monacoCompletionItemKind.Operator, vscode.CompletionItemKind.Operator], // Operator
+ [monacoCompletionItemKind.TypeParameter, vscode.CompletionItemKind.TypeParameter] // TypeParameter
+]);
+
 const mapJupyterKind: Map<string, number> = new Map<string, number>([
  ['method', monacoCompletionItemKind.Method],
  ['function', monacoCompletionItemKind.Function],
@@ -109,6 +138,12 @@ function convertToMonacoRange(range: vscodeLanguageClient.Range | undefined): mo
  }
 }
 
+function convertToVSCodeRange(range: monacoEditor.IRange | undefined): vscode.Range | undefined {
+ if (range) {
+ return new vscode.Range(new vscode.Position(range.startLineNumber - 1, range.startColumn - 1), new vscode.Position(range.endLineNumber - 1, range.endColumn - 1));
+ }
+}
+
 // Something very fishy. If the monacoEditor.languages.CompletionItemKind is included here, we get this error on startup
 // Activating extension `ms-python.python` failed: Unexpected token {
 // extensionHostProcess.js:457
@@ -123,9 +158,17 @@ function convertToMonacoCompletionItemKind(kind?: number): number {
  return monacoCompletionItemKind.Property;
 }
 
+function convertToVSCodeCompletionItemKind(kind?: number): vscode.CompletionItemKind {
+ const value = kind ? reverseMapCompletionItemKind.get(kind) : vscode.CompletionItemKind.Property;
+ if (value) {
+ return value;
+ }
+ return vscode.CompletionItemKind.Property;
+}
+
 const SnippetEscape = 4;
 
-function convertToMonacoCompletionItem(item: vscodeLanguageClient.CompletionItem, requiresKindConversion: boolean): monacoEditor.languages.CompletionItem {
+export function convertToMonacoCompletionItem(item: vscodeLanguageClient.CompletionItem, requiresKindConversion: boolean): monacoEditor.languages.CompletionItem {
  // They should be pretty much identical? Except for ranges.
  // tslint:disable-next-line: no-object-literal-type-assertion no-any
  const result = ({ ...item } as any) as monacoEditor.languages.CompletionItem;
@@ -156,6 +199,21 @@ function convertToMonacoCompletionItem(item: vscodeLanguageClient.CompletionItem
  return result;
 }
 
+export function convertToVSCodeCompletionItem(item: monacoEditor.languages.CompletionItem): vscode.CompletionItem {
+ // tslint:disable-next-line: no-object-literal-type-assertion no-any
+ const result = ({ ...item } as any) as vscode.CompletionItem;
+
+ if (item.kind && result.kind) {
+ result.kind = convertToVSCodeCompletionItemKind(item.kind);
+ }
+
+ if (item.range && result.range) {
+ result.range = convertToVSCodeRange(item.range);
+ }
+
+ return result;
+}
+
 export function convertToMonacoCompletionList(
  result: vscodeLanguageClient.CompletionList | vscodeLanguageClient.CompletionItem[] | vscode.CompletionItem[] | vscode.CompletionList | null,
  requiresKindConversion: boolean

src/client/datascience/interactive-common/intellisense/intellisenseProvider.ts

@@ -7,8 +7,8 @@ import { inject, injectable } from 'inversify';
 import * as monacoEditor from 'monaco-editor/esm/vs/editor/editor.api';
 import * as path from 'path';
 import * as uuid from 'uuid/v4';
-import { CancellationToken, CancellationTokenSource, Event, EventEmitter, SignatureHelpContext, TextDocumentContentChangeEvent, Uri } from 'vscode';
-
+import { CancellationToken, CancellationTokenSource, CompletionItem, Event, EventEmitter, SignatureHelpContext, TextDocumentContentChangeEvent, Uri } from 'vscode';
+import * as vscodeLanguageClient from 'vscode-languageclient';
 import { concatMultilineStringInput } from '../../../../datascience-ui/common';
 import { ILanguageServer, ILanguageServerCache } from '../../../activation/types';
 import { IWorkspaceService } from '../../../common/application/types';
@@ -34,9 +34,17 @@ import {
  IProvideHoverRequest,
  IProvideSignatureHelpRequest,
  IRemoveCell,
+ IResolveCompletionItemRequest,
  ISwapCells
 } from '../interactiveWindowTypes';
-import { convertStringsToSuggestions, convertToMonacoCompletionList, convertToMonacoHover, convertToMonacoSignatureHelp } from './conversion';
+import {
+ convertStringsToSuggestions,
+ convertToMonacoCompletionItem,
+ convertToMonacoCompletionList,
+ convertToMonacoHover,
+ convertToMonacoSignatureHelp,
+ convertToVSCodeCompletionItem
+} from './conversion';
 import { IntellisenseDocument } from './intellisenseDocument';
 
 // tslint:disable:no-any
@@ -95,6 +103,10 @@ export class IntellisenseProvider implements IInteractiveWindowListener {
  this.dispatchMessage(message, payload, this.handleSignatureHelpRequest);
  break;
 
+ case InteractiveWindowMessages.ResolveCompletionItemRequest:
+ this.dispatchMessage(message, payload, this.handleResolveCompletionItemRequest);
+ break;
+
  case InteractiveWindowMessages.EditCell:
  this.dispatchMessage(message, payload, this.editCell);
  break;
@@ -211,8 +223,7 @@ export class IntellisenseProvider implements IInteractiveWindowListener {
  cellId: string,
  token: CancellationToken
  ): Promise<monacoEditor.languages.CompletionList> {
- const languageServer = await this.getLanguageServer();
- const document = await this.getDocument();
+ const [languageServer, document] = await Promise.all([this.getLanguageServer(), this.getDocument()]);
  if (languageServer && document) {
  const docPos = document.convertToDocumentPosition(cellId, position.lineNumber, position.column);
  const result = await languageServer.provideCompletionItems(document, docPos, token, context);
@@ -227,8 +238,7 @@ export class IntellisenseProvider implements IInteractiveWindowListener {
  };
  }
  protected async provideHover(position: monacoEditor.Position, cellId: string, token: CancellationToken): Promise<monacoEditor.languages.Hover> {
- const languageServer = await this.getLanguageServer();
- const document = await this.getDocument();
+ const [languageServer, document] = await Promise.all([this.getLanguageServer(), this.getDocument()]);
  if (languageServer && document) {
  const docPos = document.convertToDocumentPosition(cellId, position.lineNumber, position.column);
  const result = await languageServer.provideHover(document, docPos, token);
@@ -247,8 +257,7 @@ export class IntellisenseProvider implements IInteractiveWindowListener {
  cellId: string,
  token: CancellationToken
  ): Promise<monacoEditor.languages.SignatureHelp> {
- const languageServer = await this.getLanguageServer();
- const document = await this.getDocument();
+ const [languageServer, document] = await Promise.all([this.getLanguageServer(), this.getDocument()]);
  if (languageServer && document) {
  const docPos = document.convertToDocumentPosition(cellId, position.lineNumber, position.column);
  const result = await languageServer.provideSignatureHelp(document, docPos, token, context as SignatureHelpContext);
@@ -264,6 +273,31 @@ export class IntellisenseProvider implements IInteractiveWindowListener {
  };
  }
 
+ protected async resolveCompletionItem(
+ position: monacoEditor.Position,
+ item: monacoEditor.languages.CompletionItem,
+ cellId: string,
+ token: CancellationToken
+ ): Promise<monacoEditor.languages.CompletionItem> {
+ const [languageServer, document] = await Promise.all([this.getLanguageServer(), this.getDocument()]);
+ if (languageServer && languageServer.resolveCompletionItem && document) {
+ const vscodeCompItem: CompletionItem = convertToVSCodeCompletionItem(item);
+
+ // Needed by Jedi in completionSource.ts to resolve the item
+ const docPos = document.convertToDocumentPosition(cellId, position.lineNumber, position.column);
+ (vscodeCompItem as any)._documentPosition = { document, position: docPos };
+
+ const result = await languageServer.resolveCompletionItem(vscodeCompItem, token);
+ if (result) {
+ // Convert expects vclc completion item, but takes both vclc and vscode items so just cast here
+ return convertToMonacoCompletionItem(result as vscodeLanguageClient.CompletionItem, true);
+ }
+ }
+
+ // If we can't fill in the extra info, just return the item
+ return item;
+ }
+
  protected async handleChanges(document: IntellisenseDocument, changes: TextDocumentContentChangeEvent[]): Promise<void> {
  // For the dot net language server, we have to send extra data to the language server
  if (document) {
@@ -325,6 +359,25 @@ export class IntellisenseProvider implements IInteractiveWindowListener {
  );
  }
 
+ private handleResolveCompletionItemRequest(request: IResolveCompletionItemRequest) {
+ // Create a cancellation source. We'll use this for our sub class request and a jupyter one
+ const cancelSource = new CancellationTokenSource();
+ this.cancellationSources.set(request.requestId, cancelSource);
+
+ // Combine all of the results together.
+ this.postTimedResponse(
+ [this.resolveCompletionItem(request.position, request.item, request.cellId, cancelSource.token)],
+ InteractiveWindowMessages.ResolveCompletionItemResponse,
+ c => {
+ if (c && c[0]) {
+ return { item: c[0], requestId: request.requestId };
+ } else {
+ return { item: request.item, requestId: request.requestId };
+ }
+ }
+ );
+ }
+
  private handleHoverRequest(request: IProvideHoverRequest) {
  const cancelSource = new CancellationTokenSource();
  this.cancellationSources.set(request.requestId, cancelSource);

src/client/datascience/interactive-common/interactiveWindowTypes.ts

@@ -50,6 +50,9 @@ export enum InteractiveWindowMessages {
  ProvideSignatureHelpRequest = 'provide_signature_help_request',
  CancelSignatureHelpRequest = 'cancel_signature_help_request',
  ProvideSignatureHelpResponse = 'provide_signature_help_response',
+ ResolveCompletionItemRequest = 'resolve_completion_item_request',
+ CancelResolveCompletionItemRequest = 'cancel_resolve_completion_item_request',
+ ResolveCompletionItemResponse = 'resolve_completion_item_response',
  AddCell = 'add_cell',
  EditCell = 'edit_cell',
  RemoveCell = 'remove_cell',
@@ -192,6 +195,13 @@ export interface ICancelIntellisenseRequest {
  requestId: string;
 }
 
+export interface IResolveCompletionItemRequest {
+ position: monacoEditor.Position;
+ item: monacoEditor.languages.CompletionItem;
+ requestId: string;
+ cellId: string;
+}
+
 export interface IProvideCompletionItemsResponse {
  list: monacoEditor.languages.CompletionList;
  requestId: string;
@@ -207,6 +217,11 @@ export interface IProvideSignatureHelpResponse {
  requestId: string;
 }
 
+export interface IResolveCompletionItemResponse {
+ item: monacoEditor.languages.CompletionItem;
+ requestId: string;
+}
+
 export interface IPosition {
  line: number;
  ch: number;
@@ -325,6 +340,9 @@ export class IInteractiveWindowMapping {
  public [InteractiveWindowMessages.ProvideSignatureHelpRequest]: IProvideSignatureHelpRequest;
  public [InteractiveWindowMessages.CancelSignatureHelpRequest]: ICancelIntellisenseRequest;
  public [InteractiveWindowMessages.ProvideSignatureHelpResponse]: IProvideSignatureHelpResponse;
+ public [InteractiveWindowMessages.ResolveCompletionItemRequest]: IResolveCompletionItemRequest;
+ public [InteractiveWindowMessages.CancelResolveCompletionItemRequest]: ICancelIntellisenseRequest;
+ public [InteractiveWindowMessages.ResolveCompletionItemResponse]: IResolveCompletionItemResponse;
  public [InteractiveWindowMessages.AddCell]: IAddCell;
  public [InteractiveWindowMessages.EditCell]: IEditCell;
  public [InteractiveWindowMessages.RemoveCell]: IRemoveCell;

src/datascience-ui/interactive-common/intellisenseProvider.ts

@@ -13,7 +13,8 @@ import {
  InteractiveWindowMessages,
  IProvideCompletionItemsResponse,
  IProvideHoverResponse,
- IProvideSignatureHelpResponse
+ IProvideSignatureHelpResponse,
+ IResolveCompletionItemResponse
 } from '../../client/datascience/interactive-common/interactiveWindowTypes';
 
 interface IRequestData<T> {
@@ -27,6 +28,7 @@ export class IntellisenseProvider
  public readonly signatureHelpTriggerCharacters?: ReadonlyArray<string> = ['(', ',', '<'];
  public readonly signatureHelpRetriggerCharacters?: ReadonlyArray<string> = [')'];
  private completionRequests: Map<string, IRequestData<monacoEditor.languages.CompletionList>> = new Map<string, IRequestData<monacoEditor.languages.CompletionList>>();
+ private resolveCompletionRequests: Map<string, IRequestData<monacoEditor.languages.CompletionItem>> = new Map<string, IRequestData<monacoEditor.languages.CompletionItem>>();
  private hoverRequests: Map<string, IRequestData<monacoEditor.languages.Hover>> = new Map<string, IRequestData<monacoEditor.languages.Hover>>();
  private signatureHelpRequests: Map<string, IRequestData<monacoEditor.languages.SignatureHelpResult>> = new Map<
  string,
@@ -64,6 +66,32 @@ export class IntellisenseProvider
  return promise.promise;
  }
 
+ public resolveCompletionItem(
+ model: monacoEditor.editor.ITextModel,
+ position: monacoEditor.Position,
+ item: monacoEditor.languages.CompletionItem,
+ token: monacoEditor.CancellationToken
+ ): monacoEditor.languages.ProviderResult<monacoEditor.languages.CompletionItem> {
+ // If the item has already resolved documentation (as with MS LS) we don't need to do this
+ if (!item.documentation) {
+ // Emit a new request
+ const requestId = uuid();
+ const promise = createDeferred<monacoEditor.languages.CompletionItem>();
+
+ const cancelDisposable = token.onCancellationRequested(() => {
+ promise.resolve();
+ this.sendMessage(InteractiveWindowMessages.CancelResolveCompletionItemRequest, { requestId });
+ });
+
+ this.resolveCompletionRequests.set(requestId, { promise, cancelDisposable });
+ this.sendMessage(InteractiveWindowMessages.ResolveCompletionItemRequest, { position, item, requestId, cellId: this.getCellId(model.id) });
+
+ return promise.promise;
+ } else {
+ return Promise.resolve(item);
+ }
+ }
+
  public provideHover(
  model: monacoEditor.editor.ITextModel,
  position: monacoEditor.Position,
@@ -109,6 +137,7 @@ export class IntellisenseProvider
  this.disposed = true;
  this.registerDisposables.forEach(r => r.dispose());
  this.completionRequests.forEach(r => r.promise.resolve());
+ this.resolveCompletionRequests.forEach(r => r.promise.resolve());
  this.hoverRequests.forEach(r => r.promise.resolve());
 
  this.registerDisposables = [];
@@ -154,6 +183,15 @@ export class IntellisenseProvider
  }
  }
 
+ public handleResolveCompletionItemResponse(response: IResolveCompletionItemResponse) {
+ // Resolve our waiting promise if we have one
+ const waiting = this.resolveCompletionRequests.get(response.requestId);
+ if (waiting) {
+ waiting.promise.resolve(response.item);
+ this.completionRequests.delete(response.requestId);
+ }
+ }
+
  private getCellId(monacoId: string): string {
  const result = this.monacoIdToCellId.get(monacoId);
  if (result) {

src/datascience-ui/interactive-common/redux/postOffice.ts

@@ -55,6 +55,9 @@ export enum IncomingMessageActions {
  PROVIDESIGNATUREHELPREQUEST = 'action.provide_signature_help_request',
  CANCELSIGNATUREHELPREQUEST = 'action.cancel_signature_help_request',
  PROVIDESIGNATUREHELPRESPONSE = 'action.provide_signature_help_response',
+ RESOLVECOMPLETIONITEMREQUEST = 'action.resolve_completion_item_request',
+ CANCELRESOLVECOMPLETIONITEMREQUEST = 'action.cancel_completion_items_request',
+ RESOLVECOMPLETIONITEMRESPONSE = 'action.resolve_completion_item_response',
  ADDCELL = 'action.add_cell',
  EDITCELL = 'action.edit_cell',
  REMOVECELL = 'action.remove_cell',