greybel-languageserver-core/dist/features/definition.js

Core functionality of language server for GreyScript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.activate = void 0;
const miniscript_core_1 = require("miniscript-core");
const lookup_type_1 = require("../helper/lookup-type");
const definitionLinkToString = (link) => {
    return `${link.uri}:${link.range.start.line}:${link.range.start.character}-${link.range.end.line}:${link.range.end.character}`;
};
const getLocation = (item) => {
    const node = item.astRef;
    let start;
    let end;
    switch (node.type) {
        case miniscript_core_1.ASTType.ForGenericStatement: {
            const stmt = node;
            start = {
                line: stmt.variable.start.line - 1,
                character: stmt.variable.start.character - 1
            };
            end = {
                line: stmt.variable.end.line - 1,
                character: stmt.variable.end.character - 1
            };
            break;
        }
        default: {
            start = {
                line: node.start.line - 1,
                character: node.start.character - 1
            };
            end = {
                line: node.end.line - 1,
                character: node.end.character - 1
            };
        }
    }
    return {
        uri: item.document,
        range: { start, end }
    };
};
const findAllDefinitions = async (helper, item) => {
    const result = await helper.findAllAssignmentsOfItem(item);
    const sources = result?.getSource();
    if (sources == null || sources.length === 0) {
        return [];
    }
    const definitions = [];
    const visited = new Set();
    for (const source of sources) {
        const node = source.astRef;
        if (node == null) {
            continue;
        }
        if (!node.start || !node.end) {
            continue;
        }
        const definitionLink = getLocation(source);
        const linkString = definitionLinkToString(definitionLink);
        if (visited.has(linkString)) {
            continue;
        }
        visited.add(linkString);
        definitions.push(definitionLink);
    }
    return definitions;
};
function activate(context) {
    context.connection.onDefinition(async (params) => {
        const document = await context.fs.getTextDocument(params.textDocument.uri);
        if (document == null) {
            return;
        }
        const activeDocument = await context.documentManager.getLatest(document);
        const helper = new lookup_type_1.LookupHelper(activeDocument, context);
        const astResult = await helper.lookupAST(params.position);
        if (!astResult) {
            return;
        }
        const { outer, closest } = astResult;
        const previous = outer.length > 0 ? outer[outer.length - 1] : undefined;
        let target = closest;
        if (previous) {
            if (previous instanceof miniscript_core_1.ASTMemberExpression &&
                previous.identifier === closest) {
                target = previous;
            }
        }
        return await findAllDefinitions(helper, target);
    });
}
exports.activate = activate;
//# sourceMappingURL=definition.js.map