atom-languageclient/build/lib/adapters/autocomplete-adapter.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.grammarScopeToAutoCompleteSelector = void 0;
const convert_1 = require("../convert");
const Utils = require("../utils");
const zadeh_1 = require("zadeh");
const languageclient_1 = require("../languageclient");
const apply_edit_adapter_1 = require("./apply-edit-adapter");
const atom_1 = require("atom");
class PossiblyResolvedCompletionItem {
    constructor(completionItem, isResolved) {
        this.completionItem = completionItem;
        this.isResolved = isResolved;
    }
}
/** Public: Adapts the language server protocol "textDocument/completion" to the Atom AutoComplete+ package. */
class AutocompleteAdapter {
    constructor() {
        this._suggestionCache = new WeakMap();
        this._cancellationTokens = new WeakMap();
    }
    static canAdapt(serverCapabilities) {
        return serverCapabilities.completionProvider != null;
    }
    static canResolve(serverCapabilities) {
        return (serverCapabilities.completionProvider != null && serverCapabilities.completionProvider.resolveProvider === true);
    }
    /**
     * Public: Obtain suggestion list for AutoComplete+ by querying the language server using the `textDocument/completion` request.
     *
     * @param server An {ActiveServer} pointing to the language server to query.
     * @param request The {atom$AutocompleteRequest} to satisfy.
     * @param onDidConvertCompletionItem An optional function that takes a {CompletionItem}, an
     *   {atom$AutocompleteSuggestion} and a {atom$AutocompleteRequest} allowing you to adjust converted items.
     * @param shouldReplace The behavior of suggestion acceptance (see {ShouldReplace}).
     * @returns A {Promise} of an {Array} of {atom$AutocompleteSuggestion}s containing the AutoComplete+ suggestions to display.
     */
    getSuggestions(server, request, onDidConvertCompletionItem, minimumWordLength, shouldReplace = false) {
        return __awaiter(this, void 0, void 0, function* () {
            const triggerChars = server.capabilities.completionProvider != null
                ? server.capabilities.completionProvider.triggerCharacters || []
                : [];
            // triggerOnly is true if we have just typed in a trigger character, and is false if we
            // have typed additional characters following a trigger character.
            const [triggerChar, triggerOnly] = AutocompleteAdapter.getTriggerCharacter(request, triggerChars);
            if (!this.shouldTrigger(request, triggerChar, minimumWordLength || 0)) {
                return [];
            }
            // Get the suggestions either from the cache or by calling the language server
            const suggestions = yield this.getOrBuildSuggestions(server, request, triggerChar, triggerOnly, shouldReplace, onDidConvertCompletionItem);
            // We must update the replacement prefix as characters are added and removed
            const cache = this._suggestionCache.get(server);
            const replacementPrefix = request.editor.getTextInBufferRange([
                [cache.triggerPoint.row, cache.triggerPoint.column + cache.triggerChar.length],
                request.bufferPosition,
            ]);
            for (const suggestion of suggestions) {
                if (suggestion.customReplacmentPrefix) {
                    // having this property means a custom range was provided
                    const len = replacementPrefix.length;
                    const preReplacementPrefix = suggestion.customReplacmentPrefix +
                        replacementPrefix.substring(len + cache.originalBufferPoint.column - request.bufferPosition.column, len);
                    // we cannot replace text after the cursor with the current autocomplete-plus API
                    // so we will simply ignore it for now
                    suggestion.replacementPrefix = preReplacementPrefix;
                }
                else {
                    suggestion.replacementPrefix = replacementPrefix;
                }
            }
            const filtered = !(request.prefix === "" || (triggerChar !== "" && triggerOnly));
            if (filtered) {
                // filter the suggestions who have `filterText` property
                const validSuggestions = suggestions.filter((sgs) => typeof sgs.filterText === "string");
                // TODO use `ObjectArrayFilterer.setCandidate` in `_suggestionCache` to avoid creating `ObjectArrayFilterer` every time from scratch
                const objFilterer = new zadeh_1.ObjectArrayFilterer(validSuggestions, "filterText");
                // zadeh returns an array of the selected `Suggestions`
                return objFilterer.filter(request.prefix);
            }
            else {
                return suggestions;
            }
        });
    }
    shouldTrigger(request, triggerChar, minWordLength) {
        return (request.activatedManually || triggerChar !== "" || minWordLength <= 0 || request.prefix.length >= minWordLength);
    }
    getOrBuildSuggestions(server, request, triggerChar, triggerOnly, shouldReplace, onDidConvertCompletionItem) {
        return __awaiter(this, void 0, void 0, function* () {
            const cache = this._suggestionCache.get(server);
            const triggerColumn = triggerChar !== "" && triggerOnly
                ? request.bufferPosition.column - triggerChar.length
                : request.bufferPosition.column - request.prefix.length - triggerChar.length;
            const triggerPoint = new atom_1.Point(request.bufferPosition.row, triggerColumn);
            // Do we have complete cached suggestions that are still valid for this request?
            if (cache &&
                !cache.isIncomplete &&
                cache.triggerChar === triggerChar &&
                cache.triggerPoint.isEqual(triggerPoint) &&
                cache.originalBufferPoint.isLessThanOrEqual(request.bufferPosition)) {
                return Array.from(cache.suggestionMap.keys());
            }
            // Our cached suggestions can't be used so obtain new ones from the language server
            const completions = yield Utils.doWithCancellationToken(server.connection, this._cancellationTokens, (cancellationToken) => server.connection.completion(AutocompleteAdapter.createCompletionParams(request, triggerChar, triggerOnly), cancellationToken));
            // spec guarantees all edits are on the same line, so we only need to check the columns
            const triggerColumns = [triggerPoint.column, request.bufferPosition.column];
            // Setup the cache for subsequent filtered results
            const isComplete = completions === null || Array.isArray(completions) || !completions.isIncomplete;
            const suggestionMap = this.completionItemsToSuggestions(completions, request, triggerColumns, shouldReplace, onDidConvertCompletionItem);
            this._suggestionCache.set(server, {
                isIncomplete: !isComplete,
                triggerChar,
                triggerPoint,
                originalBufferPoint: request.bufferPosition,
                suggestionMap,
            });
            return Array.from(suggestionMap.keys());
        });
    }
    /**
     * Public: Obtain a complete version of a suggestion with additional information the language server can provide by
     * way of the `completionItem/resolve` request.
     *
     * @param server An {ActiveServer} pointing to the language server to query.
     * @param suggestion An {atom$AutocompleteSuggestion} suggestion that should be resolved.
     * @param request An {Object} with the AutoComplete+ request to satisfy.
     * @param onDidConvertCompletionItem An optional function that takes a {CompletionItem}, an
     *   {atom$AutocompleteSuggestion} and a {atom$AutocompleteRequest} allowing you to adjust converted items.
     * @returns A {Promise} of an {atom$AutocompleteSuggestion} with the resolved AutoComplete+ suggestion.
     */
    completeSuggestion(server, suggestion, request, onDidConvertCompletionItem) {
        return __awaiter(this, void 0, void 0, function* () {
            const cache = this._suggestionCache.get(server);
            if (cache) {
                const possiblyResolvedCompletionItem = cache.suggestionMap.get(suggestion);
                if (possiblyResolvedCompletionItem != null && !possiblyResolvedCompletionItem.isResolved) {
                    const resolvedCompletionItem = yield server.connection.completionItemResolve(possiblyResolvedCompletionItem.completionItem);
                    if (resolvedCompletionItem != null) {
                        AutocompleteAdapter.resolveSuggestion(resolvedCompletionItem, suggestion, request, onDidConvertCompletionItem);
                        possiblyResolvedCompletionItem.isResolved = true;
                    }
                }
            }
            return suggestion;
        });
    }
    static resolveSuggestion(resolvedCompletionItem, suggestion, request, onDidConvertCompletionItem) {
        // only the `documentation` and `detail` properties may change when resolving
        AutocompleteAdapter.applyDetailsToSuggestion(resolvedCompletionItem, suggestion);
        if (onDidConvertCompletionItem != null) {
            onDidConvertCompletionItem(resolvedCompletionItem, suggestion, request);
        }
    }
    /**
     * Public: Get the trigger character that caused the autocomplete (if any). This is required because AutoComplete-plus
     * does not have trigger characters. Although the terminology is 'character' we treat them as variable length strings
     * as this will almost certainly change in the future to support '->' etc.
     *
     * @param request An {Array} of {atom$AutocompleteSuggestion}s to locate the prefix, editor, bufferPosition etc.
     * @param triggerChars The {Array} of {string}s that can be trigger characters.
     * @returns A [{string}, boolean] where the string is the matching trigger character or an empty string if one was not
     *   matched, and the boolean is true if the trigger character is in request.prefix, and false if it is in the word
     *   before request.prefix. The boolean return value has no meaning if the string return value is an empty string.
     */
    static getTriggerCharacter(request, triggerChars) {
        // AutoComplete-Plus considers text after a symbol to be a new trigger. So we should look backward
        // from the current cursor position to see if one is there and thus simulate it.
        const buffer = request.editor.getBuffer();
        const cursor = request.bufferPosition;
        const prefixStartColumn = cursor.column - request.prefix.length;
        for (const triggerChar of triggerChars) {
            if (request.prefix.endsWith(triggerChar)) {
                return [triggerChar, true];
            }
            if (prefixStartColumn >= triggerChar.length) {
                // Far enough along a line to fit the trigger char
                const start = new atom_1.Point(cursor.row, prefixStartColumn - triggerChar.length);
                const possibleTrigger = buffer.getTextInRange([start, [cursor.row, prefixStartColumn]]);
                if (possibleTrigger === triggerChar) {
                    // The text before our trigger is a trigger char!
                    return [triggerChar, false];
                }
            }
        }
        // There was no explicit trigger char
        return ["", false];
    }
    /**
     * Public: Create TextDocumentPositionParams to be sent to the language server based on the editor and position from
     * the AutoCompleteRequest.
     *
     * @param request The {atom$AutocompleteRequest} to obtain the editor from.
     * @param triggerPoint The {atom$Point} where the trigger started.
     * @returns A {string} containing the prefix including the trigger character.
     */
    static getPrefixWithTrigger(request, triggerPoint) {
        return request.editor.getBuffer().getTextInRange([[triggerPoint.row, triggerPoint.column], request.bufferPosition]);
    }
    /**
     * Public: Create {CompletionParams} to be sent to the language server based on the editor and position from the
     * Autocomplete request etc.
     *
     * @param request The {atom$AutocompleteRequest} containing the request details.
     * @param triggerCharacter The {string} containing the trigger character (empty if none).
     * @param triggerOnly A {boolean} representing whether this completion is triggered right after a trigger character.
     * @returns A {CompletionParams} with the keys:
     *
     *   - `textDocument` the language server protocol textDocument identification.
     *   - `position` the position within the text document to display completion request for.
     *   - `context` containing the trigger character and kind.
     */
    static createCompletionParams(request, triggerCharacter, triggerOnly) {
        return {
            textDocument: convert_1.default.editorToTextDocumentIdentifier(request.editor),
            position: convert_1.default.pointToPosition(request.bufferPosition),
            context: AutocompleteAdapter.createCompletionContext(triggerCharacter, triggerOnly),
        };
    }
    /**
     * Public: Create {CompletionContext} to be sent to the language server based on the trigger character.
     *
     * @param triggerCharacter The {string} containing the trigger character or '' if none.
     * @param triggerOnly A {boolean} representing whether this completion is triggered right after a trigger character.
     * @returns An {CompletionContext} that specifies the triggerKind and the triggerCharacter if there is one.
     */
    static createCompletionContext(triggerCharacter, triggerOnly) {
        if (triggerCharacter === "") {
            return { triggerKind: languageclient_1.CompletionTriggerKind.Invoked };
        }
        else {
            return triggerOnly
                ? { triggerKind: languageclient_1.CompletionTriggerKind.TriggerCharacter, triggerCharacter }
                : { triggerKind: languageclient_1.CompletionTriggerKind.TriggerForIncompleteCompletions, triggerCharacter };
        }
    }
    /**
     * Public: Convert a language server protocol CompletionItem array or CompletionList to an array of ordered
     * AutoComplete+ suggestions.
     *
     * @param completionItems An {Array} of {CompletionItem} objects or a {CompletionList} containing completion items to
     *   be converted.
     * @param request The {atom$AutocompleteRequest} to satisfy.
     * @param shouldReplace The behavior of suggestion acceptance (see {ShouldReplace}).
     * @param onDidConvertCompletionItem A function that takes a {CompletionItem}, an {atom$AutocompleteSuggestion} and a
     *   {atom$AutocompleteRequest} allowing you to adjust converted items.
     * @returns A {Map} of AutoComplete+ suggestions ordered by the CompletionItems sortText.
     */
    completionItemsToSuggestions(completionItems, request, triggerColumns, shouldReplace, onDidConvertCompletionItem) {
        const completionsArray = Array.isArray(completionItems)
            ? completionItems
            : (completionItems && completionItems.items) || [];
        return new Map(completionsArray
            .sort((a, b) => (a.sortText || a.label).localeCompare(b.sortText || b.label))
            .map((s) => [
            AutocompleteAdapter.completionItemToSuggestion(s, {}, request, triggerColumns, shouldReplace, onDidConvertCompletionItem),
            new PossiblyResolvedCompletionItem(s, false),
        ]));
    }
    /**
     * Public: Convert a language server protocol CompletionItem to an AutoComplete+ suggestion.
     *
     * @param item An {CompletionItem} containing a completion item to be converted.
     * @param suggestion A {atom$AutocompleteSuggestion} to have the conversion applied to.
     * @param request The {atom$AutocompleteRequest} to satisfy.
     * @param shouldReplace The behavior of suggestion acceptance (see {ShouldReplace}).
     * @param onDidConvertCompletionItem A function that takes a {CompletionItem}, an {atom$AutocompleteSuggestion} and a
     *   {atom$AutocompleteRequest} allowing you to adjust converted items.
     * @returns The {atom$AutocompleteSuggestion} passed in as suggestion with the conversion applied.
     */
    static completionItemToSuggestion(item, suggestion, request, triggerColumns, shouldReplace, onDidConvertCompletionItem) {
        AutocompleteAdapter.applyCompletionItemToSuggestion(item, suggestion);
        AutocompleteAdapter.applyTextEditToSuggestion(item.textEdit, request.editor, triggerColumns, request.bufferPosition, suggestion, shouldReplace);
        AutocompleteAdapter.applySnippetToSuggestion(item, suggestion);
        if (onDidConvertCompletionItem != null) {
            onDidConvertCompletionItem(item, suggestion, request);
        }
        return suggestion;
    }
    /**
     * Public: Convert the primary parts of a language server protocol CompletionItem to an AutoComplete+ suggestion.
     *
     * @param item An {CompletionItem} containing the completion items to be merged into.
     * @param suggestion The {Suggestion} to merge the conversion into.
     * @returns The {Suggestion} with details added from the {CompletionItem}.
     */
    static applyCompletionItemToSuggestion(item, suggestion) {
        suggestion.text = item.insertText || item.label;
        suggestion.filterText = item.filterText || item.label;
        suggestion.displayText = item.label;
        suggestion.type = AutocompleteAdapter.completionKindToSuggestionType(item.kind);
        AutocompleteAdapter.applyDetailsToSuggestion(item, suggestion);
        suggestion.completionItem = item;
    }
    static applyDetailsToSuggestion(item, suggestion) {
        suggestion.rightLabel = item.detail;
        // Older format, can't know what it is so assign to both and hope for best
        if (typeof item.documentation === "string") {
            suggestion.descriptionMarkdown = item.documentation;
            suggestion.description = item.documentation;
        }
        if (item.documentation != null && typeof item.documentation === "object") {
            // Newer format specifies the kind of documentation, assign appropriately
            if (item.documentation.kind === "markdown") {
                suggestion.descriptionMarkdown = item.documentation.value;
            }
            else {
                suggestion.description = item.documentation.value;
            }
        }
    }
    /**
     * Public: Applies the textEdit part of a language server protocol CompletionItem to an AutoComplete+ Suggestion via
     * the replacementPrefix and text properties.
     *
     * @param textEdit A {TextEdit} from a CompletionItem to apply.
     * @param editor An Atom {TextEditor} used to obtain the necessary text replacement.
     * @param suggestion An {atom$AutocompleteSuggestion} to set the replacementPrefix and text properties of.
     * @param shouldReplace The behavior of suggestion acceptance (see {ShouldReplace}).
     */
    static applyTextEditToSuggestion(textEdit, editor, triggerColumns, originalBufferPosition, suggestion, shouldReplace) {
        if (!textEdit) {
            return;
        }
        let range;
        if ("range" in textEdit) {
            range = textEdit.range;
        }
        else if (shouldReplace) {
            range = textEdit.replace;
        }
        else {
            range = textEdit.insert;
        }
        if (range.start.character !== triggerColumns[0]) {
            const atomRange = convert_1.default.lsRangeToAtomRange(range);
            suggestion.customReplacmentPrefix = editor.getTextInBufferRange([atomRange.start, originalBufferPosition]);
        }
        suggestion.text = textEdit.newText;
    }
    /**
     * Handle additional text edits after a suggestion insert, e.g. `additionalTextEdits`.
     *
     * `additionalTextEdits` are An optional array of additional text edits that are applied when selecting this
     * completion. Edits must not overlap (including the same insert position) with the main edit nor with themselves.
     *
     * Additional text edits should be used to change text unrelated to the current cursor position (for example adding an
     * import statement at the top of the file if the completion item will insert an unqualified type).
     */
    static applyAdditionalTextEdits(event) {
        var _a;
        const suggestion = event.suggestion;
        const additionalEdits = (_a = suggestion.completionItem) === null || _a === void 0 ? void 0 : _a.additionalTextEdits;
        const buffer = event.editor.getBuffer();
        apply_edit_adapter_1.default.applyEdits(buffer, convert_1.default.convertLsTextEdits(additionalEdits));
        buffer.groupLastChanges();
    }
    /**
     * Public: Adds a snippet to the suggestion if the CompletionItem contains snippet-formatted text
     *
     * @param item An {CompletionItem} containing the completion items to be merged into.
     * @param suggestion The {atom$AutocompleteSuggestion} to merge the conversion into.
     */
    static applySnippetToSuggestion(item, suggestion) {
        if (item.insertTextFormat === languageclient_1.InsertTextFormat.Snippet) {
            suggestion.snippet = item.textEdit != null ? item.textEdit.newText : item.insertText || item.label;
        }
    }
    /**
     * Public: Obtain the textual suggestion type required by AutoComplete+ that most closely maps to the numeric
     * completion kind supplies by the language server.
     *
     * @param kind A {Number} that represents the suggestion kind to be converted.
     * @returns A {String} containing the AutoComplete+ suggestion type equivalent to the given completion kind.
     */
    static completionKindToSuggestionType(kind) {
        switch (kind) {
            case languageclient_1.CompletionItemKind.Constant:
                return "constant";
            case languageclient_1.CompletionItemKind.Method:
                return "method";
            case languageclient_1.CompletionItemKind.Function:
            case languageclient_1.CompletionItemKind.Constructor:
                return "function";
            case languageclient_1.CompletionItemKind.Field:
            case languageclient_1.CompletionItemKind.Property:
                return "property";
            case languageclient_1.CompletionItemKind.Variable:
                return "variable";
            case languageclient_1.CompletionItemKind.Class:
                return "class";
            case languageclient_1.CompletionItemKind.Struct:
            case languageclient_1.CompletionItemKind.TypeParameter:
                return "type";
            case languageclient_1.CompletionItemKind.Operator:
                return "selector";
            case languageclient_1.CompletionItemKind.Interface:
                return "mixin";
            case languageclient_1.CompletionItemKind.Module:
                return "module";
            case languageclient_1.CompletionItemKind.Unit:
                return "builtin";
            case languageclient_1.CompletionItemKind.Enum:
            case languageclient_1.CompletionItemKind.EnumMember:
                return "enum";
            case languageclient_1.CompletionItemKind.Keyword:
                return "keyword";
            case languageclient_1.CompletionItemKind.Snippet:
                return "snippet";
            case languageclient_1.CompletionItemKind.File:
            case languageclient_1.CompletionItemKind.Folder:
                return "import";
            case languageclient_1.CompletionItemKind.Reference:
                return "require";
            default:
                return "value";
        }
    }
}
exports.default = AutocompleteAdapter;
/**
 * Normalizes the given grammar scope for autoComplete package so it always starts with `.` Based on
 * https://github.com/atom/autocomplete-plus/wiki/Autocomplete-Providers
 *
 * @param grammarScope Such as 'source.python' or '.source.python'
 * @returns The normalized grammarScope such as `.source.python`
 */
