@gooddata/sdk-maql-language-server 0.0.0-stage → 11.65.0-alpha.10

package/esm/completions/descriptions.js

@@ -0,0 +1,289 @@
+// (C) 2021-2026 GoodData Corporation
+import { CompletionItemKind, InsertTextFormat } from "vscode-languageserver";
+import { MaqlParser } from "@gooddata/maql-antlr4ts";
+import { errorTokens } from "../diagnostics.js";
+import { getTokenIdFromName } from "../parseMaql.js";
+import { MaqlType } from "../types/hierarchy.js";
+import { functionDescriptions } from "./functionDescriptions.js";
+/**
+ * Maps concepts from MAQL to completionItemKind values
+ */
+export const Kind = {
+    Attribute: CompletionItemKind.Enum,
+    Label: CompletionItemKind.Enum,
+    Metric: CompletionItemKind.Variable,
+    Parameter: CompletionItemKind.Value,
+    Fact: CompletionItemKind.Field,
+    Dataset: CompletionItemKind.Constant,
+    LabelElement: CompletionItemKind.Text,
+    Function: CompletionItemKind.Function,
+    Keyword: CompletionItemKind.Keyword,
+    Operator: CompletionItemKind.Operator,
+    Boolean: CompletionItemKind.Value,
+    Granularity: CompletionItemKind.EnumMember,
+    Snippet: CompletionItemKind.Snippet,
+};
+/**
+ * Tokens that will not generate any completion items
+ * Note that this can be overwritten by creating a CompletionDescription that triggers on that token
+ */
+export const ignoredTokens = new Set([
+    MaqlParser.String,
+    MaqlParser.OVER,
+    MaqlParser.TO,
+    MaqlParser.LPAREN,
+    MaqlParser.LBRACE,
+    MaqlParser.ID,
+    MaqlParser.SEP,
+    MaqlParser.RBRACE,
+    MaqlParser.ZERO,
+    MaqlParser.Natural,
+    MaqlParser.Real,
+    MaqlParser.COMMA,
+    MaqlParser.METRIC_TYPE,
+    MaqlParser.ATTRIBUTE,
+    MaqlParser.COMPUTED_ATTRIBUTE_OBJECT,
+    MaqlParser.LABEL,
+    MaqlParser.DATASET,
+    MaqlParser.PROMPT,
+    MaqlParser.PARAMETER,
+    MaqlParser.FACT,
+    MaqlParser.LOCAL,
+    MaqlParser.WS,
+    MaqlParser.Comment,
+    MaqlParser.REPORT,
+    MaqlParser.METRIC,
+    MaqlParser.SEMICOLON,
+    MaqlParser.EOF,
+    MaqlParser.NEXT,
+    MaqlParser.PREVIOUS,
+    MaqlParser.THIS,
+    // fiscal granularities below are parsed by the grammar but not yet fully
+    // delivered in the product, so they are hidden from completion suggestions
+    MaqlParser.FISCALWEEK,
+    MaqlParser.FISCALSEMESTER,
+    MaqlParser.FISCALDAYOFFISCALWEEK,
+    MaqlParser.FISCALDAYOFFISCALMONTH,
+    MaqlParser.FISCALDAYOFFISCALQUARTER,
+    MaqlParser.FISCALDAYOFFISCALSEMESTER,
+    MaqlParser.FISCALDAYOFFISCALYEAR,
+    MaqlParser.FISCALWEEKOFFISCALMONTH,
+    MaqlParser.FISCALWEEKOFFISCALQUARTER,
+    MaqlParser.FISCALWEEKOFFISCALSEMESTER,
+    MaqlParser.FISCALWEEKOFFISCALYEAR,
+    MaqlParser.FISCALMONTHOFFISCALQUARTER,
+    MaqlParser.FISCALMONTHOFFISCALSEMESTER,
+    MaqlParser.FISCALMONTHOFFISCALYEAR,
+    MaqlParser.FISCALQUARTEROFFISCALSEMESTER,
+    MaqlParser.FISCALQUARTEROFFISCALYEAR,
+    MaqlParser.FISCALSEMESTEROFFISCALYEAR,
+    ...errorTokens,
+]);
+export const descriptions = [
+    ...functionDescriptions,
+    desc("%", Kind.Operator, "PERCENT operator (MAQL)"),
+    desc("()", Kind.Operator),
+    desc(")", Kind.Operator),
+    desc("*", Kind.Operator, "MULTIPLICATION operator (MAQL)", "arithmetic-operations", undefined, " "),
+    desc("+", Kind.Operator, "PLUS operator (MAQL)", "arithmetic-operations", undefined, " "),
+    desc("-", Kind.Operator, "MINUS operator (MAQL)", "arithmetic-operations", undefined, " "),
+    desc("/", Kind.Operator, "DIVISION operator (MAQL)", "arithmetic-operations", undefined, " "),
+    desc("<", Kind.Operator, "LESSER filtering operator (MAQL)", "relational-operators", undefined, " "),
+    desc("<=", Kind.Operator, "LESSER OR EQUAL filtering operator (MAQL)", "relational-operators", undefined, " "),
+    desc("<>", Kind.Operator, "DOES NOT EQUAL filtering operator (MAQL)", "relational-operators", undefined, " "),
+    desc("=", Kind.Operator, "EQUALS filtering operator (MAQL)", "relational-operators", undefined, " "),
+    desc(">", Kind.Operator, "GREATER filtering operator (MAQL)", "relational-operators", undefined, " "),
+    desc(">=", Kind.Operator, "GREATER OR EQUAL filtering operator (MAQL)", "relational-operators", undefined, " "),
+    desc("ALL", Kind.Keyword, "ALL keyword (MAQL)", "by-all", undefined, " "),
+    desc("AND", Kind.Keyword, "AND logical operator (MAQL)", "and", undefined, " "),
+    desc("ASC", Kind.Keyword, "ASC keyword (MAQL)", undefined, undefined, " "),
+    desc("BETWEEN", Kind.Keyword, "BETWEEN keyword (MAQL)", "relational-operators", undefined, " "),
+    desc("ALL OTHER EXCEPT", Kind.Keyword, "ALL OTHER EXCEPT clause (MAQL)", "by-all-in-all-other-dimensions-except-for-attribute", undefined, " "),
+    desc("ALL OTHER", Kind.Keyword, "ALL OTHER clause (MAQL)", "by-all-in-all-other-dimensions", undefined),
+    desc("BY", Kind.Keyword, "BY keyword (MAQL)", "by", undefined, " "),
+    desc("CASE", Kind.Keyword, "CASE keyword (MAQL)", "case", undefined, " "),
+    desc("COMPUTED ATTRIBUTE", Kind.Keyword, "COMPUTED ATTRIBUTE keyword (MAQL)", undefined, undefined, " "),
+    desc("CURRENT", Kind.Keyword, "CURRENT keyword (MAQL)", undefined, undefined, ""),
+    desc("DESC", Kind.Keyword, "DESC keyword (MAQL)", undefined, undefined, " "),
+    desc("DIMENSIONS", Kind.Keyword, "DIMENSIONS keyword (MAQL)", undefined, undefined, " "),
+    desc("ELSE", Kind.Keyword, "ELSE keyword (MAQL)", undefined, undefined, " "),
+    desc("END", Kind.Keyword, "END keyword (MAQL)", undefined, undefined, " "),
+    desc("EXCEPT", Kind.Keyword, "EXCEPT keyword (MAQL)", undefined, undefined, " "),
+    desc("FILTER", Kind.Keyword, "FILTER keyword (MAQL)", undefined, undefined, " "),
+    desc("FOLLOWING", Kind.Keyword, "FOLLOWING keyword (MAQL)", undefined, undefined, " "),
+    desc("FOR", Kind.Keyword, "FOR keyword (MAQL)", undefined, undefined, " "),
+    desc("FOR EACH", Kind.Keyword, "FOR EACH keyword (MAQL)", "for-each", undefined, " "),
+    desc("EACH", Kind.Keyword, "FOR EACH keyword (MAQL)", "for-each", undefined, " "),
+    desc("HAVING", Kind.Keyword, "HAVING keyword (MAQL)", "filtering-with-the-having-clause", undefined, " "),
+    desc("IF", Kind.Keyword, "IF keyword (MAQL)", "if-then-else", undefined, " "),
+    desc("ILIKE", Kind.Keyword, "ILIKE keyword (MAQL)", "filtering-with-the-like-clause", undefined, " "),
+    desc("LIKE", Kind.Keyword, "LIKE keyword (MAQL)", "filtering-with-the-like-clause", undefined, " "),
+    desc("METRIC", Kind.Keyword, "METRIC keyword (MAQL)", undefined, undefined, " "),
+    desc("NOT", Kind.Keyword, "NOT keyword (MAQL)", "not", undefined, " "),
+    desc("NULL", Kind.Keyword, "NULL keyword (MAQL)", undefined, undefined, " "),
+    desc("OR", Kind.Keyword, "OR logical operator (MAQL)", "or", undefined, " "),
+    desc("OTHER", Kind.Keyword, "OTHER keyword (MAQL)", undefined, undefined),
+    desc("ORDER BY", Kind.Keyword, "ORDER BY keyword (MAQL)", undefined, undefined, " "),
+    desc("PARENT FILTER", Kind.Keyword, "PARENT FILTER keyword (MAQL)", undefined, undefined, " "),
+    desc("PARENT", Kind.Keyword, "PARENT keyword (MAQL)", undefined, undefined, " "),
+    desc("PARSE", Kind.Keyword, "PARSE keyword (MAQL)", undefined, undefined, " "),
+    desc("PF", Kind.Keyword, "PF keyword (MAQL)", undefined, undefined, " "),
+    desc("PRECEDING", Kind.Keyword, "PRECEDING keyword (MAQL)", undefined, undefined, " "),
+    desc("ROW", Kind.Keyword, "ROW keyword (MAQL)", undefined, undefined, " "),
+    desc("ROWS", Kind.Keyword, "ROWS keyword (MAQL)", undefined, undefined, " "),
+    desc("SELECT", Kind.Keyword, "SELECT keyword (MAQL)", undefined, undefined, " "),
+    desc("THEN", Kind.Keyword, "THEN keyword (MAQL)", undefined, undefined, " "),
+    desc("UNBOUNDED", Kind.Keyword, "UNBOUNDED keyword (MAQL)", undefined, undefined, " "),
+    desc("USING", Kind.Keyword, "USING keyword (MAQL)", undefined, undefined, " "),
+    desc("WHEN", Kind.Keyword, "WHEN keyword (MAQL)", undefined, undefined, " "),
+    desc("WHERE", Kind.Keyword, "WHERE keyword (MAQL)", "filtering-with-the-where-clause", undefined, " "),
+    desc("WITH", Kind.Keyword, "WITH keyword (MAQL)", "with-parent-filter", undefined, " "),
+    desc("WITHOUT", Kind.Keyword, "WITHOUT keyword (MAQL)", "without-parent-filter", undefined, " "),
+    booleanDesc("FALSE"),
+    booleanDesc("TRUE"),
+    granularityDesc("SECOND", MaqlType.CHRONOLOGICAL_GRANULARITY),
+    granularityDesc("MINUTE", MaqlType.CHRONOLOGICAL_GRANULARITY),
+    granularityDesc("DAY", MaqlType.CHRONOLOGICAL_GRANULARITY),
+    granularityDesc("HOUR", MaqlType.CHRONOLOGICAL_GRANULARITY),
+    granularityDesc("WEEK", MaqlType.CHRONOLOGICAL_GRANULARITY),
+    granularityDesc("MONTH", MaqlType.CHRONOLOGICAL_GRANULARITY),
+    granularityDesc("QUARTER", MaqlType.CHRONOLOGICAL_GRANULARITY),
+    granularityDesc("YEAR", MaqlType.CHRONOLOGICAL_GRANULARITY),
+    granularityDesc("FISCALMONTH", MaqlType.CHRONOLOGICAL_GRANULARITY),
+    granularityDesc("FISCALQUARTER", MaqlType.CHRONOLOGICAL_GRANULARITY),
+    granularityDesc("FISCALYEAR", MaqlType.CHRONOLOGICAL_GRANULARITY),
+    granularityDesc("SECONDOFMINUTE", MaqlType.PERIODICAL_GRANULARITY),
+    granularityDesc("SECONDOFDAY", MaqlType.PERIODICAL_GRANULARITY),
+    granularityDesc("MINUTEOFHOUR", MaqlType.PERIODICAL_GRANULARITY),
+    granularityDesc("MINUTEOFDAY", MaqlType.PERIODICAL_GRANULARITY),
+    granularityDesc("HOUROFDAY", MaqlType.PERIODICAL_GRANULARITY),
+    granularityDesc("DAYOFWEEK", MaqlType.PERIODICAL_GRANULARITY),
+    granularityDesc("DAYOFMONTH", MaqlType.PERIODICAL_GRANULARITY),
+    granularityDesc("DAYOFQUARTER", MaqlType.PERIODICAL_GRANULARITY),
+    granularityDesc("DAYOFYEAR", MaqlType.PERIODICAL_GRANULARITY),
+    granularityDesc("WEEKOFYEAR", MaqlType.PERIODICAL_GRANULARITY),
+    granularityDesc("MONTHOFYEAR", MaqlType.PERIODICAL_GRANULARITY),
+    granularityDesc("QUARTEROFYEAR", MaqlType.PERIODICAL_GRANULARITY),
+    objectDesc("label", undefined, "LABEL object (MAQL)", undefined, MaqlParser.RULE_attribute, Kind.Label, MaqlType.STRING_AND_DATE),
+    objectDesc("computed_attribute", undefined, "COMPUTED_ATTRIBUTE object (MAQL)", undefined, MaqlParser.RULE_attribute, Kind.Attribute, MaqlType.STRING),
+    objectDesc("dataset", undefined, "DATASET object (MAQL)", undefined, MaqlParser.RULE_attribute, Kind.Dataset, MaqlType.DATASET),
+    objectDesc("fact", undefined, "FACT object (MAQL)", undefined, MaqlParser.RULE_numeric, Kind.Fact, MaqlType.NUMERIC),
+    objectDesc("metric", undefined, "METRIC object (MAQL)", undefined, MaqlParser.RULE_numeric, Kind.Metric),
+    objectDesc("parameter", undefined, "PARAMETER object (MAQL)", undefined, MaqlParser.RULE_parameter, Kind.Parameter, MaqlType.NUMERIC),
+    // This description does not have an appropriate trigger place, disable for now
+    // {
+    //     label: "BY attribute ALL OTHER",
+    //     kind: Kind.Snippet,
+    //     insertTextFormat: InsertTextFormat.Snippet,
+    //     insertText: "BY ${1:attribute} ALL OTHER $0",
+    //     detail: "BY attribute ALL OTHER clause (MAQL)",
+    //     resolveTag: "by-attribute-all-in-all-other-dimensions",
+    //     ruleId: MaqlParser.RULE_by,
+    // },
+    {
+        label: "WITHIN(DIMENSIONS)",
+        kind: Kind.Snippet,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: "WITHIN($1)$0",
+        sortText: "WITHIN",
+        detail: "WITHIN clause (MAQL)",
+        resolveTag: "within-clause",
+        triggerTokenId: getTokenIdFromName("WITHIN"),
+    },
+    {
+        label: "BOTTOM(NUMERIC) ... -> BOOLEAN",
+        kind: Kind.Function,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: "BOTTOM($1)$0",
+        sortText: "BOTTOM",
+        detail: "BOTTOM ranking filter (MAQL)",
+        resolveTag: "filtering-with-ranking-filters",
+        triggerTokenId: getTokenIdFromName("BOTTOM"),
+        maqlType: MaqlType.BOOLEAN,
+    },
+    {
+        label: "TOP(NUMERIC) ... -> BOOLEAN",
+        kind: Kind.Function,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: "TOP($1)$0",
+        sortText: "TOP",
+        detail: "TOP ranking filter (MAQL)",
+        resolveTag: "filtering-with-ranking-filters",
+        triggerTokenId: getTokenIdFromName("TOP"),
+        maqlType: MaqlType.BOOLEAN,
+    },
+    {
+        label: "IF ... THEN ... ELSE ... END",
+        kind: Kind.Snippet,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: "IF $1 THEN $2 ELSE $3 END",
+        sortText: "IF THEN ELSE",
+        detail: "IF THEN ELSE conditional statement (MAQL)",
+        resolveTag: "if-then-else",
+        triggerTokenId: getTokenIdFromName("IF"),
+    },
+    {
+        label: "IN (...)", // TODO: IN disambiguation (TOP IN, object IN (...))
+        kind: Kind.Keyword,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: "IN ($1)$0",
+        detail: "IN keyword (MAQL)",
+        resolveTag: "relational-operators",
+        triggerTokenId: getTokenIdFromName("IN"),
+    },
+    {
+        label: "OF (...)",
+        kind: Kind.Keyword,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: "OF ($1)$0",
+        detail: "OF keyword (MAQL)",
+        resolveTag: "where-top-or-bottom-of",
+        triggerTokenId: getTokenIdFromName("OF"),
+    },
+];
+function desc(label, kind, detail, resolveTag, insertPrefix, insertSuffix, ruleId, maqlType) {
+    return {
+        label,
+        kind,
+        insertText: (insertPrefix ?? "") + label + (insertSuffix ?? ""),
+        detail,
+        resolveTag,
+        triggerTokenId: getTokenIdFromName(label),
+        ruleId,
+        maqlType,
+    };
+}
+function booleanDesc(value) {
+    return {
+        label: value,
+        kind: Kind.Boolean,
+        insertText: value,
+        triggerTokenId: getTokenIdFromName(value),
+        maqlType: MaqlType.BOOLEAN,
+    };
+}
+function granularityDesc(name, type) {
+    return {
+        label: name,
+        kind: Kind.Granularity,
+        insertText: name,
+        detail: name + " time granularity (MAQL)",
+        triggerTokenId: getTokenIdFromName(name),
+        maqlType: type,
+    };
+}
+function objectDesc(type, id = undefined, detail = undefined, resolveTag = undefined, ruleId, kind, maqlType) {
+    const format = id ? InsertTextFormat.PlainText : InsertTextFormat.Snippet;
+    return {
+        label: `${type}/${id ?? "$identifier"}`,
+        kind,
+        insertText: `{${type}/${id ?? "${1:identifier}"}}`,
+        insertTextFormat: format,
+        filterText: `{ ${type} / }`,
+        sortText: `{${type}/}`,
+        detail,
+        resolveTag,
+        ruleId,
+        maqlType,
+    };
+}

