@cloudcare/codemirror-dql 0.0.57 → 0.0.61

package/dist/cjs/parser/parser.js

@@ -75,6 +75,7 @@ var queryClauseLabels = new Map([
     ['TargetClause', 'projection'],
     ['FilterClause', 'WHERE'],
     ['TimeClause', 'time range'],
+    ['ShiftClause', 'SHIFT'],
     ['ByClause', 'BY'],
     ['HavingClause', 'HAVING'],
     ['OrderClause', 'ORDER BY'],
@@ -84,12 +85,150 @@ var queryClauseLabels = new Map([
     ['SLimitClause', 'SLIMIT'],
     ['SOffsetClause', 'SOFFSET'],
 ]);
-var expressionParents = new Set(['BinaryExpr', 'Expr', 'HavingExpr', 'ProjectionExpr']);
+var expressionParents = new Set(['BinaryExpr', 'Expr', 'HavingExpr', 'ProjectionExpr', 'CaseArithmeticExpr']);
 var commaContextBoundaries = new Set(['CaseExpr', 'Query']);
+var documentedFunctionArities = new Map(__spreadArray(__spreadArray([], __read([
+    'abs',
+    'any',
+    'avg',
+    'bool',
+    'ceil',
+    'count',
+    'count_distinct',
+    'count_series',
+    'deriv',
+    'derivative',
+    'difference',
+    'distinct',
+    'field_values',
+    'first',
+    'float',
+    'floor',
+    'histogram_auto',
+    'increase',
+    'int',
+    'irate',
+    'last',
+    'last_row',
+    'length',
+    'log',
+    'log2',
+    'log10',
+    'lower',
+    'ltrim',
+    'max',
+    'md5',
+    'median',
+    'min',
+    'mode',
+    'non_negative_derivative',
+    'non_negative_difference',
+    'rate',
+    'rate_over_count',
+    'rate_over_sum',
+    'rtrim',
+    'set',
+    'spread',
+    'stddev',
+    'string',
+    'sum',
+    'trim',
+    'uint',
+    'unwrap',
+    'upper',
+].map(function (name) { return [name, { min: 1, max: 1 }]; })), false), [
+    ['bottom', { min: 2, max: 2 }],
+    ['cidr', { min: 1, max: 2 }],
+    ['collect', { min: 1, max: 2 }],
+    ['collect_distinct', { min: 1, max: 2 }],
+    ['concat', { min: 1, max: Number.POSITIVE_INFINITY }],
+    ['count_filter', { min: 2, max: 2 }],
+    ['default', { min: 2, max: 2 }],
+    ['distinct_by_collapse', { min: 1, max: 2 }],
+    ['drain', { min: 2, max: 3 }],
+    ['exists', { min: 0, max: 0 }],
+    ['fill', { min: 2, max: 2 }],
+    ['histogram', { min: 4, max: 5 }],
+    ['histogram_quantile', { min: 2, max: 2 }],
+    ['match', { min: 1, max: 2 }],
+    ['now', { min: 0, max: 0 }],
+    ['query_string', { min: 1, max: 2 }],
+    ['querystring', { min: 1, max: 2 }],
+    ['re', { min: 1, max: 2 }],
+    ['regexp', { min: 1, max: 2 }],
+    ['regex', { min: 1, max: 2 }],
+    ['regexp_extract', { min: 2, max: 3 }],
+    ['regexp_extract_all', { min: 2, max: 3 }],
+    ['regexp_replace', { min: 3, max: 3 }],
+    ['round', { min: 1, max: 2 }],
+    ['search', { min: 1, max: 2 }],
+    ['substr', { min: 2, max: 3 }],
+    ['top', { min: 2, max: 2 }],
+    ['wildcard', { min: 1, max: 2 }],
+], false));
+var stableShiftAggregateFunctions = new Set([
+    'any',
+    'avg',
+    'change_score',
+    'collect',
+    'collect_distinct',
+    'corr',
+    'count',
+    'count_distinct',
+    'count_filter',
+    'count_series',
+    'deriv',
+    'derivative',
+    'difference',
+    'ewma',
+    'first',
+    'histogram_quantile',
+    'increase',
+    'irate',
+    'last',
+    'last_row',
+    'mad_score',
+    'max',
+    'median',
+    'min',
+    'mode',
+    'moving_average',
+    'non_negative_derivative',
+    'non_negative_difference',
+    'p50',
+    'p75',
+    'p90',
+    'p95',
+    'p99',
+    'percentile',
+    'rate',
+    'rate_over_count',
+    'rate_over_sum',
+    'slope',
+    'spread',
+    'stddev',
+    'sum',
+    'zscore',
+]);
+var unstableShiftAggregateFunctions = new Set([
+    'distinct',
+    'distinct_by_collapse',
+    'drain',
+    'field_values',
+    'histogram',
+    'histogram_auto',
+    'schema',
+]);
+var caseScalarFunctions = new Set(['int', 'float', 'string', 'md5', 'lower', 'upper', 'trim', 'ltrim', 'rtrim', 'regexp_replace', 'length']);
 exports.dqlSyntaxContexts = {
     DQL: 'DQL query',
     DQLConditions: 'DQL condition',
     QueryExpr: 'DQL query',
+    StudioQuery: 'STUDIOQL query',
+    StudioModule: 'STUDIOQL module',
+    StudioFunction: 'STUDIOQL function',
+    StudioCallBody: 'function arguments',
+    StudioArgument: 'named function argument',
     ShowExpr: 'SHOW expression',
     QueryFragment: 'query fragment',
     QueryFragmentClause: 'query fragment clause',
@@ -121,8 +260,15 @@ exports.dqlSyntaxContexts = {
     OuterArgItem: 'outer function argument',
     Queted: 'quoted query delimiter',
     EvalCallBody: 'eval function arguments',
+    EvalArgItem: 'eval expression argument',
+    EvalExpression: 'eval expression',
+    EvalAtom: 'eval expression value',
+    EvalFunctionCall: 'eval function call',
+    EvalFunctionCallBody: 'eval function arguments',
+    EvalFunctionArg: 'eval function argument',
     FunctionCallBody: 'function arguments',
     ArgItem: 'function argument',
+    EvalFieldReference: 'eval field reference',
     InValue: 'argument value list',
     SingleExpr: 'expression value',
     Expr: 'expression',
@@ -139,6 +285,8 @@ exports.dqlSyntaxContexts = {
     ProjectionFieldFragment: 'projection field fragment',
     ProjectionField: 'projection field',
     SingleFieldExpr: 'projection expression value',
+    ShiftExpr: 'SHIFT expression',
+    ShiftOperand: 'SHIFT operand',
     ProjectionExpr: 'projection expression',
     AsExpr: 'alias',
     FilterClause: 'filter clause',
@@ -152,10 +300,10 @@ exports.dqlSyntaxContexts = {
     CaseCondition: 'CASE condition',
     CaseFilterExpr: 'CASE filter expression',
     CasePredicate: 'CASE predicate',
+    CaseComparableValue: 'CASE comparison value',
     CaseValue: 'CASE value',
-    CaseFunctionCall: 'CASE function call',
-    CaseFunctionIdentifier: 'CASE function name',
-    CaseFunctionCallBody: 'CASE function arguments',
+    CaseArithmeticAtom: 'CASE arithmetic value',
+    CaseArithmeticExpr: 'CASE arithmetic expression',
     FilterFragmentExpr: 'filter fragment',
     ComparisonExpr: 'comparison expression',
     LogicalFragmentExpr: 'logical filter expression',
@@ -166,6 +314,7 @@ exports.dqlSyntaxContexts = {
     FilterExpr: 'filter expression',
     BinaryExpr: 'binary expression',
     TimeClause: 'time range clause',
+    ShiftClause: 'SHIFT clause',
     TimeRange: 'time range',
     TimeExpr: 'time range value',
     ByClause: 'BY clause',
@@ -184,7 +333,9 @@ exports.dqlSyntaxContexts = {
     NestedByMathExpr: 'nested grouping expression',
 };
 var functionCallBodyParents = new Set([
+    'StudioCallBody',
     'FunctionCallBody',
+    'EvalFunctionCallBody',
     'EvalCallBody',
     'OuterFunctionCallBody',
     'RawOuterFunctionCallBody',
@@ -193,7 +344,6 @@ var functionCallBodyParents = new Set([
     'FillOuterFunctionCallBody',
     'VariadicOuterFunctionCallBody',
     'RollupFunctionCallBody',
-    'CaseFunctionCallBody',
 ]);
 var Parser = /** @class */ (function () {
     function Parser(state, deadline) {
@@ -211,6 +361,7 @@ var Parser = /** @class */ (function () {
         this.quotedQueryDelimiterInfo = undefined;
         this.caseResultDiagnostics = undefined;
         this.caseResultRecoveryErrors = new Set();
+        this.caseShiftPresence = new Map();
     }
     Parser.prototype.getDiagnostics = function () {
         var seen = new Set();
@@ -599,7 +750,7 @@ var Parser = /** @class */ (function () {
         this.appendDiagnostics(diagnostics);
     };
     Parser.prototype.describeError = function (node) {
-        var _a;
+        var _a, _b, _c;
         var delimiterIssue = this.getDelimiterIssue();
         if (delimiterIssue && delimiterIssue.kind !== 'unclosed' && this.isRelatedDelimiterError(node, delimiterIssue)) {
             return null;
@@ -681,6 +832,26 @@ var Parser = /** @class */ (function () {
             }
             return this.makeDiagnostic(node, 'expected "AS" before projection alias', group);
         }
+        var projectionField = (_a = this.findAncestor(parent, 'ProjectionField')) !== null && _a !== void 0 ? _a : this.findAncestor(parent, 'ProjectionFieldFragment');
+        if (projectionField) {
+            var shiftError = this.errorDescendantsWithText(projectionField, 'shift').find(function (error) { return error.from <= node.from; });
+            if (shiftError && this.containsNode(projectionField, 'ShiftExpr')) {
+                return this.makeDiagnosticAt(shiftError.from, shiftError.to, 'SHIFT expressions cannot be nested', "shift-nested-syntax:".concat(projectionField.from));
+            }
+            if (shiftError) {
+                var rawOperand = this.state.sliceDoc(projectionField.from, shiftError.from);
+                var leading = rawOperand.length - rawOperand.trimStart().length;
+                var trailing = rawOperand.length - rawOperand.trimEnd().length;
+                return this.makeDiagnosticAt(projectionField.from + leading, Math.max(projectionField.from + leading + 1, projectionField.from + rawOperand.length - trailing), 'SHIFT operand must be a stable aggregate or subquery measure', "shift-operand-syntax:".concat(projectionField.from));
+            }
+        }
+        var invalidShiftContext = (_b = this.findAncestor(parent, 'FilterClause')) !== null && _b !== void 0 ? _b : this.findAncestor(parent, 'HavingClause');
+        if (invalidShiftContext) {
+            var shiftError = this.errorDescendantsWithText(invalidShiftContext, 'shift').find(function (error) { return error.from <= node.from; });
+            if (shiftError) {
+                return this.makeDiagnosticAt(shiftError.from, shiftError.to, 'expression-level SHIFT is only allowed in the projection', "shift-context-syntax:".concat(invalidShiftContext.from));
+            }
+        }
         if (parentName === 'OuterFunctionCall') {
             return this.makeUnexpectedTokenDiagnostic(node, exports.dqlSyntaxContexts.OuterFunctionCall, group);
         }
@@ -705,7 +876,7 @@ var Parser = /** @class */ (function () {
             }
             return this.makeUnexpectedTokenDiagnostic(node, 'function call', group);
         }
-        if (parentName === 'ArgItem' && node.from === node.to) {
+        if ((parentName === 'ArgItem' || parentName === 'EvalFunctionArg') && node.from === node.to) {
             if ((previous === null || previous === void 0 ? void 0 : previous.name) === 'EqlSingle') {
                 return this.makeDiagnostic(node, 'function argument value expected after "="', group);
             }
@@ -751,20 +922,52 @@ var Parser = /** @class */ (function () {
         if (parentName === 'ByExpr' && errorText === ',') {
             return this.makeDiagnostic(node, 'grouping field expected before ","', group);
         }
-        if (expressionParents.has(parentName)) {
-            if (previous && this.isOperator(previous)) {
-                return this.makeDiagnostic(node, "right-hand expression expected after \"".concat(previousText, "\""), group);
-            }
-            return this.makeUnexpectedTokenDiagnostic(node, 'expression', group);
-        }
         var caseWhenClause = this.findAncestor(parent, 'CaseWhenClause');
         if (caseWhenClause) {
+            var firstCaseError = this.firstErrorFrom(caseWhenClause);
             var missingCondition = /^\s*when\s+(then)\b/i.exec(this.maskLineComments(this.nodeText(caseWhenClause)));
             if (missingCondition) {
-                var thenOffset = missingCondition.index + missingCondition[0].toLowerCase().lastIndexOf('then');
-                return this.makeDiagnosticAt(caseWhenClause.from + thenOffset, caseWhenClause.from + thenOffset + 4, 'CASE condition expected after "WHEN"', this.caseGroup(caseWhenClause));
+                if (node.from === firstCaseError) {
+                    var thenOffset = missingCondition.index + missingCondition[0].toLowerCase().lastIndexOf('then');
+                    return this.makeDiagnosticAt(caseWhenClause.from + thenOffset, caseWhenClause.from + thenOffset + 4, 'CASE condition expected after "WHEN"', this.caseGroup(caseWhenClause));
+                }
+                return null;
+            }
+            if (!caseWhenClause.getChild('Then')) {
+                if (node.from === firstCaseError) {
+                    return this.makeDiagnostic(node, 'expected "THEN" after CASE condition', this.caseGroup(caseWhenClause));
+                }
+                return null;
+            }
+            var missingResult = /\bthen\s+(else)\b/i.exec(this.maskLineComments(this.nodeText(caseWhenClause)));
+            if (missingResult) {
+                if (node.from === firstCaseError) {
+                    var keyword = missingResult[1];
+                    var keywordOffset = missingResult.index + missingResult[0].toLowerCase().lastIndexOf(keyword.toLowerCase());
+                    return this.makeDiagnosticAt(caseWhenClause.from + keywordOffset, caseWhenClause.from + keywordOffset + keyword.length, 'CASE result expected after "THEN"', this.caseGroup(caseWhenClause));
+                }
+                return errorText ? this.makeUnexpectedTokenDiagnostic(node, exports.dqlSyntaxContexts.CaseExpr, group) : null;
             }
         }
+        if (parentName === 'EvalAtom' && errorText === '=' && (previous === null || previous === void 0 ? void 0 : previous.name) === 'Identifier') {
+            return this.makeDiagnostic(node, 'function argument value expected after "="', group);
+        }
+        if (parentName === 'EvalExpression' && node.from === node.to && (previous === null || previous === void 0 ? void 0 : previous.name) === 'EvalAtom' && (next === null || next === void 0 ? void 0 : next.name) === 'EvalAtom') {
+            return this.makeDiagnostic(node, 'expected "," between function arguments', group);
+        }
+        if (parentName === 'CaseArithmeticExpr' && errorText && !(previous === null || previous === void 0 ? void 0 : previous.type.isError)) {
+            return this.makeUnexpectedTokenDiagnostic(node, exports.dqlSyntaxContexts.CaseExpr, group);
+        }
+        if (parentName === 'ShiftExpr' || parentName === 'ShiftClause') {
+            var message = errorText ? 'SHIFT duration must be a positive fixed duration' : 'duration expected after "SHIFT"';
+            return this.makeDiagnostic(node, message, "shift-duration:".concat(parent.from));
+        }
+        if (expressionParents.has(parentName)) {
+            if (previous && this.isOperator(previous)) {
+                return this.makeDiagnostic(node, "right-hand expression expected after \"".concat(previousText, "\""), group);
+            }
+            return this.makeUnexpectedTokenDiagnostic(node, 'expression', group);
+        }
         if (parentName === 'CaseCondition') {
             return this.makeDiagnostic(node, 'expected "THEN" after CASE condition', this.caseGroup(parent));
         }
@@ -812,7 +1015,7 @@ var Parser = /** @class */ (function () {
         }
         if (parentName === 'RollupIdentifier') {
             var timeClause_1 = this.findAncestor(parent, 'TimeClause');
-            var child = (_a = timeClause_1 === null || timeClause_1 === void 0 ? void 0 : timeClause_1.firstChild) !== null && _a !== void 0 ? _a : null;
+            var child = (_c = timeClause_1 === null || timeClause_1 === void 0 ? void 0 : timeClause_1.firstChild) !== null && _c !== void 0 ? _c : null;
             while (child) {
                 if (child.type.isError)
                     return null;
@@ -1381,7 +1584,9 @@ var Parser = /** @class */ (function () {
     Parser.prototype.describeConsecutiveCommaError = function (node, parent) {
         var contexts = {
             Projection: 'projection item',
+            StudioCallBody: 'function argument',
             FunctionCallBody: 'function argument',
+            EvalFunctionCallBody: 'function argument',
             EvalCallBody: 'function argument',
             OuterFunctionCallBody: 'function argument',
             RawOuterFunctionCallBody: 'function argument',
@@ -1390,7 +1595,6 @@ var Parser = /** @class */ (function () {
             FillOuterFunctionCallBody: 'function argument',
             VariadicOuterFunctionCallBody: 'function argument',
             RollupFunctionCallBody: 'function argument',
-            CaseFunctionCallBody: 'function argument',
             InValue: 'argument value',
             InFieldValue: 'filter value',
             IndexExpr: 'namespace index',
@@ -1575,6 +1779,20 @@ var Parser = /** @class */ (function () {
         }
         return false;
     };
+    Parser.prototype.firstErrorFrom = function (node) {
+        var first = null;
+        var visit = function (current) {
+            var child = current.firstChild;
+            while (child) {
+                if (child.type.isError && (first === null || child.from < first))
+                    first = child.from;
+                visit(child);
+                child = child.nextSibling;
+            }
+        };
+        visit(node);
+        return first;
+    };
     Parser.prototype.looksLikeProjectionAfterMissingColon = function (node) {
         var querySource = node.getChild('QuerySource');
         return Boolean(querySource && this.containsError(querySource) && !this.containsNode(querySource, 'DColon'));
@@ -2648,6 +2866,8 @@ var Parser = /** @class */ (function () {
                 case 'Query':
                 case 'QueryFragment':
                     this.checkDuplicateQueryClauses(node);
+                    this.checkQueryShiftPlacement(node);
+                    this.checkExpressionShiftOffsets(node);
                     break;
                 case 'ShowExpr':
                     this.checkDuplicateShowClauses(node);
@@ -2656,6 +2876,19 @@ var Parser = /** @class */ (function () {
                 case 'TimeRange':
                     this.checkTimeRangeShape(node);
                     break;
+                case 'ShiftClause':
+                    this.checkShiftDuration(node);
+                    break;
+                case 'ShiftExpr':
+                    this.checkShiftDuration(node);
+                    this.checkShiftExpression(node);
+                    break;
+                case 'EvalExpr':
+                    this.checkEvalReferences(node);
+                    break;
+                case 'EvalFieldReference':
+                    this.checkEvalFieldReferenceContext(node);
+                    break;
                 case 'RollupIdentifier':
                     this.checkBareRollup(node);
                     break;
@@ -2663,7 +2896,10 @@ var Parser = /** @class */ (function () {
                     this.checkRollupFunctionCall(node);
                     break;
                 case 'FunctionCall':
+                case 'EvalFunctionCall':
                     this.checkFunctionCall(node);
+                    if (node.name === 'FunctionCall')
+                        this.checkCaseFunction(node);
                     break;
                 case 'OuterFunctionCall':
                     this.checkOuterFunctionCall(node);
@@ -2683,9 +2919,6 @@ var Parser = /** @class */ (function () {
                 case 'FieldName':
                     this.checkFieldName(node);
                     break;
-                case 'CaseFunctionIdentifier':
-                    this.checkCaseFunction(node);
-                    break;
                 case 'CaseExpr':
                     this.checkCaseResults(node);
                     break;
@@ -2718,6 +2951,203 @@ var Parser = /** @class */ (function () {
             child = child.nextSibling;
         }
     };
+    Parser.prototype.checkQueryShiftPlacement = function (query) {
+        var _a;
+        var clauses = [];
+        var child = query.firstChild;
+        while (child) {
+            if (child.name === 'QueryClause' || child.name === 'QueryFragmentClause') {
+                var clause = child.firstChild;
+                if (clause)
+                    clauses.push(clause);
+            }
+            child = child.nextSibling;
+        }
+        var shifts = clauses.filter(function (clause) { return clause.name === 'ShiftClause'; });
+        var timeRanges = clauses.filter(function (clause) { return clause.name === 'TimeClause'; });
+        if (shifts.length !== 1 || timeRanges.length > 1)
+            return;
+        var shift = shifts[0];
+        var shiftIndex = clauses.indexOf(shift);
+        var laterTarget = clauses.slice(shiftIndex + 1).find(function (clause) { return clause.name === 'TargetClause'; });
+        if (laterTarget) {
+            this.pushSemanticDiagnostic(shift, '"SHIFT" must appear after the projection', "shift-placement:".concat(shift.from));
+            return;
+        }
+        var laterFilter = clauses.slice(shiftIndex + 1).find(function (clause) { return clause.name === 'FilterClause'; });
+        if (laterFilter) {
+            this.pushSemanticDiagnostic(shift, '"SHIFT" must appear after "WHERE"', "shift-placement:".concat(shift.from));
+            return;
+        }
+        if (timeRanges.length === 1) {
+            var timeIndex = clauses.indexOf(timeRanges[0]);
+            if (shiftIndex !== timeIndex + 1) {
+                this.pushSemanticDiagnostic(shift, '"SHIFT" must immediately follow the time range', "shift-placement:".concat(shift.from));
+            }
+            return;
+        }
+        var outputClause = clauses
+            .slice(0, shiftIndex)
+            .reverse()
+            .find(function (clause) {
+            return ['ByClause', 'HavingClause', 'OrderClause', 'SOrderClause', 'LimitClause', 'OffsetClause', 'SLimitClause', 'SOffsetClause'].includes(clause.name);
+        });
+        if (outputClause) {
+            var label = (_a = queryClauseLabels.get(outputClause.name)) !== null && _a !== void 0 ? _a : outputClause.name;
+            this.pushSemanticDiagnostic(shift, "\"SHIFT\" must appear before \"".concat(label, "\""), "shift-placement:".concat(shift.from));
+        }
+    };
+    Parser.prototype.checkExpressionShiftOffsets = function (query) {
+        var _this = this;
+        var offsets = new Set();
+        var overflowReported = false;
+        var visit = function (node) {
+            if (overflowReported || Date.now() >= _this.deadline)
+                return;
+            if (node !== query && node.name === 'Query')
+                return;
+            if (node.name === 'ShiftExpr') {
+                var duration = node.getChild('Duration');
+                if (duration) {
+                    var rawOffset = _this.nodeText(duration).toLowerCase();
+                    var milliseconds = _this.fixedDurationMilliseconds(rawOffset);
+                    var offset = milliseconds !== null && Number.isSafeInteger(milliseconds) ? "".concat(milliseconds, "ms") : rawOffset;
+                    if (!offsets.has(offset)) {
+                        offsets.add(offset);
+                        if (offsets.size > 16) {
+                            _this.pushSemanticDiagnostic(duration, 'a SELECT can use at most 16 distinct SHIFT offsets', "shift-offsets:".concat(query.from));
+                            overflowReported = true;
+                            return;
+                        }
+                    }
+                }
+            }
+            var child = node.firstChild;
+            while (child) {
+                visit(child);
+                child = child.nextSibling;
+            }
+        };
+        visit(query);
+    };
+    Parser.prototype.checkShiftDuration = function (shift) {
+        var duration = shift.getChild('Duration');
+        if (!duration || this.isPositiveFixedDuration(this.nodeText(duration)))
+            return;
+        this.pushSemanticDiagnostic(duration, 'SHIFT duration must be a positive fixed duration', "shift-duration:".concat(shift.from));
+    };
+    Parser.prototype.checkShiftExpression = function (shift) {
+        var _this = this;
+        var _a, _b;
+        var nested = this.findAncestor(shift.parent, 'ShiftExpr');
+        if (nested) {
+            this.pushSemanticDiagnostic(shift, 'SHIFT expressions cannot be nested', "shift-nested:".concat(shift.from));
+            return;
+        }
+        if (!this.findAncestor(shift.parent, 'TargetClause') && !this.findAncestor(shift.parent, 'ProjectionFragment')) {
+            this.pushSemanticDiagnostic(shift, 'expression-level SHIFT is only allowed in the projection', "shift-context:".concat(shift.from));
+            return;
+        }
+        var operand = shift.getChild('ShiftOperand');
+        if (!operand)
+            return;
+        var calls = this.shiftOperandFunctionCalls(operand);
+        var unstable = calls.find(function (call) {
+            var name = _this.functionCallName(call);
+            return name !== null && unstableShiftAggregateFunctions.has(name);
+        });
+        if (unstable) {
+            var name_1 = (_a = this.functionCallName(unstable)) !== null && _a !== void 0 ? _a : 'function';
+            var identifier = (_b = unstable.getChild('FunctionIdentifier')) !== null && _b !== void 0 ? _b : unstable;
+            this.pushSemanticDiagnostic(identifier, "function \"".concat(name_1, "\" cannot be used as a SHIFT operand"), "shift-operand:".concat(shift.from));
+            return;
+        }
+        var hasStableAggregate = calls.some(function (call) {
+            var name = _this.functionCallName(call);
+            return name !== null && stableShiftAggregateFunctions.has(name);
+        });
+        if (!hasStableAggregate) {
+            this.pushSemanticDiagnostic(operand, 'SHIFT operand must be a stable aggregate or subquery measure', "shift-operand:".concat(shift.from));
+        }
+    };
+    Parser.prototype.checkEvalFieldReferenceContext = function (reference) {
+        if (this.findAncestor(reference.parent, 'EvalExpr'))
+            return;
+        this.pushSemanticDiagnostic(reference, 'qualified field references are only supported inside eval', "eval-field-context:".concat(reference.from));
+    };
+    Parser.prototype.checkEvalReferences = function (evalExpr) {
+        var e_24, _a, e_25, _b, e_26, _c;
+        var body = evalExpr.getChild('EvalCallBody');
+        if (!body)
+            return;
+        var aliases = new Set();
+        try {
+            for (var _d = __values(this.directChildren(body, 'OuterArgItem')), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var argument = _e.value;
+                var identifier = argument.getChild('Identifier');
+                if (!identifier || !argument.getChild('EqlSingle'))
+                    continue;
+                if (!argument.getChild('Query') && !argument.getChild('OuterFunctionCall'))
+                    continue;
+                var name_2 = this.nodeText(identifier).toLowerCase();
+                if (aliases.has(name_2)) {
+                    this.pushSemanticDiagnostic(identifier, "duplicate eval subquery \"".concat(name_2, "\""), "eval-alias-duplicate:".concat(identifier.from));
+                    continue;
+                }
+                aliases.add(name_2);
+            }
+        }
+        catch (e_24_1) { e_24 = { error: e_24_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_24) throw e_24.error; }
+        }
+        var expression = body.getChild('EvalArgItem');
+        if (!expression)
+            return;
+        try {
+            for (var _f = __values(this.descendantsNamed(expression, 'EvalFieldReference')), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var reference = _g.value;
+                var alias = reference.getChild('Identifier');
+                if (!alias)
+                    continue;
+                var name_3 = this.nodeText(alias).toLowerCase();
+                if (!aliases.has(name_3)) {
+                    this.pushSemanticDiagnostic(alias, "unknown eval subquery \"".concat(name_3, "\" in field reference"), "eval-field:".concat(reference.from));
+                }
+            }
+        }
+        catch (e_25_1) { e_25 = { error: e_25_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+            }
+            finally { if (e_25) throw e_25.error; }
+        }
+        if (aliases.size > 1) {
+            try {
+                for (var _h = __values(this.descendantsNamed(expression, 'EvalAtom')), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    var atom = _j.value;
+                    var identifier = atom.getChild('Identifier');
+                    if (!identifier)
+                        continue;
+                    var name_4 = this.nodeText(identifier).toLowerCase();
+                    if (!aliases.has(name_4)) {
+                        this.pushSemanticDiagnostic(identifier, "unknown eval subquery \"".concat(name_4, "\" in expression"), "eval-alias:".concat(identifier.from));
+                    }
+                }
+            }
+            catch (e_26_1) { e_26 = { error: e_26_1 }; }
+            finally {
+                try {
+                    if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                }
+                finally { if (e_26) throw e_26.error; }
+            }
+        }
+    };
     Parser.prototype.checkDuplicateShowClauses = function (show) {
         var seen = new Set();
         var child = show.firstChild;
@@ -2839,12 +3269,44 @@ var Parser = /** @class */ (function () {
         }
     };
     Parser.prototype.checkFunctionCall = function (call) {
+        var _a;
         var identifier = call.getChild('FunctionIdentifier');
-        var body = call.getChild('FunctionCallBody');
+        var body = (_a = call.getChild('FunctionCallBody')) !== null && _a !== void 0 ? _a : call.getChild('EvalFunctionCallBody');
         if (!identifier || !body)
             return;
         var name = this.nodeText(identifier).toLowerCase();
-        var args = this.directChildren(body, 'ArgItem');
+        var argumentName = body.name === 'EvalFunctionCallBody' ? 'EvalFunctionArg' : 'ArgItem';
+        var args = this.directChildren(body, argumentName);
+        var arity = documentedFunctionArities.get(name);
+        if (arity && (args.length < arity.min || args.length > arity.max)) {
+            this.pushSemanticDiagnostic(body, this.functionArityMessage(name, arity), "function-arity:".concat(call.from));
+            return;
+        }
+        if ((name === 'count_filter' || name === 'distinct_by_collapse') && args.length === 2 && !args[1].getChild('InValue')) {
+            this.pushSemanticDiagnostic(args[1], "function \"".concat(name, "\" expects a value list as its second argument"), "function:".concat(call.from));
+            return;
+        }
+        if (name === 'histogram_quantile' && args.length === 2) {
+            var quantile = this.numericValue(args[1]);
+            if (quantile === null || quantile < 0 || quantile > 1) {
+                this.pushSemanticDiagnostic(args[1], 'function "histogram_quantile" expects a quantile in range [0, 1]', "function:".concat(call.from));
+                return;
+            }
+        }
+        if (name === 'drain' && args.length >= 2) {
+            var threshold = this.numericValue(args[1]);
+            if (threshold === null || threshold <= 0 || threshold > 1) {
+                this.pushSemanticDiagnostic(args[1], 'function "drain" expects a similarity threshold in range (0, 1]', "function:".concat(call.from));
+                return;
+            }
+            if (args.length === 3) {
+                var maxClusters = this.numericValue(args[2]);
+                if (maxClusters === null || !Number.isInteger(maxClusters) || maxClusters < 1 || maxClusters > 10000) {
+                    this.pushSemanticDiagnostic(args[2], 'function "drain" expects max_clusters to be an integer in range [1, 10000]', "function:".concat(call.from));
+                    return;
+                }
+            }
+        }
         if (name === 'ewma') {
             var alpha = args.length === 2 ? this.numericValue(args[1]) : null;
             if (alpha === null || alpha <= 0 || alpha > 1) {
@@ -2873,6 +3335,17 @@ var Parser = /** @class */ (function () {
             this.pushSemanticDiagnostic(body, "function \"".concat(name, "\" expects exactly one input field"), "function:".concat(call.from));
         }
     };
+    Parser.prototype.functionArityMessage = function (name, arity) {
+        if (arity.min === arity.max) {
+            if (arity.min === 0)
+                return "function \"".concat(name, "\" does not accept arguments");
+            return "function \"".concat(name, "\" expects exactly ").concat(arity.min, " ").concat(arity.min === 1 ? 'argument' : 'arguments');
+        }
+        if (!Number.isFinite(arity.max)) {
+            return "function \"".concat(name, "\" expects at least ").concat(arity.min, " ").concat(arity.min === 1 ? 'argument' : 'arguments');
+        }
+        return "function \"".concat(name, "\" expects between ").concat(arity.min, " and ").concat(arity.max, " arguments");
+    };
     Parser.prototype.checkOuterFunctionCall = function (call) {
         var identifier = call.firstChild;
         if (!identifier || identifier.name === 'FunctionIdentifier')
@@ -2971,11 +3444,36 @@ var Parser = /** @class */ (function () {
             this.pushSemanticDiagnostic(field, 'field names containing "-" must be enclosed in backticks', "field-name:".concat(field.from));
         }
     };
-    Parser.prototype.checkCaseFunction = function (identifier) {
+    Parser.prototype.checkCaseFunction = function (call) {
+        var caseExpr = this.findAncestor(call.parent, 'CaseExpr');
+        if (!caseExpr)
+            return;
+        var shiftExpr = this.findAncestor(call.parent, 'ShiftExpr');
+        if (shiftExpr && shiftExpr.from >= caseExpr.from && shiftExpr.to <= caseExpr.to)
+            return;
+        var identifier = call.getChild('FunctionIdentifier');
+        var body = call.getChild('FunctionCallBody');
+        if (!identifier || !body)
+            return;
         var name = this.nodeText(identifier).toLowerCase();
-        if (name === 'uint' || name === 'bool' || name === 'substr') {
-            this.pushSemanticDiagnostic(identifier, "function \"".concat(name, "\" is not supported inside CASE"), "case-function:".concat(identifier.from));
-        }
+        var args = this.directChildren(body, 'ArgItem');
+        var arity = documentedFunctionArities.get(name);
+        if (arity && (args.length < arity.min || args.length > arity.max))
+            return;
+        if (caseScalarFunctions.has(name))
+            return;
+        if (stableShiftAggregateFunctions.has(name) && this.caseContainsShift(caseExpr))
+            return;
+        this.pushSemanticDiagnostic(identifier, "function \"".concat(name, "\" is not supported inside CASE"), "case-function:".concat(identifier.from));
+    };
+    Parser.prototype.caseContainsShift = function (caseExpr) {
+        var key = this.nodeRangeKey(caseExpr);
+        var cached = this.caseShiftPresence.get(key);
+        if (cached !== undefined)
+            return cached;
+        var containsShift = this.containsNode(caseExpr, 'ShiftExpr');
+        this.caseShiftPresence.set(key, containsShift);
+        return containsShift;
     };
     Parser.prototype.checkCaseResults = function (caseExpr) {
         var clause = caseExpr.firstChild;
@@ -3002,6 +3500,10 @@ var Parser = /** @class */ (function () {
         var hasFrom = /\bfrom\s*=/.test(bodyText.toLowerCase());
         var filter = show.getChild('FilterClause');
         var hasSourceFilter = Boolean(filter && /@__source__/.test(this.maskStringsAndLineComments(this.nodeText(filter))));
+        if (/^show_[a-z0-9]+_index$/.test(name)) {
+            this.pushSemanticDiagnostic(identifier, "\"".concat(name, "\" is not supported by the DQL parser"), "show:".concat(show.from, ":unsupported"));
+            return;
+        }
         if ((name === 'show_tag_value' || name === 'show_tag_value_cardinality' || name === 'show_series_count_by_tag_value') && !hasKeyin) {
             this.pushSemanticDiagnostic(identifier, "\"".concat(name, "\" requires the named argument \"keyin\""), "show:".concat(show.from, ":keyin"));
         }
@@ -3028,13 +3530,106 @@ var Parser = /** @class */ (function () {
         }
         return children;
     };
+    Parser.prototype.descendantsNamed = function (node, name) {
+        var descendants = [];
+        var visit = function (current) {
+            var child = current.firstChild;
+            while (child) {
+                if (child.name === name)
+                    descendants.push(child);
+                visit(child);
+                child = child.nextSibling;
+            }
+        };
+        visit(node);
+        return descendants;
+    };
+    Parser.prototype.shiftOperandFunctionCalls = function (operand) {
+        var querySource = operand.getChild('QuerySource');
+        if (!querySource)
+            return this.descendantsNamed(operand, 'FunctionCall');
+        var query = querySource.getChild('Query');
+        if (!query)
+            return [];
+        var calls = [];
+        var clause = query.firstChild;
+        while (clause) {
+            if (clause.name === 'QueryClause') {
+                var target = clause.getChild('TargetClause');
+                if (target)
+                    calls.push.apply(calls, __spreadArray([], __read(this.descendantsNamed(target, 'FunctionCall')), false));
+            }
+            clause = clause.nextSibling;
+        }
+        return calls;
+    };
+    Parser.prototype.errorDescendantsWithText = function (node, text) {
+        var _this = this;
+        var errors = [];
+        var expected = text.toLowerCase();
+        var visit = function (current) {
+            var child = current.firstChild;
+            while (child) {
+                if (child.type.isError && _this.nodeText(child).toLowerCase() === expected)
+                    errors.push(child);
+                visit(child);
+                child = child.nextSibling;
+            }
+        };
+        visit(node);
+        return errors;
+    };
+    Parser.prototype.functionCallName = function (call) {
+        var identifier = call.getChild('FunctionIdentifier');
+        return identifier ? this.nodeText(identifier).toLowerCase() : null;
+    };
+    Parser.prototype.isPositiveFixedDuration = function (text) {
+        var milliseconds = this.fixedDurationMilliseconds(text);
+        return milliseconds !== null && milliseconds > 0;
+    };
+    Parser.prototype.fixedDurationMilliseconds = function (text) {
+        var multipliers = {
+            y: 365 * 24 * 60 * 60 * 1000,
+            w: 7 * 24 * 60 * 60 * 1000,
+            d: 24 * 60 * 60 * 1000,
+            h: 60 * 60 * 1000,
+            m: 60 * 1000,
+            s: 1000,
+            ms: 1,
+        };
+        var normalized = text.toLowerCase();
+        var pattern = /(\d+)(ms|[ywdhms])/g;
+        var total = 0;
+        var consumed = 0;
+        var part = pattern.exec(normalized);
+        while (part) {
+            if (part.index !== consumed)
+                return null;
+            var amount = Number(part[1]);
+            var component = amount * multipliers[part[2]];
+            if (!Number.isSafeInteger(amount) || !Number.isSafeInteger(component) || !Number.isSafeInteger(total + component))
+                return null;
+            total += component;
+            consumed = pattern.lastIndex;
+            part = pattern.exec(normalized);
+        }
+        return consumed === normalized.length ? total : null;
+    };
     Parser.prototype.numericValue = function (node) {
         if (!node)
             return null;
-        var number = node.name === 'Number' ? node : node.getChild('Number');
+        var valueNode = node;
+        if (node.name === 'EvalFunctionArg') {
+            var expression = node.getChild('EvalExpression');
+            var atom = expression === null || expression === void 0 ? void 0 : expression.firstChild;
+            if (!expression || (atom === null || atom === void 0 ? void 0 : atom.name) !== 'EvalAtom' || atom.nextSibling)
+                return null;
+            valueNode = atom;
+        }
+        var number = valueNode.name === 'Number' ? valueNode : valueNode.getChild('Number');
         if (!number)
             return null;
-        var sign = node.name !== 'Number' && node.getChild('Sub') ? -1 : 1;
+        var sign = valueNode.name !== 'Number' && valueNode.getChild('Sub') ? -1 : 1;
         var value = sign * Number(this.nodeText(number).replace(/_/g, ''));
         return Number.isFinite(value) ? value : null;
     };
@@ -3083,10 +3678,10 @@ var Parser = /** @class */ (function () {
         var functionPattern = /\b([A-Za-z_][A-Za-z0-9_-]*)\s*\(/g;
         var match = functionPattern.exec(text);
         while (match) {
-            var name_1 = match[1];
+            var name_5 = match[1];
             var nameFrom = context.from + match.index;
             if (!this.containsFunctionCallStartingAt(context, nameFrom)) {
-                return this.makeDiagnosticAt(nameFrom, nameFrom + name_1.length, "unknown function \"".concat(name_1, "\""), "unknown-function:".concat(context.from, ":").concat(nameFrom));
+                return this.makeDiagnosticAt(nameFrom, nameFrom + name_5.length, "unknown function \"".concat(name_5, "\""), "unknown-function:".concat(context.from, ":").concat(nameFrom));
             }
             match = functionPattern.exec(text);
         }