function grammarScopeToAutoCompleteSelector(grammarScope) {
    return grammarScope.includes(".") && grammarScope[0] !== "." ? `.${grammarScope}` : grammarScope;
}
exports.grammarScopeToAutoCompleteSelector = grammarScopeToAutoCompleteSelector;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autocomplete-adapter.js","sourceRoot":"","sources":["../../../lib/adapters/autocomplete-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import Convert from \"../convert\"\nimport * as Utils from \"../utils\"\nimport { CancellationTokenSource } from \"vscode-jsonrpc\"\nimport { ActiveServer } from \"../server-manager\"\nimport { ObjectArrayFilterer } from \"zadeh\"\nimport {\n  CompletionContext,\n  CompletionItem,\n  CompletionItemKind,\n  CompletionList,\n  CompletionParams,\n  CompletionTriggerKind,\n  InsertTextFormat,\n  InsertReplaceEdit,\n  LanguageClientConnection,\n  Range,\n  ServerCapabilities,\n  TextEdit,\n} from \"../languageclient\"\nimport ApplyEditAdapter from \"./apply-edit-adapter\"\nimport { Point, TextEditor } from \"atom\"\nimport * as ac from \"atom/autocomplete-plus\"\nimport { Suggestion, TextSuggestion, SnippetSuggestion, SuggestionBase } from \"../types/autocomplete-extended\"\n\n/**\n * Defines the behavior of suggestion acceptance. Assume you have \"cons|ole\" in the editor ( `|` is the cursor position)\n * and the autocomplete suggestion is `const`.\n *\n * - If `false` -> the edits are inserted : const|ole\n * - If `true`` -> the edits are replaced: const|\n */\ntype ShouldReplace = boolean\n\n/**\n * Holds a list of suggestions generated from the CompletionItem[] list sent by the server, as well as metadata about\n * the context it was collected in\n */\ninterface SuggestionCacheEntry {\n  /** If `true`, the server will send a list of suggestions to replace this one */\n  isIncomplete: boolean\n  /** The point left of the first character in the original prefix sent to the server */\n  triggerPoint: Point\n  /** The point right of the last character in the original prefix sent to the server */\n  originalBufferPoint: Point\n  /** The trigger string that caused the autocomplete (if any) */\n  triggerChar: string\n  suggestionMap: Map<Suggestion, PossiblyResolvedCompletionItem>\n}\n\ntype CompletionItemAdjuster = (\n  item: CompletionItem,\n  suggestion: ac.AnySuggestion,\n  request: ac.SuggestionsRequestedEvent\n) => void\n\nclass PossiblyResolvedCompletionItem {\n  constructor(public completionItem: CompletionItem, public isResolved: boolean) {}\n}\n\n/** Public: Adapts the language server protocol \"textDocument/completion\" to the Atom AutoComplete+ package. */\nexport default class AutocompleteAdapter {\n  public static canAdapt(serverCapabilities: ServerCapabilities): boolean {\n    return serverCapabilities.completionProvider != null\n  }\n\n  public static canResolve(serverCapabilities: ServerCapabilities): boolean {\n    return (\n      serverCapabilities.completionProvider != null && serverCapabilities.completionProvider.resolveProvider === true\n    )\n  }\n\n  private _suggestionCache: WeakMap<ActiveServer, SuggestionCacheEntry> = new WeakMap()\n  private _cancellationTokens: WeakMap<LanguageClientConnection, CancellationTokenSource> = new WeakMap()\n\n  /**\n   * Public: Obtain suggestion list for AutoComplete+ by querying the language server using the `textDocument/completion` request.\n   *\n   * @param server An {ActiveServer} pointing to the language server to query.\n   * @param request The {atom$AutocompleteRequest} to satisfy.\n   * @param onDidConvertCompletionItem An optional function that takes a {CompletionItem}, an\n   *   {atom$AutocompleteSuggestion} and a {atom$AutocompleteRequest} allowing you to adjust converted items.\n   * @param shouldReplace The behavior of suggestion acceptance (see {ShouldReplace}).\n   * @returns A {Promise} of an {Array} of {atom$AutocompleteSuggestion}s containing the AutoComplete+ suggestions to display.\n   */\n  public async getSuggestions(\n    server: ActiveServer,\n    request: ac.SuggestionsRequestedEvent,\n    onDidConvertCompletionItem?: CompletionItemAdjuster,\n    minimumWordLength?: number,\n    shouldReplace: ShouldReplace = false\n  ): Promise<ac.AnySuggestion[]> {\n    const triggerChars =\n      server.capabilities.completionProvider != null\n        ? server.capabilities.completionProvider.triggerCharacters || []\n        : []\n\n    // triggerOnly is true if we have just typed in a trigger character, and is false if we\n    // have typed additional characters following a trigger character.\n    const [triggerChar, triggerOnly] = AutocompleteAdapter.getTriggerCharacter(request, triggerChars)\n\n    if (!this.shouldTrigger(request, triggerChar, minimumWordLength || 0)) {\n      return []\n    }\n\n    // Get the suggestions either from the cache or by calling the language server\n    const suggestions = await this.getOrBuildSuggestions(\n      server,\n      request,\n      triggerChar,\n      triggerOnly,\n      shouldReplace,\n      onDidConvertCompletionItem\n    )\n\n    // We must update the replacement prefix as characters are added and removed\n    const cache = this._suggestionCache.get(server)!\n    const replacementPrefix = request.editor.getTextInBufferRange([\n      [cache.triggerPoint.row, cache.triggerPoint.column + cache.triggerChar.length],\n      request.bufferPosition,\n    ])\n    for (const suggestion of suggestions) {\n      if (suggestion.customReplacmentPrefix) {\n        // having this property means a custom range was provided\n        const len = replacementPrefix.length\n        const preReplacementPrefix =\n          suggestion.customReplacmentPrefix +\n          replacementPrefix.substring(len + cache.originalBufferPoint.column - request.bufferPosition.column, len)\n        // we cannot replace text after the cursor with the current autocomplete-plus API\n        // so we will simply ignore it for now\n        suggestion.replacementPrefix = preReplacementPrefix\n      } else {\n        suggestion.replacementPrefix = replacementPrefix\n      }\n    }\n\n    const filtered = !(request.prefix === \"\" || (triggerChar !== \"\" && triggerOnly))\n    if (filtered) {\n      // filter the suggestions who have `filterText` property\n      const validSuggestions = suggestions.filter((sgs) => typeof sgs.filterText === \"string\") as Suggestion[] &\n        { filterText: string }[]\n      // TODO use `ObjectArrayFilterer.setCandidate` in `_suggestionCache` to avoid creating `ObjectArrayFilterer` every time from scratch\n      const objFilterer = new ObjectArrayFilterer(validSuggestions, \"filterText\")\n      // zadeh returns an array of the selected `Suggestions`\n      return objFilterer.filter(request.prefix) as any as Suggestion[]\n    } else {\n      return suggestions\n    }\n  }\n\n  private shouldTrigger(request: ac.SuggestionsRequestedEvent, triggerChar: string, minWordLength: number): boolean {\n    return (\n      request.activatedManually || triggerChar !== \"\" || minWordLength <= 0 || request.prefix.length >= minWordLength\n    )\n  }\n\n  private async getOrBuildSuggestions(\n    server: ActiveServer,\n    request: ac.SuggestionsRequestedEvent,\n    triggerChar: string,\n    triggerOnly: boolean,\n    shouldReplace: ShouldReplace,\n    onDidConvertCompletionItem?: CompletionItemAdjuster\n  ): Promise<Suggestion[]> {\n    const cache = this._suggestionCache.get(server)\n\n    const triggerColumn =\n      triggerChar !== \"\" && triggerOnly\n        ? request.bufferPosition.column - triggerChar.length\n        : request.bufferPosition.column - request.prefix.length - triggerChar.length\n    const triggerPoint = new Point(request.bufferPosition.row, triggerColumn)\n\n    // Do we have complete cached suggestions that are still valid for this request?\n    if (\n      cache &&\n      !cache.isIncomplete &&\n      cache.triggerChar === triggerChar &&\n      cache.triggerPoint.isEqual(triggerPoint) &&\n      cache.originalBufferPoint.isLessThanOrEqual(request.bufferPosition)\n    ) {\n      return Array.from(cache.suggestionMap.keys())\n    }\n\n    // Our cached suggestions can't be used so obtain new ones from the language server\n    const completions = await Utils.doWithCancellationToken(\n      server.connection,\n      this._cancellationTokens,\n      (cancellationToken) =>\n        server.connection.completion(\n          AutocompleteAdapter.createCompletionParams(request, triggerChar, triggerOnly),\n          cancellationToken\n        )\n    )\n\n    // spec guarantees all edits are on the same line, so we only need to check the columns\n    const triggerColumns: [number, number] = [triggerPoint.column, request.bufferPosition.column]\n\n    // Setup the cache for subsequent filtered results\n    const isComplete = completions === null || Array.isArray(completions) || !completions.isIncomplete\n    const suggestionMap = this.completionItemsToSuggestions(\n      completions,\n      request,\n      triggerColumns,\n      shouldReplace,\n      onDidConvertCompletionItem\n    )\n    this._suggestionCache.set(server, {\n      isIncomplete: !isComplete,\n      triggerChar,\n      triggerPoint,\n      originalBufferPoint: request.bufferPosition,\n      suggestionMap,\n    })\n\n    return Array.from(suggestionMap.keys())\n  }\n\n  /**\n   * Public: Obtain a complete version of a suggestion with additional information the language server can provide by\n   * way of the `completionItem/resolve` request.\n   *\n   * @param server An {ActiveServer} pointing to the language server to query.\n   * @param suggestion An {atom$AutocompleteSuggestion} suggestion that should be resolved.\n   * @param request An {Object} with the AutoComplete+ request to satisfy.\n   * @param onDidConvertCompletionItem An optional function that takes a {CompletionItem}, an\n   *   {atom$AutocompleteSuggestion} and a {atom$AutocompleteRequest} allowing you to adjust converted items.\n   * @returns A {Promise} of an {atom$AutocompleteSuggestion} with the resolved AutoComplete+ suggestion.\n   */\n  public async completeSuggestion(\n    server: ActiveServer,\n    suggestion: ac.AnySuggestion,\n    request: ac.SuggestionsRequestedEvent,\n    onDidConvertCompletionItem?: CompletionItemAdjuster\n  ): Promise<ac.AnySuggestion> {\n    const cache = this._suggestionCache.get(server)\n    if (cache) {\n      const possiblyResolvedCompletionItem = cache.suggestionMap.get(suggestion)\n      if (possiblyResolvedCompletionItem != null && !possiblyResolvedCompletionItem.isResolved) {\n        const resolvedCompletionItem = await server.connection.completionItemResolve(\n          possiblyResolvedCompletionItem.completionItem\n        )\n        if (resolvedCompletionItem != null) {\n          AutocompleteAdapter.resolveSuggestion(resolvedCompletionItem, suggestion, request, onDidConvertCompletionItem)\n          possiblyResolvedCompletionItem.isResolved = true\n        }\n      }\n    }\n    return suggestion\n  }\n\n  public static resolveSuggestion(\n    resolvedCompletionItem: CompletionItem,\n    suggestion: ac.AnySuggestion,\n    request: ac.SuggestionsRequestedEvent,\n    onDidConvertCompletionItem?: CompletionItemAdjuster\n  ): void {\n    // only the `documentation` and `detail` properties may change when resolving\n    AutocompleteAdapter.applyDetailsToSuggestion(resolvedCompletionItem, suggestion)\n    if (onDidConvertCompletionItem != null) {\n      onDidConvertCompletionItem(resolvedCompletionItem, suggestion as ac.AnySuggestion, request)\n    }\n  }\n\n  /**\n   * Public: Get the trigger character that caused the autocomplete (if any). This is required because AutoComplete-plus\n   * does not have trigger characters. Although the terminology is 'character' we treat them as variable length strings\n   * as this will almost certainly change in the future to support '->' etc.\n   *\n   * @param request An {Array} of {atom$AutocompleteSuggestion}s to locate the prefix, editor, bufferPosition etc.\n   * @param triggerChars The {Array} of {string}s that can be trigger characters.\n   * @returns A [{string}, boolean] where the string is the matching trigger character or an empty string if one was not\n   *   matched, and the boolean is true if the trigger character is in request.prefix, and false if it is in the word\n   *   before request.prefix. The boolean return value has no meaning if the string return value is an empty string.\n   */\n  public static getTriggerCharacter(request: ac.SuggestionsRequestedEvent, triggerChars: string[]): [string, boolean] {\n    // AutoComplete-Plus considers text after a symbol to be a new trigger. So we should look backward\n    // from the current cursor position to see if one is there and thus simulate it.\n    const buffer = request.editor.getBuffer()\n    const cursor = request.bufferPosition\n    const prefixStartColumn = cursor.column - request.prefix.length\n    for (const triggerChar of triggerChars) {\n      if (request.prefix.endsWith(triggerChar)) {\n        return [triggerChar, true]\n      }\n      if (prefixStartColumn >= triggerChar.length) {\n        // Far enough along a line to fit the trigger char\n        const start = new Point(cursor.row, prefixStartColumn - triggerChar.length)\n        const possibleTrigger = buffer.getTextInRange([start, [cursor.row, prefixStartColumn]])\n        if (possibleTrigger === triggerChar) {\n          // The text before our trigger is a trigger char!\n          return [triggerChar, false]\n        }\n      }\n    }\n\n    // There was no explicit trigger char\n    return [\"\", false]\n  }\n\n  /**\n   * Public: Create TextDocumentPositionParams to be sent to the language server based on the editor and position from\n   * the AutoCompleteRequest.\n   *\n   * @param request The {atom$AutocompleteRequest} to obtain the editor from.\n   * @param triggerPoint The {atom$Point} where the trigger started.\n   * @returns A {string} containing the prefix including the trigger character.\n   */\n  public static getPrefixWithTrigger(request: ac.SuggestionsRequestedEvent, triggerPoint: Point): string {\n    return request.editor.getBuffer().getTextInRange([[triggerPoint.row, triggerPoint.column], request.bufferPosition])\n  }\n\n  /**\n   * Public: Create {CompletionParams} to be sent to the language server based on the editor and position from the\n   * Autocomplete request etc.\n   *\n   * @param request The {atom$AutocompleteRequest} containing the request details.\n   * @param triggerCharacter The {string} containing the trigger character (empty if none).\n   * @param triggerOnly A {boolean} representing whether this completion is triggered right after a trigger character.\n   * @returns A {CompletionParams} with the keys:\n   *\n   *   - `textDocument` the language server protocol textDocument identification.\n   *   - `position` the position within the text document to display completion request for.\n   *   - `context` containing the trigger character and kind.\n   */\n  public static createCompletionParams(\n    request: ac.SuggestionsRequestedEvent,\n    triggerCharacter: string,\n    triggerOnly: boolean\n  ): CompletionParams {\n    return {\n      textDocument: Convert.editorToTextDocumentIdentifier(request.editor),\n      position: Convert.pointToPosition(request.bufferPosition),\n      context: AutocompleteAdapter.createCompletionContext(triggerCharacter, triggerOnly),\n    }\n  }\n\n  /**\n   * Public: Create {CompletionContext} to be sent to the language server based on the trigger character.\n   *\n   * @param triggerCharacter The {string} containing the trigger character or '' if none.\n   * @param triggerOnly A {boolean} representing whether this completion is triggered right after a trigger character.\n   * @returns An {CompletionContext} that specifies the triggerKind and the triggerCharacter if there is one.\n   */\n  public static createCompletionContext(triggerCharacter: string, triggerOnly: boolean): CompletionContext {\n    if (triggerCharacter === \"\") {\n      return { triggerKind: CompletionTriggerKind.Invoked }\n    } else {\n      return triggerOnly\n        ? { triggerKind: CompletionTriggerKind.TriggerCharacter, triggerCharacter }\n        : { triggerKind: CompletionTriggerKind.TriggerForIncompleteCompletions, triggerCharacter }\n    }\n  }\n\n  /**\n   * Public: Convert a language server protocol CompletionItem array or CompletionList to an array of ordered\n   * AutoComplete+ suggestions.\n   *\n   * @param completionItems An {Array} of {CompletionItem} objects or a {CompletionList} containing completion items to\n   *   be converted.\n   * @param request The {atom$AutocompleteRequest} to satisfy.\n   * @param shouldReplace The behavior of suggestion acceptance (see {ShouldReplace}).\n   * @param onDidConvertCompletionItem A function that takes a {CompletionItem}, an {atom$AutocompleteSuggestion} and a\n   *   {atom$AutocompleteRequest} allowing you to adjust converted items.\n   * @returns A {Map} of AutoComplete+ suggestions ordered by the CompletionItems sortText.\n   */\n  public completionItemsToSuggestions(\n    completionItems: CompletionItem[] | CompletionList | null,\n    request: ac.SuggestionsRequestedEvent,\n    triggerColumns: [number, number],\n    shouldReplace: ShouldReplace,\n    onDidConvertCompletionItem?: CompletionItemAdjuster\n  ): Map<Suggestion, PossiblyResolvedCompletionItem> {\n    const completionsArray = Array.isArray(completionItems)\n      ? completionItems\n      : (completionItems && completionItems.items) || []\n    return new Map(\n      completionsArray\n        .sort((a, b) => (a.sortText || a.label).localeCompare(b.sortText || b.label))\n        .map<[Suggestion, PossiblyResolvedCompletionItem]>((s) => [\n          AutocompleteAdapter.completionItemToSuggestion(\n            s,\n            {} as Suggestion,\n            request,\n            triggerColumns,\n            shouldReplace,\n            onDidConvertCompletionItem\n          ),\n          new PossiblyResolvedCompletionItem(s, false),\n        ])\n    )\n  }\n\n  /**\n   * Public: Convert a language server protocol CompletionItem to an AutoComplete+ suggestion.\n   *\n   * @param item An {CompletionItem} containing a completion item to be converted.\n   * @param suggestion A {atom$AutocompleteSuggestion} to have the conversion applied to.\n   * @param request The {atom$AutocompleteRequest} to satisfy.\n   * @param shouldReplace The behavior of suggestion acceptance (see {ShouldReplace}).\n   * @param onDidConvertCompletionItem A function that takes a {CompletionItem}, an {atom$AutocompleteSuggestion} and a\n   *   {atom$AutocompleteRequest} allowing you to adjust converted items.\n   * @returns The {atom$AutocompleteSuggestion} passed in as suggestion with the conversion applied.\n   */\n  public static completionItemToSuggestion(\n    item: CompletionItem,\n    suggestion: Suggestion,\n    request: ac.SuggestionsRequestedEvent,\n    triggerColumns: [number, number],\n    shouldReplace: ShouldReplace,\n    onDidConvertCompletionItem?: CompletionItemAdjuster\n  ): Suggestion {\n    AutocompleteAdapter.applyCompletionItemToSuggestion(item, suggestion as TextSuggestion)\n    AutocompleteAdapter.applyTextEditToSuggestion(\n      item.textEdit,\n      request.editor,\n      triggerColumns,\n      request.bufferPosition,\n      suggestion as TextSuggestion,\n      shouldReplace\n    )\n    AutocompleteAdapter.applySnippetToSuggestion(item, suggestion as SnippetSuggestion)\n    if (onDidConvertCompletionItem != null) {\n      onDidConvertCompletionItem(item, suggestion as ac.AnySuggestion, request)\n    }\n\n    return suggestion\n  }\n\n  /**\n   * Public: Convert the primary parts of a language server protocol CompletionItem to an AutoComplete+ suggestion.\n   *\n   * @param item An {CompletionItem} containing the completion items to be merged into.\n   * @param suggestion The {Suggestion} to merge the conversion into.\n   * @returns The {Suggestion} with details added from the {CompletionItem}.\n   */\n  public static applyCompletionItemToSuggestion(item: CompletionItem, suggestion: TextSuggestion): void {\n    suggestion.text = item.insertText || item.label\n    suggestion.filterText = item.filterText || item.label\n    suggestion.displayText = item.label\n    suggestion.type = AutocompleteAdapter.completionKindToSuggestionType(item.kind)\n    AutocompleteAdapter.applyDetailsToSuggestion(item, suggestion)\n    suggestion.completionItem = item\n  }\n\n  public static applyDetailsToSuggestion(item: CompletionItem, suggestion: Suggestion): void {\n    suggestion.rightLabel = item.detail\n\n    // Older format, can't know what it is so assign to both and hope for best\n    if (typeof item.documentation === \"string\") {\n      suggestion.descriptionMarkdown = item.documentation\n      suggestion.description = item.documentation\n    }\n\n    if (item.documentation != null && typeof item.documentation === \"object\") {\n      // Newer format specifies the kind of documentation, assign appropriately\n      if (item.documentation.kind === \"markdown\") {\n        suggestion.descriptionMarkdown = item.documentation.value\n      } else {\n        suggestion.description = item.documentation.value\n      }\n    }\n  }\n\n  /**\n   * Public: Applies the textEdit part of a language server protocol CompletionItem to an AutoComplete+ Suggestion via\n   * the replacementPrefix and text properties.\n   *\n   * @param textEdit A {TextEdit} from a CompletionItem to apply.\n   * @param editor An Atom {TextEditor} used to obtain the necessary text replacement.\n   * @param suggestion An {atom$AutocompleteSuggestion} to set the replacementPrefix and text properties of.\n   * @param shouldReplace The behavior of suggestion acceptance (see {ShouldReplace}).\n   */\n  public static applyTextEditToSuggestion(\n    textEdit: TextEdit | InsertReplaceEdit | undefined,\n    editor: TextEditor,\n    triggerColumns: [number, number],\n    originalBufferPosition: Point,\n    suggestion: TextSuggestion,\n    shouldReplace: ShouldReplace\n  ): void {\n    if (!textEdit) {\n      return\n    }\n    let range: Range\n    if (\"range\" in textEdit) {\n      range = textEdit.range\n    } else if (shouldReplace) {\n      range = textEdit.replace\n    } else {\n      range = textEdit.insert\n    }\n\n    if (range.start.character !== triggerColumns[0]) {\n      const atomRange = Convert.lsRangeToAtomRange(range)\n      suggestion.customReplacmentPrefix = editor.getTextInBufferRange([atomRange.start, originalBufferPosition])\n    }\n    suggestion.text = textEdit.newText\n  }\n\n  /**\n   * Handle additional text edits after a suggestion insert, e.g. `additionalTextEdits`.\n   *\n   * `additionalTextEdits` are An optional array of additional text edits that are applied when selecting this\n   * completion. Edits must not overlap (including the same insert position) with the main edit nor with themselves.\n   *\n   * Additional text edits should be used to change text unrelated to the current cursor position (for example adding an\n   * import statement at the top of the file if the completion item will insert an unqualified type).\n   */\n  public static applyAdditionalTextEdits(event: ac.SuggestionInsertedEvent): void {\n    const suggestion = event.suggestion as SuggestionBase\n    const additionalEdits = suggestion.completionItem?.additionalTextEdits\n    const buffer = event.editor.getBuffer()\n\n    ApplyEditAdapter.applyEdits(buffer, Convert.convertLsTextEdits(additionalEdits))\n    buffer.groupLastChanges()\n  }\n\n  /**\n   * Public: Adds a snippet to the suggestion if the CompletionItem contains snippet-formatted text\n   *\n   * @param item An {CompletionItem} containing the completion items to be merged into.\n   * @param suggestion The {atom$AutocompleteSuggestion} to merge the conversion into.\n   */\n  public static applySnippetToSuggestion(item: CompletionItem, suggestion: SnippetSuggestion): void {\n    if (item.insertTextFormat === InsertTextFormat.Snippet) {\n      suggestion.snippet = item.textEdit != null ? item.textEdit.newText : item.insertText || item.label\n    }\n  }\n\n  /**\n   * Public: Obtain the textual suggestion type required by AutoComplete+ that most closely maps to the numeric\n   * completion kind supplies by the language server.\n   *\n   * @param kind A {Number} that represents the suggestion kind to be converted.\n   * @returns A {String} containing the AutoComplete+ suggestion type equivalent to the given completion kind.\n   */\n  public static completionKindToSuggestionType(kind: number | undefined): string {\n    switch (kind) {\n      case CompletionItemKind.Constant:\n        return \"constant\"\n      case CompletionItemKind.Method:\n        return \"method\"\n      case CompletionItemKind.Function:\n      case CompletionItemKind.Constructor:\n        return \"function\"\n      case CompletionItemKind.Field:\n      case CompletionItemKind.Property:\n        return \"property\"\n      case CompletionItemKind.Variable:\n        return \"variable\"\n      case CompletionItemKind.Class:\n        return \"class\"\n      case CompletionItemKind.Struct:\n      case CompletionItemKind.TypeParameter:\n        return \"type\"\n      case CompletionItemKind.Operator:\n        return \"selector\"\n      case CompletionItemKind.Interface:\n        return \"mixin\"\n      case CompletionItemKind.Module:\n        return \"module\"\n      case CompletionItemKind.Unit:\n        return \"builtin\"\n      case CompletionItemKind.Enum:\n      case CompletionItemKind.EnumMember:\n        return \"enum\"\n      case CompletionItemKind.Keyword:\n        return \"keyword\"\n      case CompletionItemKind.Snippet:\n        return \"snippet\"\n      case CompletionItemKind.File:\n      case CompletionItemKind.Folder:\n        return \"import\"\n      case CompletionItemKind.Reference:\n        return \"require\"\n      default:\n        return \"value\"\n    }\n  }\n}\n\n/**\n * Normalizes the given grammar scope for autoComplete package so it always starts with `.` Based on\n * https://github.com/atom/autocomplete-plus/wiki/Autocomplete-Providers\n *\n * @param grammarScope Such as 'source.python' or '.source.python'\n * @returns The normalized grammarScope such as `.source.python`\n */\nexport function grammarScopeToAutoCompleteSelector(grammarScope: string): string {\n  return grammarScope.includes(\".\") && grammarScope[0] !== \".\" ? `.${grammarScope}` : grammarScope\n}\n"]}