package/esm/completions/findContext.d.ts

@@ -0,0 +1,19 @@
+import { type Token } from "antlr4ng";
+import { type AstNode, type IPosition } from "@gooddata/maql-antlr4ts";
+import { type MaqlMetric } from "../parseMaql.js";
+import { MaqlType } from "../types/hierarchy.js";
+export interface ICaretContext {
+    /** List of AST nodes whose range includes the caret. Starts from the deepest node */
+    nodeStack: AstNode[];
+    /** List of types that are expected to be present at the caret position */
+    expectedTypes: MaqlType[];
+    /** Final tokens surrounding the caret position */
+    tokens: {
+        caretToken: Token;
+        leftFinalToken: Token;
+        rightFinalToken: Token;
+    };
+}
+export declare function findContext(metric: MaqlMetric, caretPosition: IPosition, offset: number): ICaretContext;
+export declare function isFinal(token: Token): boolean;
+//# sourceMappingURL=findContext.d.ts.map

package/esm/completions/findContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findContext.d.ts","sourceRoot":"","sources":["../../src/completions/findContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,KAAK,EAAoB,MAAM,UAAU,CAAC;AAExD,OAAO,EAEH,KAAK,OAAO,EAEZ,KAAK,SAAS,EAIjB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAsB,MAAM,uBAAuB,CAAC;AAOrE,MAAM,WAAW,aAAa;IAC1B,qFAAqF;IACrF,SAAS,EAAE,OAAO,EAAE,CAAC;IACrB,0EAA0E;IAC1E,aAAa,EAAE,QAAQ,EAAE,CAAC;IAC1B,kDAAkD;IAClD,MAAM,EAAE;QAAE,UAAU,EAAE,KAAK,CAAC;QAAC,cAAc,EAAE,KAAK,CAAC;QAAC,eAAe,EAAE,KAAK,CAAA;KAAE,CAAC;CAChF;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,aAAa,CAiBvG;AAkKD,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAE7C"}

