@malloydata/malloy 0.0.80-dev230907183434 → 0.0.80

package/dist/lang/lib/Malloy/MalloyParserListener.d.ts

@@ -42,6 +42,7 @@ import { ExprLogicalAndContext } from "./MalloyParser";
 import { ExprLogicalOrContext } from "./MalloyParser";
 import { ExprCoalesceContext } from "./MalloyParser";
 import { ExprCountDisinctContext } from "./MalloyParser";
+import { ExprPathlessAggregateContext } from "./MalloyParser";
 import { ExprAggregateContext } from "./MalloyParser";
 import { ExprExprContext } from "./MalloyParser";
 import { ExprAggFuncContext } from "./MalloyParser";
@@ -727,6 +728,18 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitExprCountDisinct?: (ctx: ExprCountDisinctContext) => void;
+    /**
+     * Enter a parse tree produced by the `exprPathlessAggregate`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     */
+    enterExprPathlessAggregate?: (ctx: ExprPathlessAggregateContext) => void;
+    /**
+     * Exit a parse tree produced by the `exprPathlessAggregate`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     */
+    exitExprPathlessAggregate?: (ctx: ExprPathlessAggregateContext) => void;
     /**
      * Enter a parse tree produced by the `exprAggregate`
      * labeled alternative in `MalloyParser.fieldExpr`.

package/dist/lang/lib/Malloy/MalloyParserVisitor.d.ts

@@ -42,6 +42,7 @@ import { ExprLogicalAndContext } from "./MalloyParser";
 import { ExprLogicalOrContext } from "./MalloyParser";
 import { ExprCoalesceContext } from "./MalloyParser";
 import { ExprCountDisinctContext } from "./MalloyParser";
+import { ExprPathlessAggregateContext } from "./MalloyParser";
 import { ExprAggregateContext } from "./MalloyParser";
 import { ExprExprContext } from "./MalloyParser";
 import { ExprAggFuncContext } from "./MalloyParser";
@@ -515,6 +516,13 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitExprCountDisinct?: (ctx: ExprCountDisinctContext) => Result;
+    /**
+     * Visit a parse tree produced by the `exprPathlessAggregate`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExprPathlessAggregate?: (ctx: ExprPathlessAggregateContext) => Result;
     /**
      * Visit a parse tree produced by the `exprAggregate`
      * labeled alternative in `MalloyParser.fieldExpr`.

package/dist/lang/malloy-to-ast.d.ts

@@ -175,7 +175,10 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitExprCompare(pcx: parse.ExprCompareContext): ast.ExprCompare;
     visitExprCountDisinct(pcx: parse.ExprCountDisinctContext): ast.ExprCountDistinct;
     visitExprUngroup(pcx: parse.ExprUngroupContext): ast.ExprUngroup;
+    symmetricAggregateUsageError(aggFunc: string): string;
+    asymmetricAggregateUsageError(aggFunc: string): string;
     visitExprAggregate(pcx: parse.ExprAggregateContext): ast.ExpressionDef;
+    visitExprPathlessAggregate(pcx: parse.ExprPathlessAggregateContext): ast.ExpressionDef;
     visitExprApply(pcx: parse.ExprApplyContext): ast.Apply;
     visitExprRange(pcx: parse.ExprRangeContext): ast.Range;
     visitExprCast(pcx: parse.ExprCastContext): ast.ExpressionDef;

package/dist/lang/malloy-to-ast.js

@@ -1006,6 +1006,9 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         throw this.internalError(pcx, `untranslatable comparison operator '${op}'`);
     }
     visitExprCountDisinct(pcx) {
+        if (this.m4WarningsEnabled()) {
+            this.contextError(pcx, "'count(DISTINCT expression)' deprecated, use 'count(expression)' instead");
+        }
         return this.astAt(new ast.ExprCountDistinct(this.getFieldExpr(pcx.fieldExpr())), pcx);
     }
     visitExprUngroup(pcx) {
@@ -1013,53 +1016,101 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const kw = pcx.ungroup().text.toLowerCase();
         return this.astAt(new ast.ExprUngroup(kw === 'all' ? kw : 'exclude', this.getFieldExpr(pcx.fieldExpr()), flist), pcx);
     }
+    symmetricAggregateUsageError(aggFunc) {
+        return `Symmetric aggregate function \`${aggFunc}\` must be written as \`${aggFunc}(expression)\` or \`path.to.field.${aggFunc}()\``;
+    }
+    asymmetricAggregateUsageError(aggFunc) {
+        return `Asymmetric aggregate function \`${aggFunc}\` must be written as \`path.to.field.${aggFunc}()\`, \`path.to.join.${aggFunc}(expression)\`, or \`${aggFunc}(expression)\``;
+    }
     visitExprAggregate(pcx) {
         const pathCx = pcx.fieldPath();
-        const path = pathCx
-            ? this.getFieldPath(pathCx, ast.ExpressionFieldReference)
-            : undefined;
+        const path = this.getFieldPath(pathCx, ast.ExpressionFieldReference);
         const source = pathCx && path ? this.astAt(path, pathCx) : undefined;
+        const aggFunc = pcx.aggregate().text.toLowerCase();
         const exprDef = pcx.fieldExpr();
         if (pcx.aggregate().COUNT()) {
             if (exprDef) {
-                this.contextError(exprDef, 'Ignored expression inside COUNT()');
+                this.contextError(exprDef, 'Expression illegal inside path.count()');
             }
             return new ast.ExprCount(source);
         }
-        // * was ok in count, not ok now ... this should be in grammer but at
-        // the moment while things are still changing its right to be caught here
-        const star = pcx.STAR();
-        if (star) {
-            this.contextError(pcx, "'*' is not a valid expression");
+        const expr = exprDef ? this.getFieldExpr(exprDef) : undefined;
+        if (aggFunc === 'min' || aggFunc === 'max') {
+            if (expr) {
+                this.contextError(pcx, this.symmetricAggregateUsageError(aggFunc));
+            }
+            else {
+                const idRef = this.astAt(new ast.ExprIdReference(path), pathCx);
+                return aggFunc === 'min'
+                    ? new ast.ExprMin(idRef)
+                    : new ast.ExprMax(idRef);
+            }
+        }
+        else if (aggFunc === 'avg') {
+            return new ast.ExprAvg(expr, source);
+        }
+        else if (aggFunc === 'sum') {
+            return new ast.ExprSum(expr, source);
+        }
+        else {
+            this.contextError(pcx, `Cannot parse aggregate function ${aggFunc}`);
         }
+        return new ast.ExprNULL();
+    }
+    /*
+     * error toodos
+     * for an aggregate function being called with no path predeeding ...
+     * [X] sum/avg() -- always an error
+     * [X] sum/avg(fieldName) -- suggest fieldName.sum
+     * [X] sum/avg(expr) -- suggest source.sum(expr)
+     * [X] count() -- OK
+     * [X] count(anything) OK
+     * ?? source.count()
+     * [X] min/max() -- always an error
+     * [X] min/max(expr) -- OK
+     * ?? source.min/max(expr)
+     */
+    visitExprPathlessAggregate(pcx) {
+        const exprDef = pcx.fieldExpr();
         const expr = exprDef ? this.getFieldExpr(exprDef) : undefined;
-        if (pcx.aggregate().MIN()) {
-            if (path) {
-                this.contextError(pcx, 'Path not legal for min()');
+        const source = undefined;
+        const aggFunc = pcx.aggregate().text.toLowerCase();
+        if (this.m4WarningsEnabled()) {
+            if (pcx.STAR()) {
+                this.contextError(pcx, `* illegal inside ${aggFunc}()`, 'warn');
             }
-            else if (expr) {
+        }
+        if (aggFunc === 'count') {
+            return this.astAt(expr ? new ast.ExprCountDistinct(expr) : new ast.ExprCount(), pcx);
+        }
+        else if (aggFunc === 'min') {
+            if (expr) {
                 return new ast.ExprMin(expr);
             }
             else {
-                this.contextError(pcx, 'Missing expression for min');
+                this.contextError(pcx, this.symmetricAggregateUsageError(aggFunc));
             }
         }
-        else if (pcx.aggregate().MAX()) {
-            if (path) {
-                this.contextError(pcx, 'Path not legal for max()');
-            }
-            else if (expr) {
+        else if (aggFunc === 'max') {
+            if (expr) {
                 return new ast.ExprMax(expr);
             }
             else {
-                this.contextError(pcx, 'Missing expression for max');
+                this.contextError(pcx, this.symmetricAggregateUsageError(aggFunc));
             }
         }
-        else if (pcx.aggregate().AVG()) {
-            return new ast.ExprAvg(expr, source);
-        }
-        else if (pcx.aggregate().SUM()) {
-            return new ast.ExprSum(expr, source);
+        else {
+            if (expr === undefined) {
+                this.contextError(pcx, this.asymmetricAggregateUsageError(aggFunc));
+                return new ast.ExprNULL();
+            }
+            const explicitSource = pcx.SOURCE_KW() !== undefined;
+            if (aggFunc === 'avg') {
+                return new ast.ExprAvg(expr, source, explicitSource);
+            }
+            else if (aggFunc === 'sum') {
+                return new ast.ExprSum(expr, source, explicitSource);
+            }
         }
         return new ast.ExprNULL();
     }

package/dist/lang/parse-malloy.d.ts

@@ -124,6 +124,7 @@ export declare abstract class MalloyTranslation {
     problemResponse(): ProblemResponse;
     problems(): LogMessage[];
     getLineMap(url: string): string[] | undefined;
+    codeAtLocation(location: DocumentLocation): string;
     prettyErrors(): string;
     childRequest(importURL: string): ModelDataRequest;
     getChildExports(importURL: string): Record<string, NamedModelObject>;

package/dist/lang/parse-malloy.js

@@ -575,6 +575,19 @@ class MalloyTranslation {
             return (_b = theChild.parseStep.sourceInfo) === null || _b === void 0 ? void 0 : _b.lines;
         }
     }
+    codeAtLocation(location) {
+        const lines = this.getLineMap(location.url) || [];
+        if (location.range.start.line === location.range.end.line) {
+            return lines[location.range.start.line].slice(location.range.start.character, location.range.end.character);
+        }
+        let result = '';
+        result += lines[location.range.start.line].slice(location.range.start.character);
+        for (let lineNumber = location.range.start.line + 1; lineNumber < location.range.end.line; lineNumber++) {
+            result += lines[lineNumber];
+        }
+        result += lines[location.range.end.line].slice(0, location.range.end.character);
+        return result;
+    }
     prettyErrors() {
         let lovely = '';
         let inFile = '';

package/dist/lang/test/expressions.spec.js

@@ -172,31 +172,247 @@ describe('expressions', () => {
       `).translationToFailWith('Filtered expression requires an aggregate computation');
     });
     describe('aggregate forms', () => {
-        test('count', () => {
-            expect((0, test_translator_1.expr) `count()`).toTranslate();
-        });
-        test('count distinct', () => {
-            expect((0, test_translator_1.expr) `count(distinct astr)`).toTranslate();
-        });
-        test('join.count()', () => {
-            expect((0, test_translator_1.expr) `b.count()`).toTranslate();
-        });
-        for (const f of ['sum', 'min', 'max', 'avg']) {
-            const fOfT = `${f}(af)`;
-            test(fOfT, () => {
-                expect(new test_translator_1.BetaExpression(fOfT)).toTranslate();
-            });
-            if (f !== 'min' && f !== 'max') {
-                const joinDot = `b.af.${f}()`;
-                test(joinDot, () => {
-                    expect(new test_translator_1.BetaExpression(joinDot)).toTranslate();
-                });
-                const joinAgg = `b.${f}(af)`;
-                test(joinAgg, () => {
-                    expect(new test_translator_1.BetaExpression(joinAgg)).toTranslate();
-                });
-            }
-        }
+        const m = (0, test_translator_1.model) `
+      source: root is a {
+        rename: column is ai
+        rename: nested is astruct
+        dimension: field is column * 2
+        dimension: many_field is many.column * 2
+        dimension: many_one_field is many.column + one.column
+        join_one: one is a {
+          rename: column is ai
+          dimension: field is column * 2
+          dimension: many_field is many.column * 2
+          join_many: many is a {
+            rename: column is ai
+            dimension: field is column * 2
+            dimension: constant is 1
+          } on true
+        } on true
+        join_many: many is a {
+          rename: column is ai
+          dimension: field is column * 2
+          dimension: constant is 1
+          join_one: one is a {
+            rename: column is ai
+            dimension: field is column * 2
+            join_one: one is a {
+              rename: column is ai
+              dimension: field is column * 2
+            } on true
+          } on true
+        } on true
+        join_cross: cross is a {
+          rename: column is ai
+          dimension: field is column * 2
+        } on true
+      }
+    `;
+        m.translator.translate();
+        const modelX = (0, test_translator_1.makeModelFunc)({
+            model: m.translator.modelDef,
+            wrap: x => `run: root -> { aggregate: x is ${x} }`,
+        });
+        test('one.column.min()', () => {
+            expect(modelX `one.column.min()`).toTranslate();
+        });
+        test('one.min(one.column)', () => {
+            expect(modelX `one.min(one.column)`).translationToFailWith('Symmetric aggregate function `min` must be written as `min(expression)` or `path.to.field.min()`');
+        });
+        test('min(one.column)', () => {
+            expect(modelX `min(one.column)`).toTranslate();
+        });
+        test('min(many.column)', () => {
+            expect(modelX `min(many.column)`).toTranslate();
+        });
+        test('min()', () => {
+            expect(modelX `min()`).translationToFailWith('Symmetric aggregate function `min` must be written as `min(expression)` or `path.to.field.min()`');
+        });
+        test('source.min(column)', () => {
+            expect(modelX `source.min(column)`).toTranslate();
+        });
+        test('many.column.max()', () => {
+            expect(modelX `many.column.max()`).toTranslate();
+        });
+        test('max(many.column)', () => {
+            expect(modelX `max(many.column)`).toTranslate();
+        });
+        test('max()', () => {
+            expect(modelX `max()`).translationToFailWith('Symmetric aggregate function `max` must be written as `max(expression)` or `path.to.field.max()`');
+        });
+        test('source.max(many.column)', () => {
+            expect(modelX `source.max(many.column)`).toTranslate();
+        });
+        test('many.column.count()', () => {
+            expect((0, test_translator_1.expr) `many.column.count()`).toTranslate();
+        });
+        test('count()', () => {
+            expect(modelX `count()`).toTranslate();
+        });
+        test('count(many.column)', () => {
+            expect(modelX `count(many.column)`).toTranslate();
+        });
+        test('source.count()', () => {
+            expect(modelX `source.count()`).toTranslate();
+        });
+        test('many.count()', () => {
+            expect(modelX `many.count()`).toTranslate();
+        });
+        test('sum()', () => {
+            expect(modelX `sum()`).translationToFailWith('Asymmetric aggregate function `sum` must be written as `path.to.field.sum()`, `path.to.join.sum(expression)`, or `sum(expression)`');
+        });
+        test('sum(column)', () => {
+            expect(modelX `sum(column)`).toTranslate();
+        });
+        test('sum(column * 2)', () => {
+            expect(modelX `sum(column * 2)`).toTranslate();
+        });
+        test('column.sum()', () => {
+            expect(modelX `column.sum()`).toTranslate();
+        });
+        test('source.sum(column)', () => {
+            expect(modelX `source.sum(column)`).toTranslate();
+        });
+        test('sum(many.column)', () => {
+            expect(modelX `sum(many.column)`).translationToFailWith('Join path is required for this calculation; use `many.column.sum()`');
+        });
+        test('source.sum(many.column)', () => {
+            expect(modelX `source.sum(many.column)`).translationToFailWith('Cannot compute asymmetric aggregate across forward `join_many` relationship `many`; use `many.column.sum()`');
+        });
+        test('many.column.sum()', () => {
+            expect(modelX `many.column.sum()`).toTranslate();
+        });
+        test('many.sum(many.column)', () => {
+            expect(modelX `many.sum(many.column)`).toTranslate();
+        });
+        test('sum(one.column)', () => {
+            expect(modelX `sum(one.column)`).toTranslateWithWarnings('Join path is required for this calculation; use `one.column.sum()` or `source.sum(one.column)` to get a result weighted with respect to `source`');
+        });
+        test('sum(many.constant)', () => {
+            expect(modelX `sum(many.constant)`).toTranslate();
+        });
+        test('source.sum(many.constant)', () => {
+            expect(modelX `source.sum(many.constant)`).toTranslate();
+        });
+        test('sum(nested.column)', () => {
+            expect(modelX `sum(nested.column)`).toTranslateWithWarnings('Join path is required for this calculation; use `nested.column.sum()` or `source.sum(nested.column)` to get a result weighted with respect to `source`');
+        });
+        test('nested.column.sum()', () => {
+            expect(modelX `nested.column.sum()`).toTranslate();
+        });
+        test('source.sum(nested.column)', () => {
+            expect(modelX `source.sum(nested.column)`).toTranslate();
+        });
+        test('sum(many.field)', () => {
+            expect(modelX `sum(many.field)`).translationToFailWith('Join path is required for this calculation; use `many.field.sum()`');
+        });
+        test('source.sum(many.field)', () => {
+            expect(modelX `source.sum(many.field)`).translationToFailWith('Cannot compute asymmetric aggregate across forward `join_many` relationship `many`; use `many.field.sum()`');
+        });
+        test('many.field.sum()', () => {
+            expect(modelX `many.field.sum()`).toTranslate();
+        });
+        test('many.sum(many.field)', () => {
+            expect(modelX `many.sum(many.field)`).toTranslate();
+        });
+        test('sum(many.field + many.field)', () => {
+            expect(modelX `sum(many.field + many.field)`).translationToFailWith('Join path is required for this calculation; use `many.sum(many.field + many.field)`');
+        });
+        test('source.sum(many.field + many.field)', () => {
+            expect(modelX `source.sum(many.field + many.field)`).translationToFailWith('Cannot compute asymmetric aggregate across forward `join_many` relationship `many`; use `many.sum(many.field + many.field)`');
+        });
+        test('many.field + many.field.sum()', () => {
+            expect(modelX `many.field + many.field.sum()`).toTranslate();
+        });
+        test('many.sum(many.field + many.field)', () => {
+            expect(modelX `many.sum(many.field + many.field)`).toTranslate();
+        });
+        test('sum(many_field)', () => {
+            expect(modelX `sum(many_field)`).translationToFailWith('Join path is required for this calculation; use `many_field.sum()`');
+        });
+        test('source.sum(many_field)', () => {
+            expect(modelX `source.sum(many_field)`).translationToFailWith('Cannot compute asymmetric aggregate across forward `join_many` relationship `many`; use `many_field.sum()`');
+        });
+        test('many_field.sum()', () => {
+            expect(modelX `many_field.sum()`).toTranslate();
+        });
+        test('many.sum(many_field)', () => {
+            expect(modelX `many.sum(many_field)`).toTranslate();
+        });
+        test('sum(one.many_field)', () => {
+            expect(modelX `sum(one.many_field)`).translationToFailWith('Join path is required for this calculation; use `one.many_field.sum()`');
+        });
+        test('source.sum(one.many_field)', () => {
+            expect(modelX `source.sum(one.many_field)`).translationToFailWith('Cannot compute asymmetric aggregate across forward `join_many` relationship `many`; use `one.many_field.sum()`');
+        });
+        test('one.many_field.sum()', () => {
+            expect(modelX `one.many_field.sum()`).toTranslate();
+        });
+        test('many.sum(one.many_field)', () => {
+            expect(modelX `one.many.sum(one.many_field)`).toTranslate();
+        });
+        test('sum(many.field + one.field)', () => {
+            expect(modelX `sum(many.field + one.field)`).translationToFailWith('Aggregated dimensional expression contains multiple join paths; rewrite, for example `sum(first_join.field + second_join.field)` as `first_join.field.sum() + second_join.field.sum()`');
+        });
+        test('source.sum(many.field + one.field)', () => {
+            expect(modelX `source.sum(many.field + one.field)`).translationToFailWith('Aggregated dimensional expression contains multiple join paths; rewrite, for example `sum(first_join.field + second_join.field)` as `first_join.field.sum() + second_join.field.sum()`');
+        });
+        test('many.sum(many.field + one.field)', () => {
+            expect(modelX `many.sum(many.field + one.field)`).toTranslate();
+        });
+        test('sum(many_one_field)', () => {
+            expect(modelX `sum(many_one_field)`).translationToFailWith('Aggregated dimensional expression contains multiple join paths; rewrite, for example `sum(first_join.field + second_join.field)` as `first_join.field.sum() + second_join.field.sum()`');
+        });
+        test('source.sum(many_one_field)', () => {
+            expect(modelX `source.sum(many_one_field)`).translationToFailWith('Aggregated dimensional expression contains multiple join paths; rewrite, for example `sum(first_join.field + second_join.field)` as `first_join.field.sum() + second_join.field.sum()`');
+        });
+        test('many.sum(many_one_field)', () => {
+            expect(modelX `many.sum(many_one_field)`).toTranslate();
+        });
+        test('sum(many.one.field)', () => {
+            expect(modelX `sum(many.one.field)`).translationToFailWith('Join path is required for this calculation; use `many.one.field.sum()` or `many.sum(many.one.field)` to get a result weighted with respect to `many`');
+        });
+        test('sum(many.one.one.field)', () => {
+            expect(modelX `sum(many.one.one.field)`).translationToFailWith('Join path is required for this calculation; use `many.one.one.field.sum()` or `many.sum(many.one.one.field)` to get a result weighted with respect to `many`');
+        });
+        test('many.avg(field)', () => {
+            expect(modelX `many.avg(field)`).toTranslate();
+        });
+        test('one.avg(field)', () => {
+            expect(modelX `one.avg(field)`).toTranslate();
+        });
+        test('cross.avg(field)', () => {
+            expect(modelX `cross.avg(field)`).translationToFailWith('Cannot compute asymmetric aggregate across `join_cross` relationship `cross`; use `field.avg()`');
+        });
+        test('cross.avg(cross.field)', () => {
+            expect(modelX `cross.avg(cross.field)`).toTranslate();
+        });
+        test('one.column.sum()', () => {
+            expect(modelX `one.column.sum()`).toTranslate();
+        });
+        test('one.sum(one.column)', () => {
+            expect(modelX `one.sum(one.column)`).toTranslate();
+        });
+        test('source.sum(one.column)', () => {
+            expect(modelX `source.sum(one.column)`).toTranslate();
+        });
+        test('sum(one.column + one.column)', () => {
+            expect(modelX `sum(one.column + one.column)`).toTranslateWithWarnings('Join path is required for this calculation; use `one.sum(one.column + one.column)` or `source.sum(one.column + one.column)` to get a result weighted with respect to `source`');
+        });
+        test('one.sum(one.column + one.column)', () => {
+            expect(modelX `one.sum(one.column + one.column)`).toTranslate();
+        });
+        test('source.sum(one.column + one.column)', () => {
+            expect(modelX `source.sum(one.column + one.column)`).toTranslate();
+        });
+        test('lag(sum(output))', () => {
+            expect((0, test_translator_1.model) `
+      ##! m4warnings
+      run: a -> {
+        group_by: output is 1
+        calculate: bar is lag(sum(output))
+      }`).translationToFailWith("'output' is not defined");
+        });
     });
     describe('pick statements', () => {
         test('full', () => {

package/dist/lang/test/parse.spec.js

@@ -301,133 +301,7 @@ describe('error cascading', () => {
         'days(@2003 to err)': 'number',
     };
     const scalars = Object.keys(typedScalars);
-    const aggregates = [
-        'measure_err { where: true }',
-        'count(distinct err)',
-        'b.sum(err)',
-        'b.stddev(err)',
-    ];
-    const ungroupedAggregates = ['all(measure_err)'];
-    test('dependent errors do not cascade', () => {
-        expect(`
-        source: a1 is a {
-          join_one: b with astr
-          dimension:
-            ${'err is null'}
-            ${scalars.map((d, i) => `e${i} is ${d}`).join('\n            ')}
-          measure:
-            measure_err is count(distinct foo),
-            ${[...aggregates, ...ungroupedAggregates]
-            .map((m, i) => `e${i + scalars.length} is ${m}`)
-            .join('\n            ')}
-        }
-      `).translationToFailWith("Cannot define 'err', unexpected type: null", "'foo' is not defined");
-    });
-    test('error type inference is good', () => {
-        for (const scalar of scalars) {
-            const source = `
-          source: a1 is a {
-            dimension:
-              ${'err is null'}
-              dim is length(${scalar}, 1)
-          }
-        `;
-            expect(source).translationToFailWith("Cannot define 'err', unexpected type: null", `No matching overload for function length(${typedScalars[scalar]}, number)`);
-        }
-    });
-    test('eval space of errors is preserved', () => {
-        expect(`
-        source: a1 is a {
-          join_one: b with astr
-        }
-        query: a1 -> {
-          group_by:
-            ${'err is null'}
-          aggregate:
-            measure_err is count(distinct foo)
-          calculate:
-            ${scalars
-            .map((d, i) => `e${i} is lag(${d})`)
-            .join('\n            ')}
-            ${aggregates
-            .map((m, i) => `e${i + scalars.length} is lag(${m})`)
-            .join('\n            ')}
-        }
-      `).translationToFailWith("Cannot define 'err', unexpected type: null", "'foo' is not defined");
-    });
-});
-describe('error cascading', () => {
-    test('errors can appear in multiple top level objects', () => {
-        expect((0, test_translator_1.markSource) `
-        source: a1 is a { dimension: ${'x is count()'} }
-        source: a2 is a { dimension: ${'x is count()'} }
-      `).translationToFailWith('Cannot use an aggregate field in a dimension declaration, did you mean to use a measure declaration instead?', 'Cannot use an aggregate field in a dimension declaration, did you mean to use a measure declaration instead?');
-    });
-    const typedScalars = {
-        'err': 'error',
-        '@2003 ~ @2003 for err hours': 'boolean',
-        'err.hour': 'timestamp',
-        'err.month': 'date',
-        'day_of_week(err)': 'number',
-        'err::string': 'string',
-        '-err': 'number',
-        'err * 1': 'number',
-        '1 * err': 'number',
-        'err / 1': 'number',
-        '1 / err': 'number',
-        'err % 1': 'number',
-        '1 % err': 'number',
-        'err + 1': 'number',
-        '1 + err': 'number',
-        'err - 1': 'number',
-        '1 - err': 'number',
-        '@2003 ? err for 1 minute': 'boolean',
-        '@2003 ? @2003 for err minutes': 'boolean',
-        '3 ? > err & > 3': 'boolean',
-        '3 ? > 3 & > err': 'boolean',
-        '3 ? > err | > 3': 'boolean',
-        '3 ? > 3 | > err': 'boolean',
-        'err ? > 3': 'boolean',
-        '3 ? > err': 'boolean',
-        '1 > err': 'boolean',
-        'err > 1': 'boolean',
-        '1 >= err': 'boolean',
-        'err >= 1': 'boolean',
-        '1 < err': 'boolean',
-        'err < 1': 'boolean',
-        '1 <= err': 'boolean',
-        'err <= 1': 'boolean',
-        '1 = err': 'boolean',
-        'err = 1': 'boolean',
-        '1 != err': 'boolean',
-        'err != 1': 'boolean',
-        '1 ~ err': 'boolean',
-        'err ~ 1': 'boolean',
-        '1 !~ err': 'boolean',
-        'err !~ 1': 'boolean',
-        'not err': 'boolean',
-        'err and true': 'boolean',
-        'true and err': 'boolean',
-        'err or true': 'boolean',
-        'true or err': 'boolean',
-        'err ?? 1': 'number',
-        '1 ?? err': 'number',
-        'cast(err as number)': 'number',
-        '(err)': 'error',
-        'length(err)': 'number',
-        'pick err when true else false': 'boolean',
-        'pick true when err else false': 'boolean',
-        'pick true when true else err': 'boolean',
-        'days(err to @2003)': 'number',
-        'days(@2003 to err)': 'number',
-    };
-    const scalars = Object.keys(typedScalars);
-    const aggregates = [
-        'measure_err { where: true }',
-        'count(distinct err)',
-        'b.sum(err)',
-        'b.stddev(err)',
-    ];
+    const aggregates = ['measure_err { where: true }'];
     const ungroupedAggregates = ['all(measure_err)'];
     test('dependent errors do not cascade', () => {
         expect(`

package/dist/lang/test/query.spec.js

@@ -579,7 +579,7 @@ describe('query:', () => {
       query: a extend { join_one: aaa on astr=aaa.astr } -> {
         group_by: aaa.big_i
         aggregate: s is aaa.big_i.sum()
-        calculate: a is lag(big_i.sum())
+        calculate: a is lag(big_i)
       }`).toTranslate();
         });
     });