atom-languageclient/build/lib/adapters/definition-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 });
const convert_1 = require("../convert");
const Utils = require("../utils");
const languageclient_1 = require("../languageclient");
const atom_1 = require("atom");
/**
 * Public: Adapts the language server definition provider to the Atom IDE UI Definitions package for 'Go To Definition'
 * functionality.
 */
class DefinitionAdapter {
    /**
     * Public: Determine whether this adapter can be used to adapt a language server based on the serverCapabilities
     * matrix containing a definitionProvider.
     *
     * @param serverCapabilities The {ServerCapabilities} of the language server to consider.
     * @returns A {Boolean} indicating adapter can adapt the server based on the given serverCapabilities.
     */
    static canAdapt(serverCapabilities) {
        return serverCapabilities.definitionProvider === true;
    }
    /**
     * Public: Get the definitions for a symbol at a given {Point} within a {TextEditor} including optionally highlighting
     * all other references within the document if the langauge server also supports highlighting.
     *
     * @param connection A {LanguageClientConnection} to the language server that will provide definitions and highlights.
     * @param serverCapabilities The {ServerCapabilities} of the language server that will be used.
     * @param languageName The name of the programming language.
     * @param editor The Atom {TextEditor} containing the symbol and potential highlights.
     * @param point The Atom {Point} containing the position of the text that represents the symbol for which the
     *   definition and highlights should be provided.
     * @returns A {Promise} indicating adapter can adapt the server based on the given serverCapabilities.
     */
    getDefinition(connection, serverCapabilities, languageName, editor, point) {
        return __awaiter(this, void 0, void 0, function* () {
            const documentPositionParams = convert_1.default.editorToTextDocumentPositionParams(editor, point);
            const definitionLocations = DefinitionAdapter.normalizeLocations(yield connection.gotoDefinition(documentPositionParams));
            if (definitionLocations == null || definitionLocations.length === 0) {
                return null;
            }
            let queryRange;
            if (serverCapabilities.documentHighlightProvider) {
                const highlights = yield connection.documentHighlight(documentPositionParams);
                if (highlights != null && highlights.length > 0) {
                    queryRange = highlights.map((h) => convert_1.default.lsRangeToAtomRange(h.range));
                }
            }
            return {
                queryRange: queryRange || [Utils.getWordAtPosition(editor, point)],
                definitions: DefinitionAdapter.convertLocationsToDefinitions(definitionLocations, languageName),
            };
        });
    }
    /**
     * Public: Normalize the locations so a single {Location} becomes an {Array} of just one. The language server protocol
     * return either as the protocol evolved between v1 and v2.
     *
     * @param locationResult Either a single {Location} object or an {Array} of {Locations}.
     * @returns An {Array} of {Location}s or {null} if the locationResult was null.
     */
    static normalizeLocations(locationResult) {
        if (locationResult == null) {
            // TODO use ===
            return null;
        }
        // TODO `d.targetRange.start` never becomes `null` according to the types
        if (isLocationLinkArray(locationResult)) {
            return locationResult.filter((d) => d.targetRange.start != null);
        }
        return (Array.isArray(locationResult) ? locationResult : [locationResult]).filter((d) => d.range.start != null);
    }
    /**
     * Public: Convert an {Array} of {Location} objects into an Array of {Definition}s.
     *
     * @param locations An {Array} of {Location} objects to be converted.
     * @param languageName The name of the language these objects are written in.
     * @returns An {Array} of {Definition}s that represented the converted {Location}s.
     */
    static convertLocationsToDefinitions(locations, languageName) {
        if (isLocationLinkArray(locations)) {
            return locations.map((d) => ({
                path: convert_1.default.uriToPath(d.targetUri),
                position: convert_1.default.positionToPoint(d.targetRange.start),
                range: atom_1.Range.fromObject(convert_1.default.lsRangeToAtomRange(d.targetRange)),
                language: languageName,
            }));
        }
        return locations.map((d) => ({
            path: convert_1.default.uriToPath(d.uri),
            position: convert_1.default.positionToPoint(d.range.start),
            range: atom_1.Range.fromObject(convert_1.default.lsRangeToAtomRange(d.range)),
            language: languageName,
        }));
    }
}
exports.default = DefinitionAdapter;
function isLocationLinkArray(value) {
    return Array.isArray(value) && languageclient_1.LocationLink.is(value[0]);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition-adapter.js","sourceRoot":"","sources":["../../../lib/adapters/definition-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as atomIde from \"atom-ide-base\"\nimport Convert from \"../convert\"\nimport * as Utils from \"../utils\"\nimport { LanguageClientConnection, Location, LocationLink, ServerCapabilities } from \"../languageclient\"\nimport { Point, TextEditor, Range } from \"atom\"\n\n/**\n * Public: Adapts the language server definition provider to the Atom IDE UI Definitions package for 'Go To Definition'\n * functionality.\n */\nexport default class DefinitionAdapter {\n  /**\n   * Public: Determine whether this adapter can be used to adapt a language server based on the serverCapabilities\n   * matrix containing a definitionProvider.\n   *\n   * @param serverCapabilities The {ServerCapabilities} of the language server to consider.\n   * @returns A {Boolean} indicating adapter can adapt the server based on the given serverCapabilities.\n   */\n  public static canAdapt(serverCapabilities: ServerCapabilities): boolean {\n    return serverCapabilities.definitionProvider === true\n  }\n\n  /**\n   * Public: Get the definitions for a symbol at a given {Point} within a {TextEditor} including optionally highlighting\n   * all other references within the document if the langauge server also supports highlighting.\n   *\n   * @param connection A {LanguageClientConnection} to the language server that will provide definitions and highlights.\n   * @param serverCapabilities The {ServerCapabilities} of the language server that will be used.\n   * @param languageName The name of the programming language.\n   * @param editor The Atom {TextEditor} containing the symbol and potential highlights.\n   * @param point The Atom {Point} containing the position of the text that represents the symbol for which the\n   *   definition and highlights should be provided.\n   * @returns A {Promise} indicating adapter can adapt the server based on the given serverCapabilities.\n   */\n  public async getDefinition(\n    connection: LanguageClientConnection,\n    serverCapabilities: ServerCapabilities,\n    languageName: string,\n    editor: TextEditor,\n    point: Point\n  ): Promise<atomIde.DefinitionQueryResult | null> {\n    const documentPositionParams = Convert.editorToTextDocumentPositionParams(editor, point)\n    const definitionLocations = DefinitionAdapter.normalizeLocations(\n      await connection.gotoDefinition(documentPositionParams)\n    )\n    if (definitionLocations == null || definitionLocations.length === 0) {\n      return null\n    }\n\n    let queryRange\n    if (serverCapabilities.documentHighlightProvider) {\n      const highlights = await connection.documentHighlight(documentPositionParams)\n      if (highlights != null && highlights.length > 0) {\n        queryRange = highlights.map((h) => Convert.lsRangeToAtomRange(h.range))\n      }\n    }\n\n    return {\n      queryRange: queryRange || [Utils.getWordAtPosition(editor, point)],\n      definitions: DefinitionAdapter.convertLocationsToDefinitions(definitionLocations, languageName),\n    }\n  }\n\n  /**\n   * Public: Normalize the locations so a single {Location} becomes an {Array} of just one. The language server protocol\n   * return either as the protocol evolved between v1 and v2.\n   *\n   * @param locationResult Either a single {Location} object or an {Array} of {Locations}.\n   * @returns An {Array} of {Location}s or {null} if the locationResult was null.\n   */\n  public static normalizeLocations(\n    locationResult: Location | Location[] | LocationLink[] | null\n  ): Location[] | LocationLink[] | null {\n    if (locationResult == null) {\n      // TODO use ===\n      return null\n    }\n    // TODO `d.targetRange.start` never becomes `null` according to the types\n    if (isLocationLinkArray(locationResult)) {\n      return locationResult.filter((d) => d.targetRange.start != null)\n    }\n    return (Array.isArray(locationResult) ? locationResult : [locationResult]).filter((d) => d.range.start != null)\n  }\n\n  /**\n   * Public: Convert an {Array} of {Location} objects into an Array of {Definition}s.\n   *\n   * @param locations An {Array} of {Location} objects to be converted.\n   * @param languageName The name of the language these objects are written in.\n   * @returns An {Array} of {Definition}s that represented the converted {Location}s.\n   */\n  public static convertLocationsToDefinitions(\n    locations: Location[] | LocationLink[],\n    languageName: string\n  ): atomIde.Definition[] {\n    if (isLocationLinkArray(locations)) {\n      return locations.map((d) => ({\n        path: Convert.uriToPath(d.targetUri),\n        position: Convert.positionToPoint(d.targetRange.start),\n        range: Range.fromObject(Convert.lsRangeToAtomRange(d.targetRange)),\n        language: languageName,\n      }))\n    }\n    return locations.map((d) => ({\n      path: Convert.uriToPath(d.uri),\n      position: Convert.positionToPoint(d.range.start),\n      range: Range.fromObject(Convert.lsRangeToAtomRange(d.range)),\n      language: languageName,\n    }))\n  }\n}\n\nfunction isLocationLinkArray(value: any): value is LocationLink[] {\n  return Array.isArray(value) && LocationLink.is(value[0])\n}\n"]}