package/esm/completions/findContext.js

@@ -0,0 +1,171 @@
+// (C) 2022-2026 GoodData Corporation
+import { AbstractAstVisitor, MaqlParser, positionInRange, } from "@gooddata/maql-antlr4ts";
+import { MaqlType, abstractValueTypes } from "../types/hierarchy.js";
+import { findFunctionDefinitions, } from "../types/signatures.js";
+export function findContext(metric, caretPosition, offset) {
+    const finder = new AstContextFinder(caretPosition);
+    const [leftFinalToken, caretToken, rightFinalToken] = findCaretToken(metric.tokenStream, offset);
+    const context = finder.visit(metric.ast);
+    if (context.caretExpectedTypes.size === 0) {
+        // no information is inferred therefore allow everything
+        context.caretExpectedTypes.add(MaqlType.ANY);
+    }
+    return {
+        nodeStack: context.nodeStack,
+        expectedTypes: Array.from(context.caretExpectedTypes),
+        tokens: {
+            leftFinalToken,
+            caretToken,
+            rightFinalToken,
+        },
+    };
+}
+class AstContext {
+    nodeStack;
+    caretExpectedTypes;
+    /**
+     * @param nodeStack - List of AST nodes whose range includes the caret. Starts from the deepest node
+     * @param caretExpectedTypes - List of possible MAQL types expected at caret position
+     */
+    constructor(nodeStack = [], caretExpectedTypes = new Set()) {
+        this.nodeStack = nodeStack;
+        this.caretExpectedTypes = caretExpectedTypes;
+    }
+}
+class AstContextFinder extends AbstractAstVisitor {
+    caretPosition;
+    constructor(caretPosition) {
+        super();
+        this.caretPosition = caretPosition;
+    }
+    defaultResult() {
+        return new AstContext();
+    }
+    aggregateResult(aggregate, nextResult) {
+        return aggregate.nodeStack.length === 0 ? nextResult : aggregate;
+    }
+    mergeResultWithParent(parentNode, result) {
+        // Add `parentNode` to `result.nodeStack` if the caret position is in range
+        if (parentNode.contextRange && positionInRange(this.caretPosition, parentNode.contextRange)) {
+            result.nodeStack.push(parentNode);
+        }
+        return result;
+    }
+    visitFunctionNode(node) {
+        const args = node.content.map((child) => this.visit(child));
+        // find the index of argument with the caret position
+        const argIdx = args.findIndex((arg) => arg.nodeStack.length > 0);
+        const argContext = args[argIdx] ?? new AstContext();
+        if (this.isCaretContext(argContext)) {
+            return this.mergeResultWithParent(node, argContext);
+        }
+        const defs = findFunctionDefinitions(node.type, node.name);
+        // if no argument has the caret position, definitions exists, and the caret is still within the function range,
+        // assume that the user wants the next argument of the function
+        const range = node.contextRange;
+        const idx = argIdx === -1 && defs.length !== 0 && range && positionInRange(this.caretPosition, range)
+            ? args.length
+            : argIdx;
+        if (idx === -1) {
+            return this.mergeResultWithParent(node, argContext);
+        }
+        const allowedTypes = defs
+            .map((def) => {
+            return def.vararg ? Array(args.length).fill(def.parameters[0]) : def.parameters;
+        })
+            .map((paramTypes) => paramTypes[idx]?.type)
+            .filter((type) => type !== undefined);
+        return this.mergeResultWithParent(node, new AstContext(argContext.nodeStack, new Set(allowedTypes)));
+    }
+    visitOrderByElement(node) {
+        const elementCtx = this.visit(node.content[0]);
+        if (this.isCaretContext(elementCtx)) {
+            return this.mergeResultWithParent(node, elementCtx);
+        }
+        return this.mergeResultWithParent(node, new AstContext(elementCtx.nodeStack, new Set(abstractValueTypes)));
+    }
+    /**
+     * Check that the context is the one most relevant to the location of the caret
+     */
+    isCaretContext(ctx) {
+        // nodeStack > 1 means caret is in a deeper rule, expected types mean that the context is already restricted
+        return ctx.nodeStack.length > 1 || ctx.caretExpectedTypes.size > 0;
+    }
+}
+/**
+ * Function to find position of the caret for the purposes of completions.
+ * The caret position may be ambiguous in regard to the caret token.
+ * The caret token is the place at which position we want to place completions.
+ * We can imagine it as removing the token and everything after it
+ * Consider these two examples, '|' signifies caret position
+ * 1. parse metric SELECT SUM(|)
+ * 2. parse metric SELECT SUM(Price|)
+ * In both queries, we want to see suggestions as if the query was 'SELECT SUM('.
+ * In query 1, the caret token is on the RIGHT of the caret: ')'.
+ * In query 2, the caret token is on the LEFT of the caret: 'Price'
+ * This function resolves this by separating tokens into two categories - "final" (F) and "extensible" (X).
+ * Final tokens cannot change by appending characters to them. These are tokens like parentheses, commas, operators,
+ * completed strings and end-of-file. Extensible tokens are rewritable - these include all keywords, functions,
+ * unterminated strings and incomplete objects (missing '\}'). When the caret is at the boundary of two tokens, the caret
+ * token is decided as follows:
+ * F | F -\> RIGHT
+ * F | X -\> RIGHT
+ * X | F -\> LEFT
+ * X | X -\> LEFT
+ * After caret token is found, the function looks for the closest final tokens on the left and right to serve as
+ * boundaries for text edit range on completion.
+ * @returns [Token, Token, Token]
+ *          - leftFinalToken - last final token before or including caret token
+ *          - caretToken - the actual token where the caret is currently placed, to be passed into antlr4c3 completion core
+ *          - rightFinalToken - first final token after or including caret token
+ */
+function findCaretToken(tokenStream, offset) {
+    let caretToken = tokenStream.get(0), leftFinalToken, rightFinalToken;
+    // first find the caret token
+    for (let tokenIndex = 0; tokenIndex < tokenStream.size; tokenIndex++) {
+        const nextToken = tokenStream.get(tokenIndex);
+        if (nextToken.start < offset || (nextToken.start === offset && isFinal(caretToken))) {
+            caretToken = nextToken;
+        }
+        if (nextToken.start >= offset)
+            break;
+    }
+    for (let tokenIndex = caretToken.tokenIndex; tokenIndex < tokenStream.size; tokenIndex++) {
+        const nextToken = tokenStream.get(tokenIndex);
+        if (nextToken.type !== MaqlParser.RBRACE && isFinal(nextToken)) {
+            // rewriting RBRACE is allowed if approached from the left side
+            rightFinalToken = nextToken;
+            break;
+        }
+    }
+    for (let tokenIndex = caretToken.tokenIndex; tokenIndex > 0; tokenIndex--) {
+        const prevToken = tokenStream.get(tokenIndex);
+        if (isFinal(prevToken)) {
+            leftFinalToken = prevToken;
+            break;
+        }
+    }
+    return [leftFinalToken ?? caretToken, caretToken, rightFinalToken ?? caretToken];
+}
+const finalTokens = new Set([
+    MaqlParser.WS,
+    MaqlParser.EOF,
+    MaqlParser.String,
+    MaqlParser.ZERO,
+    MaqlParser.Natural,
+    MaqlParser.Real,
+    MaqlParser.PLUS,
+    MaqlParser.MINUS,
+    MaqlParser.MUL,
+    MaqlParser.DIV,
+    MaqlParser.PERCENT,
+    MaqlParser.RELOP,
+    MaqlParser.COMMA,
+    MaqlParser.SEMICOLON,
+    MaqlParser.LPAREN,
+    MaqlParser.RPAREN,
+    MaqlParser.RBRACE,
+]);
+export function isFinal(token) {
+    return finalTokens.has(token.type);
+}

package/esm/completions/functionDescriptions.d.ts

@@ -0,0 +1,3 @@
+import { type CompletionDescription } from "./descriptions.js";
+export declare const functionDescriptions: CompletionDescription[];
+//# sourceMappingURL=functionDescriptions.d.ts.map

package/esm/completions/functionDescriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionDescriptions.d.ts","sourceRoot":"","sources":["../../src/completions/functionDescriptions.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AA4E/D,eAAO,MAAM,oBAAoB,EAAE,qBAAqB,EAuBvD,CAAC"}

package/esm/completions/functionDescriptions.js

@@ -0,0 +1,98 @@
+// (C) 2022-2026 GoodData Corporation
+import { CompletionItemKind, InsertTextFormat } from "vscode-languageserver";
+import { MaqlParser, functionDefinitions, } from "@gooddata/maql-antlr4ts";
+import { getTokenIdFromName } from "../parseMaql.js";
+import { transformFunctionDefinition } from "../types/signatures.js";
+/**
+ * Tags for functions to resolve correct documentation
+ */
+const functionResolveTags = {
+    "time macro": {
+        THIS: "time-macros",
+        NEXT: "time-macros",
+        PREVIOUS: "time-macros",
+    },
+    function: {
+        ABS: "abs",
+        APPROXIMATE_COUNT: "approximate_count",
+        AVG: "avg",
+        CEIL: "ceiling",
+        CEILING: "ceiling",
+        CORREL: "correl",
+        COUNT: "count",
+        COVAR: "covariance-functions",
+        COVARP: "covariance-functions",
+        ROW_NUMBER: "rank-variations",
+        RANK: "rank-variations",
+        DENSE_RANK: "rank-variations",
+        PERCENT_RANK: "rank-variations",
+        CUME_DIST: "rank-variations",
+        EXP: "exp",
+        FIRST_VALUE: "first",
+        FLOOR: "floor",
+        // "FORECAST": "forecast", // not implemented
+        GREATEST: "greatest",
+        IFNULL: "ifnull",
+        LAST_VALUE: "last",
+        LEAST: "least",
+        LN: "ln",
+        LOG: "log",
+        MAX: "max",
+        MEDIAN: "median",
+        MIN: "min",
+        NEXT: "for-next",
+        NEXTPERIOD: "for-next-period",
+        PERCENTILE: "percentile",
+        POWER: "power",
+        PREVIOUS: "for-previous",
+        PREVIOUSPERIOD: "for-previous-period",
+        ROUND: "round",
+        RSQ: "least-squares-functions",
+        RUNAVG: "running-totals-for-core-functions",
+        RUNMAX: "running-totals-for-core-functions",
+        RUNMIN: "running-totals-for-core-functions",
+        RUNSUM: "running-totals-for-core-functions",
+        RUNSTDEV: "running-total-statistical-functions",
+        RUNSTDEVP: "running-total-statistical-functions",
+        RUNVAR: "running-total-statistical-functions",
+        RUNVARP: "running-total-statistical-functions",
+        SIGN: "sign",
+        SQRT: "sqrt",
+        STDEV: "standard-deviation-functions",
+        STDEVP: "standard-deviation-functions",
+        SUM: "sum",
+        TRUNC: "trunc",
+        VAR: "variance-functions",
+        VARP: "variance-functions",
+        DATETIME_ADD: "datetime-add",
+        DATETIME_DIFF: "datetime-diff",
+        INTERCEPT: undefined,
+        SLOPE: undefined,
+    },
+};
+export const functionDescriptions = Object.entries(functionDefinitions).flatMap(([astType, astDefs]) => {
+    return Object.entries(astDefs).flatMap(([name, defs]) => {
+        return defs.map((def) => {
+            const signature = transformFunctionDefinition(def, name);
+            const ruleId = astType === "time macro" ? MaqlParser.RULE_timeMacroName : undefined;
+            return {
+                label: signature.toString(),
+                kind: CompletionItemKind.Function,
+                insertText: name + snippetArgs(signature.parameters.length),
+                insertTextFormat: InsertTextFormat.Snippet,
+                sortText: name,
+                detail: `${name} function (MAQL)`,
+                resolveTag: functionResolveTags[astType][name],
+                ruleId,
+                triggerTokenId: ruleId ? undefined : getTokenIdFromName(name),
+                maqlType: signature.returns.type,
+            };
+        });
+    });
+});
+function snippetArgs(count) {
+    return labelArgs(Array.from(Array(count)).map((_v, idx) => `$${idx + 1}`), undefined, ")$0");
+}
+function labelArgs(args, prefix = "(", suffix = ")", separator = ", ") {
+    return prefix + args.join(separator) + suffix;
+}

package/esm/completions/sort.d.ts

@@ -0,0 +1,4 @@
+import { type CompletionList } from "vscode-languageserver";
+import { type ICaretContext } from "./findContext.js";
+export declare function adjustSortText(list: CompletionList, context: ICaretContext): CompletionList;
+//# sourceMappingURL=sort.d.ts.map

package/esm/completions/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../src/completions/sort.ts"],"names":[],"mappings":"AAEA,OAAO,EAA2B,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAKrF,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAgDtD,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,aAAa,kBAoD1E"}