@malloydata/malloy 0.0.43-dev230621212545 → 0.0.43-dev230622144455

package/dist/lang/ast/ast-utils.js

@@ -33,7 +33,7 @@ exports.errorFor = void 0;
  */
 function errorFor(reason) {
     return {
-        dataType: 'unknown',
+        dataType: 'error',
         expressionType: 'scalar',
         value: [`_ERROR_${reason.replace(/ /g, '_')}`],
         evalSpace: 'constant',

package/dist/lang/ast/expressions/expr-coalesce.js

@@ -48,8 +48,12 @@ class ExprCoalesce extends expression_def_1.ExpressionDef {
          * SQL, but I decided that is will happen when the "expressions are true
          * trees" rewrite happens.
          */
+        if (!fragtype_utils_1.FT.typeEq(maybeNull, whenNull)) {
+            this.log(`Mismatched types for coalesce (${maybeNull.dataType}, ${whenNull.dataType})`);
+        }
         return {
             ...whenNull,
+            dataType: maybeNull.dataType === 'error' ? whenNull.dataType : maybeNull.dataType,
             expressionType: (0, model_1.maxExpressionType)(maybeNull.expressionType, whenNull.expressionType),
             value: (0, model_1.mkExpr) `COALESCE(${maybeNull.value},${whenNull.value})`,
             evalSpace: (0, model_1.mergeEvalSpaces)(maybeNull.evalSpace, whenNull.evalSpace),

package/dist/lang/ast/expressions/expr-func.js

@@ -70,21 +70,11 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         const func = (_c = this.modelEntry(this.name.toLowerCase())) === null || _c === void 0 ? void 0 : _c.entry;
         if (func === undefined) {
             this.log(`Unknown function '${this.name}'. Use '${this.name}!(...)' to call a SQL function directly.`);
-            return {
-                dataType: 'unknown',
-                expressionType: 'scalar',
-                value: [],
-                evalSpace: 'constant',
-            };
+            return (0, ast_utils_1.errorFor)('unknown function');
         }
         else if (func.type !== 'function') {
             this.log(`Cannot call '${this.name}', which is of type ${func.type}`);
-            return {
-                dataType: 'unknown',
-                expressionType: 'scalar',
-                value: [],
-                evalSpace: 'constant',
-            };
+            return (0, ast_utils_1.errorFor)('called non function');
         }
         // Find the 'implicit argument' for aggregate functions called like `some_join.some_field.agg(...args)`
         // where the full arg list is `(some_field, ...args)`.
@@ -127,12 +117,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             this.log(`No matching overload for function ${this.name}(${argExprs
                 .map(e => e.dataType)
                 .join(', ')})`);
-            return {
-                dataType: 'unknown',
-                expressionType: 'scalar',
-                value: [],
-                evalSpace: 'constant',
-            };
+            return (0, ast_utils_1.errorFor)('no matching overload');
         }
         const { overload, expressionTypeErrors, evalSpaceErrors, nullabilityErrors } = result;
         // Report errors for expression type mismatch
@@ -171,12 +156,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             this.log(`Cannot call function ${this.name}(${argExprs
                 .map(e => e.dataType)
                 .join(', ')}) with source`);
-            return {
-                dataType: 'unknown',
-                expressionType,
-                value: [],
-                evalSpace: 'constant',
-            };
+            return (0, ast_utils_1.errorFor)('cannot call with source');
         }
         const funcCall = [
             {
@@ -189,12 +169,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         ];
         if (type.dataType === 'any') {
             this.log(`Invalid return type ${type.dataType} for function '${this.name}'`);
-            return {
-                dataType: 'unknown',
-                expressionType,
-                value: [],
-                evalSpace: 'constant',
-            };
+            return (0, ast_utils_1.errorFor)('invalid return type');
         }
         const maxEvalSpace = (0, malloy_types_1.mergeEvalSpaces)(...argExprs.map(e => e.evalSpace));
         // If the merged eval space of all args is constant, the result is constant.
@@ -240,10 +215,7 @@ function findOverload(func, args) {
                     // does not make sense to limit function calls to not allow nulls, since have
                     // so little control over nullability.
                     arg.dataType === 'null' ||
-                    // TODO I've included this because it means that errors cascade a bit less...
-                    // I think we may want to add an `error` type for nodes generated from errors,
-                    // then make `error` propagate without generating more errors.
-                    arg.dataType === 'unknown';
+                    arg.dataType === 'error';
                 // Check expression type errors
                 if (paramT.expressionType) {
                     const expressionTypeMatch = (0, malloy_types_1.isExpressionTypeLEQ)(arg.expressionType, paramT.expressionType);

package/dist/lang/ast/expressions/expr-granular-time.js

@@ -70,8 +70,20 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
             }
             return tsVal;
         }
-        this.log(`Cannot do time truncation on type '${exprVal.dataType}'`);
-        return (0, ast_utils_1.errorFor)('granularity typecheck');
+        if (exprVal.dataType !== 'error') {
+            this.log(`Cannot do time truncation on type '${exprVal.dataType}'`);
+        }
+        const returnType = exprVal.dataType === 'error'
+            ? (0, malloy_types_1.isDateUnit)(timeframe)
+                ? 'date'
+                : 'timestamp'
+            : exprVal.dataType;
+        return {
+            ...exprVal,
+            dataType: returnType,
+            value: (0, ast_utils_1.errorFor)('granularity typecheck').value,
+            evalSpace: 'constant',
+        };
     }
     apply(fs, op, left) {
         return this.getRange(fs).apply(fs, op, left);

package/dist/lang/ast/expressions/expr-minus.js

@@ -37,9 +37,9 @@ class ExprMinus extends expression_def_1.ExpressionDef {
         const expr = this.expr.getExpression(fs);
         if (this.typeCheck(this.expr, expr)) {
             if (expr.value.length > 1) {
-                return { ...expr, value: ['-(', ...expr.value, ')'] };
+                return { ...expr, dataType: 'number', value: ['-(', ...expr.value, ')'] };
             }
-            return { ...expr, value: ['-', ...expr.value] };
+            return { ...expr, dataType: 'number', value: ['-', ...expr.value] };
         }
         return (0, ast_utils_1.errorFor)('negate requires number');
     }

package/dist/lang/ast/expressions/expr-time-extract.js

@@ -54,6 +54,16 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
             if (from instanceof range_1.Range) {
                 let first = from.first.getExpression(fs);
                 let last = from.last.getExpression(fs);
+                const expressionType = (0, malloy_types_1.maxExpressionType)(first.expressionType, last.expressionType);
+                const evalSpace = (0, malloy_types_1.mergeEvalSpaces)(first.evalSpace, last.evalSpace);
+                if (first.dataType === 'error' || last.dataType === 'error') {
+                    return {
+                        dataType: 'number',
+                        expressionType,
+                        evalSpace,
+                        value: (0, ast_utils_1.errorFor)('extract from error').value,
+                    };
+                }
                 if (!(0, malloy_types_1.isTimeFieldType)(first.dataType)) {
                     from.first.log(`Can't extract ${extractTo} from '${first.dataType}'`);
                     return (0, ast_utils_1.errorFor)(`${extractTo} bad type ${first.dataType}`);
@@ -95,8 +105,8 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                 }
                 return {
                     dataType: 'number',
-                    expressionType: (0, malloy_types_1.maxExpressionType)(first.expressionType, last.expressionType),
-                    evalSpace: (0, malloy_types_1.mergeEvalSpaces)(first.evalSpace, last.evalSpace),
+                    expressionType,
+                    evalSpace,
                     value: [
                         {
                             type: 'dialect',
@@ -125,8 +135,16 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                         ],
                     };
                 }
-                this.log(`${this.extractText}() requires time type, not '${argV.dataType}'`);
-                return (0, ast_utils_1.errorFor)(`${this.extractText} bad type ${argV.dataType}`);
+                if (argV.dataType !== 'error') {
+                    this.log(`${this.extractText}() requires time type, not '${argV.dataType}'`);
+                }
+                return {
+                    dataType: 'number',
+                    expressionType: argV.expressionType,
+                    evalSpace: argV.evalSpace,
+                    value: (0, ast_utils_1.errorFor)(`${this.extractText} bad type ${argV.dataType}`)
+                        .value,
+                };
             }
         }
         throw this.internalError(`Illegal extraction unit '${this.extractText}'`);

package/dist/lang/ast/expressions/for-range.d.ts

@@ -7,7 +7,7 @@ export declare class ForRange extends ExpressionDef {
     readonly duration: ExpressionDef;
     readonly timeframe: Timeframe;
     elementType: string;
-    legalChildTypes: import("../../..").TypeDesc[];
+    legalChildTypes: import("../../../model").TypeDesc[];
     constructor(from: ExpressionDef, duration: ExpressionDef, timeframe: Timeframe);
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): undefined;

package/dist/lang/ast/expressions/for-range.js

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForRange = void 0;
+const model_1 = require("../../../model");
 const ast_utils_1 = require("../ast-utils");
 const fragtype_utils_1 = require("../fragtype-utils");
 const time_utils_1 = require("../time-utils");
@@ -46,8 +47,15 @@ class ForRange extends expression_def_1.ExpressionDef {
         }
         const nV = this.duration.getExpression(fs);
         if (nV.dataType !== 'number') {
-            this.log(`FOR duration count must be a number, not '${nV.dataType}'`);
-            return (0, ast_utils_1.errorFor)('FOR not number');
+            if (nV.dataType !== 'error') {
+                this.log(`FOR duration count must be a number, not '${nV.dataType}'`);
+            }
+            return {
+                dataType: 'boolean',
+                evalSpace: (0, model_1.mergeEvalSpaces)(startV.evalSpace, checkV.evalSpace),
+                expressionType: (0, model_1.maxExpressionType)(startV.expressionType, checkV.expressionType),
+                value: (0, ast_utils_1.errorFor)('for not number').value,
+            };
         }
         const units = this.timeframe.text;
         // If the duration resolution is smaller than date, we have

package/dist/lang/ast/expressions/pick-when.js

@@ -30,7 +30,11 @@ const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
 const utils_1 = require("./utils");
 function typeCoalesce(ev1, ev2) {
-    return ev1 === undefined || ev1.dataType === 'null' ? ev2 : ev1;
+    return ev1 === undefined ||
+        ev1.dataType === 'null' ||
+        ev1.dataType === 'error'
+        ? ev2
+        : ev1;
 }
 class Pick extends expression_def_1.ExpressionDef {
     constructor(choices, elsePick) {

package/dist/lang/ast/field-space/query-spaces.js

@@ -292,14 +292,11 @@ class QuerySpace extends refined_space_1.RefinedSpace {
                     }
                     else {
                         const typeDesc = field.typeDesc();
-                        // Filter out fields whose type is unknown, which means that a totally bad field
-                        // isn't sent to the compiler, where it will wig out. The downside is that in
-                        // subsequent stages of a query, the field is not in the input struct. But since
-                        // the error message says "Cannot define x which has unknown type", it makes sense
-                        // that it wouldn't be "defined" in later stages.
+                        // Filter out fields whose type is 'error', which means that a totally bad field
+                        // isn't sent to the compiler, where it will wig out.
                         // TODO Figure out how to make errors generated by `canContain` go in the right place,
                         // maybe by adding a logable element to SpaceFields.
-                        if (typeDesc.dataType !== 'unknown' && this.canContain(typeDesc)) {
+                        if (typeDesc.dataType !== 'error' && this.canContain(typeDesc)) {
                             fields.push(fieldQueryDef);
                         }
                     }

package/dist/lang/ast/field-space/reference-field.js

@@ -45,7 +45,7 @@ class ReferenceField extends space_field_1.SpaceField {
         if (this.res !== undefined && this.res.found) {
             return this.res.found.typeDesc();
         }
-        return { dataType: 'unknown', expressionType: 'scalar', evalSpace: 'input' };
+        return { dataType: 'error', expressionType: 'scalar', evalSpace: 'input' };
     }
 }
 exports.ReferenceField = ReferenceField;

package/dist/lang/ast/fragtype-utils.d.ts

@@ -21,7 +21,7 @@ export declare class FT {
      * @param right Right type
      * @param nullOk True if a NULL is an acceptable match
      */
-    static typeEq(left: TypeDesc, right: TypeDesc, nullOk?: boolean): boolean;
+    static typeEq(left: TypeDesc, right: TypeDesc, nullOk?: boolean, errorOk?: boolean): boolean;
     /**
      *
      * For error messages, returns a comma seperated list of readable names

package/dist/lang/ast/fragtype-utils.js

@@ -59,10 +59,11 @@ class FT {
      * @param right Right type
      * @param nullOk True if a NULL is an acceptable match
      */
-    static typeEq(left, right, nullOk = false) {
+    static typeEq(left, right, nullOk = false, errorOk = true) {
         const maybeEq = left.dataType === right.dataType;
         const nullEq = nullOk && (left.dataType === 'null' || right.dataType === 'null');
-        return maybeEq || nullEq;
+        const errorEq = errorOk && (left.dataType === 'error' || right.dataType === 'error');
+        return maybeEq || nullEq || errorEq;
     }
     /**
      *

package/dist/lang/ast/parameters/constant-parameter.js

@@ -37,7 +37,7 @@ class ConstantParameter extends has_parameter_1.HasParameter {
             this.log(`Unexpected expression type '${cVal.dataType}'`);
             return {
                 value: ['XXX-type-mismatch-error-XXX'],
-                type: 'string',
+                type: 'error',
                 name: this.name,
                 constant: true,
             };

package/dist/lang/ast/query-items/field-declaration.js

@@ -66,8 +66,8 @@ class FieldDeclaration extends malloy_element_1.MalloyElement {
         catch (error) {
             this.log(`Cannot define '${exprName}', ${error.message}`);
             return {
-                name: `error_defining_${exprName}`,
-                type: 'string',
+                name: exprName,
+                type: 'error',
             };
         }
         const compressValue = (0, utils_1.compressExpr)(exprValue.value);
@@ -96,17 +96,14 @@ class FieldDeclaration extends malloy_element_1.MalloyElement {
         }
         const circularDef = exprFS instanceof DefSpace && exprFS.foundCircle;
         if (!circularDef) {
-            if (exprValue.dataType === 'unknown') {
-                this.log(`Cannot define '${exprName}', value has unknown type`);
-            }
-            else {
+            if (exprValue.dataType !== 'error') {
                 const badType = fragtype_utils_1.FT.inspect(exprValue);
                 this.log(`Cannot define '${exprName}', unexpected type: ${badType}`);
             }
         }
         return {
-            name: `error_defining_${exprName}`,
-            type: 'string',
+            name: exprName,
+            type: 'error',
         };
     }
 }

package/dist/lang/ast/types/expression-def.js

@@ -67,7 +67,7 @@ class ExpressionDef extends malloy_element_1.MalloyElement {
      * @param eVal ...list of expressions that must match legalChildTypes
      */
     typeCheck(eNode, eVal) {
-        if (!fragtype_utils_1.FT.in(eVal, this.legalChildTypes)) {
+        if (eVal.dataType !== 'error' && !fragtype_utils_1.FT.in(eVal, this.legalChildTypes)) {
             eNode.log(`'${this.elementType}' Can't use type ${fragtype_utils_1.FT.inspect(eVal)}`);
             return false;
         }
@@ -232,6 +232,9 @@ function nullCompare(left, op, right) {
 function equality(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
+    const err = errorCascade('boolean', lhs, rhs);
+    if (err)
+        return err;
     // Unsupported types can be compare with null
     const checkUnsupport = lhs.dataType === 'unsupported' || rhs.dataType === 'unsupported';
     if (checkUnsupport) {
@@ -245,7 +248,7 @@ function equality(fs, left, op, right) {
         }
     }
     let value = timeCompare(left, lhs, op, rhs) || (0, utils_1.compose)(lhs.value, op, rhs.value);
-    if (lhs.dataType !== 'unknown' && rhs.dataType !== 'unknown') {
+    if (lhs.dataType !== 'error' && rhs.dataType !== 'error') {
         switch (op) {
             case '~':
             case '!~': {
@@ -285,6 +288,9 @@ function equality(fs, left, op, right) {
 function compare(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
+    const err = errorCascade('boolean', lhs, rhs);
+    if (err)
+        return err;
     const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
     const noCompare = unsupportError(left, lhs, right, rhs);
     if (noCompare) {
@@ -312,6 +318,9 @@ function allAre(oneType, ...values) {
 function numeric(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
+    const err = errorCascade('number', lhs, rhs);
+    if (err)
+        return err;
     const noGo = unsupportError(left, lhs, right, rhs);
     if (noGo) {
         return noGo;
@@ -335,7 +344,11 @@ function delta(fs, left, op, right) {
     if (noGo) {
         return noGo;
     }
-    if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType)) {
+    const timeLHS = (0, malloy_types_1.isTimeFieldType)(lhs.dataType);
+    const err = errorCascade(timeLHS ? 'error' : 'number', lhs, rhs);
+    if (err)
+        return err;
+    if (timeLHS) {
         let duration = right;
         if (rhs.dataType !== 'duration') {
             if ((0, granular_result_1.isGranularResult)(lhs)) {
@@ -385,6 +398,9 @@ function applyBinary(fs, left, op, right) {
             left.log('Cannot operate with unsupported type');
             return noGo;
         }
+        const err = errorCascade('number', num, denom);
+        if (err)
+            return err;
         if (num.dataType !== 'number') {
             left.log('Numerator for division must be a number');
         }
@@ -411,6 +427,16 @@ function applyBinary(fs, left, op, right) {
     return (0, ast_utils_1.errorFor)('applybinary bad operator');
 }
 exports.applyBinary = applyBinary;
+function errorCascade(dataType, ...es) {
+    if (es.some(e => e.dataType === 'error')) {
+        return {
+            dataType,
+            expressionType: (0, malloy_types_1.maxOfExpressionTypes)(es.map(e => e.expressionType)),
+            value: ["'cascading error'"],
+            evalSpace: (0, malloy_types_1.mergeEvalSpaces)(...es.map(e => e.evalSpace)),
+        };
+    }
+}
 /**
  * Return an error if a binary operation includes unsupported types.
  */

package/dist/lang/ast/types/malloy-element.js

@@ -297,14 +297,6 @@ class RunList extends ListOf {
     }
     executeList(doc) {
         while (this.execCursor < this.elements.length) {
-            if (doc.errorsExist()) {
-                // TODO make a better way to stop cascading errors -- this way means that if there are
-                // actual different errors in multiple places, we only see the first one. A better way
-                // might be to make things that have error pass all kinds of typechecks, which prevents
-                // the real cascade.
-                // This stops cascading errors
-                return;
-            }
             const el = this.elements[this.execCursor];
             if (isDocStatement(el)) {
                 const resp = el.execute(doc);

package/dist/lang/ast/types/space-param.js

@@ -40,7 +40,7 @@ class AbstractParameter extends SpaceParam {
         return this.astParam.parameter();
     }
     typeDesc() {
-        const type = this.astParam.type || 'unknown';
+        const type = this.astParam.type || 'error';
         // TODO Not sure whether params are considered "input space". It seems like they
         // could be input or constant, depending on usage.
         return { dataType: type, expressionType: 'scalar', evalSpace: 'input' };

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

@@ -319,7 +319,7 @@ describe('model statements', () => {
             group_by: b is c2
           }`).translationToFailWith(
                     // c2 is not defined because group_by doesn't know to look in the output space
-                    "'c2' is not defined", "Cannot define 'b', value has unknown type");
+                    "'c2' is not defined");
                 });
                 test('cannot use analytic in order_by, preserved over refinement', () => {
                     expect(`query: a1 is a -> {
@@ -334,19 +334,19 @@ describe('model statements', () => {
                     expect(`query: a1 is a -> {
             group_by: c is 1
             aggregate: c2 is all(all(sum(ai)))
-          }`).translationToFailWith('all() expression must not already be ungrouped', "Cannot define 'c2', value has unknown type");
+          }`).translationToFailWith('all() expression must not already be ungrouped');
                 });
                 test('cannot aggregate an ungrouped', () => {
                     expect(`query: a1 is a -> {
             group_by: c is 1
             aggregate: c2 is sum(all(sum(ai)))
-          }`).translationToFailWith('Aggregate expression cannot be aggregate', "Cannot define 'c2', value has unknown type");
+          }`).translationToFailWith('Aggregate expression cannot be aggregate');
                 });
                 test('cannot aggregate an aggregate', () => {
                     expect(`query: a1 is a -> {
             group_by: c is 1
             aggregate: c2 is sum(sum(ai))
-          }`).translationToFailWith('Aggregate expression cannot be aggregate', "Cannot define 'c2', value has unknown type");
+          }`).translationToFailWith('Aggregate expression cannot be aggregate');
                 });
                 test('can use field def in group_by, preserved over refinement', () => {
                     expect(`query: a1 is a -> {
@@ -375,12 +375,12 @@ describe('model statements', () => {
             test('function no matching overload', () => {
                 expect(`query: a -> {
           group_by: s is floor('a', 'b')
-        }`).translationToFailWith('No matching overload for function floor(string, string)', "Cannot define 's', value has unknown type");
+        }`).translationToFailWith('No matching overload for function floor(string, string)');
             });
             test('unknown function', () => {
                 expect(`query: a -> {
           group_by: s is asdfasdf()
-        }`).translationToFailWith("Unknown function 'asdfasdf'. Use 'asdfasdf!(...)' to call a SQL function directly.", "Cannot define 's', value has unknown type");
+        }`).translationToFailWith("Unknown function 'asdfasdf'. Use 'asdfasdf!(...)' to call a SQL function directly.");
             });
             test('can select different overload', () => {
                 expect('query: a -> { group_by: s is concat() }').toTranslate();
@@ -402,7 +402,7 @@ describe('model statements', () => {
             test('function return type incorrect', () => {
                 expect(`query: a -> {
             group_by: s is floor(1.2) + 'a'
-        }`).translationToFailWith("Non numeric('number,string') value with '+'", "Cannot define 's', value has unknown type");
+        }`).translationToFailWith("Non numeric('number,string') value with '+'");
             });
             test('can use output value in calculate', () => {
                 expect(`query: a -> {
@@ -414,7 +414,7 @@ describe('model statements', () => {
                 expect(`query: a -> {
           group_by: x is 1
           group_by: y is x
-        }`).translationToFailWith("'x' is not defined", "Cannot define 'y', value has unknown type");
+        }`).translationToFailWith("'x' is not defined");
             });
             test('lag can check that other args are constant', () => {
                 expect(`query: a -> {
@@ -471,7 +471,7 @@ describe('model statements', () => {
                 expect(`query: a {join_one: b with astr } -> {
             group_by: b
             calculate: foo is lag(b)
-          }`).translationToFailWith('No matching overload for function lag(struct)', "Cannot define 'foo', value has unknown type");
+          }`).translationToFailWith('No matching overload for function lag(struct)');
             });
             // TODO this doesn't work today, we're not rigorous enough with integer
             // subtypes. But we should probably make this typecheck properly.
@@ -485,7 +485,7 @@ describe('model statements', () => {
             test('cannot use stddev with no arguments', () => {
                 expect(`query: a -> {
           aggregate: x is stddev()
-        }`).translationToFailWith('No matching overload for function stddev()', "Cannot define 'x', value has unknown type");
+        }`).translationToFailWith('No matching overload for function stddev()');
             });
             test('can use stddev with postfix syntax', () => {
                 expect(`query: a -> {
@@ -1230,6 +1230,9 @@ describe('expressions', () => {
         test('null-check (??)', () => {
             expect((0, test_translator_1.expr) `ai ?? 7`).toTranslate();
         });
+        test('coalesce type mismatch', () => {
+            expect(new test_translator_1.BetaExpression('ai ?? @2003')).translationToFailWith('Mismatched types for coalesce (number, date)');
+        });
         test('disallow date OP number', () => {
             expect(new test_translator_1.BetaExpression('@2001 = 7')).translationToFailWith('Cannot compare a date to a number');
         });
@@ -1357,7 +1360,7 @@ describe('expressions', () => {
         source: na is a + { dimension: d is
           pick 7 when true and true
         }
-      `).translationToFailWith("pick incomplete, missing 'else'", "Cannot define 'd', value has unknown type");
+      `).translationToFailWith("pick incomplete, missing 'else'");
         });
         test('n-ary with mismatch when clauses', () => {
             expect((0, test_translator_1.markSource) `
@@ -1366,7 +1369,7 @@ describe('expressions', () => {
           pick '7' when true or true
           else 7
         }
-      `).translationToFailWith("pick type 'string', expected 'number'", "Cannot define 'd', value has unknown type");
+      `).translationToFailWith("pick type 'string', expected 'number'");
         });
         test('n-ary with mismatched else clause', () => {
             expect((0, test_translator_1.markSource) `
@@ -1374,28 +1377,28 @@ describe('expressions', () => {
           pick 7 when true and true
           else '7'
         }
-      `).translationToFailWith("else type 'string', expected 'number'", "Cannot define 'd', value has unknown type");
+      `).translationToFailWith("else type 'string', expected 'number'");
         });
         test('applied else mismatch', () => {
             expect((0, test_translator_1.markSource) `
         source: na is a + { dimension: d is
           7 ? pick 7 when 7 else 'not seven'
         }
-      `).translationToFailWith("else type 'string', expected 'number'", "Cannot define 'd', value has unknown type");
+      `).translationToFailWith("else type 'string', expected 'number'");
         });
         test('applied default mismatch', () => {
             expect((0, test_translator_1.markSource) `
         source: na is a + { dimension: d is
           7 ? pick 'seven' when 7
         }
-      `).translationToFailWith("pick default type 'number', expected 'string'", "Cannot define 'd', value has unknown type");
+      `).translationToFailWith("pick default type 'number', expected 'string'");
         });
         test('applied when mismatch', () => {
             expect((0, test_translator_1.markSource) `
         source: na is a + { dimension: d is
           7 ? pick 'seven' when 7 pick 6 when 6
         }
-      `).translationToFailWith("pick type 'number', expected 'string'", "Cannot define 'd', value has unknown type");
+      `).translationToFailWith("pick type 'number', expected 'string'");
         });
     });
     test('paren and applied div', () => {
@@ -2365,6 +2368,248 @@ describe('translation need error locations', () => {
         expect(m).translationToFailWith(/Bad table!/);
     });
 });
+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 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 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('pipeline comprehension', () => {
     test('second query gets namespace from first', () => {
         expect(`

package/dist/malloy.d.ts

@@ -511,7 +511,8 @@ export declare enum AtomicFieldType {
     Date = "date",
     Timestamp = "timestamp",
     Json = "json",
-    Unsupported = "unsupported"
+    Unsupported = "unsupported",
+    Error = "error"
 }
 export declare class AtomicField extends Entity {
     protected fieldTypeDef: FieldTypeDef;

package/dist/malloy.js

@@ -1030,6 +1030,7 @@ var AtomicFieldType;
     AtomicFieldType["Timestamp"] = "timestamp";
     AtomicFieldType["Json"] = "json";
     AtomicFieldType["Unsupported"] = "unsupported";
+    AtomicFieldType["Error"] = "error";
 })(AtomicFieldType = exports.AtomicFieldType || (exports.AtomicFieldType = {}));
 class AtomicField extends Entity {
     constructor(fieldTypeDef, parent, source) {
@@ -1053,6 +1054,8 @@ class AtomicField extends Entity {
                 return AtomicFieldType.Json;
             case 'unsupported':
                 return AtomicFieldType.Unsupported;
+            case 'error':
+                return AtomicFieldType.Error;
         }
     }
     isIntrinsic() {

package/dist/model/malloy_types.d.ts

@@ -269,7 +269,7 @@ declare type HasExpression = FieldDef & JustExpression;
 export declare function hasExpression(f: FieldDef): f is HasExpression;
 export declare type TimeFieldType = 'date' | 'timestamp';
 export declare function isTimeFieldType(s: string): s is TimeFieldType;
-export declare type AtomicFieldType = 'string' | 'number' | TimeFieldType | 'boolean' | 'unsupported' | 'json';
+export declare type AtomicFieldType = 'string' | 'number' | TimeFieldType | 'boolean' | 'unsupported' | 'json' | 'error';
 export declare function isAtomicFieldType(s: string): s is AtomicFieldType;
 /** All scalars can have an optional expression */
 export interface FieldAtomicDef extends NamedObject, Expression, ResultMetadata {
@@ -300,6 +300,9 @@ export interface FieldUnsupportedDef extends FieldAtomicDef {
     type: 'unsupported';
     rawType?: string;
 }
+export interface FieldErrorDef extends FieldAtomicDef {
+    type: 'error';
+}
 export declare type DateUnit = 'day' | 'week' | 'month' | 'quarter' | 'year';
 export declare function isDateUnit(str: string): str is DateUnit;
 export declare type TimestampUnit = DateUnit | 'hour' | 'minute' | 'second';
@@ -480,7 +483,7 @@ export interface StructDef extends NamedObject, ResultStructMetadata, Filtered {
     queryTimezone?: string;
     dialect: string;
 }
-export declare type ExpressionValueType = AtomicFieldType | 'null' | 'unknown' | 'duration' | 'any' | 'regular expression';
+export declare type ExpressionValueType = AtomicFieldType | 'null' | 'duration' | 'any' | 'regular expression';
 export declare type FieldValueType = ExpressionValueType | 'turtle' | 'struct';
 export interface ExpressionTypeDesc {
     dataType: FieldValueType;
@@ -528,7 +531,7 @@ export interface SQLBlockStructDef extends StructDef {
 }
 export declare function isSQLBlockStruct(sd: StructDef): sd is SQLBlockStructDef;
 /** any of the different field types */
-export declare type FieldTypeDef = FieldStringDef | FieldDateDef | FieldTimestampDef | FieldNumberDef | FieldBooleanDef | FieldJSONDef | FieldUnsupportedDef;
+export declare type FieldTypeDef = FieldStringDef | FieldDateDef | FieldTimestampDef | FieldNumberDef | FieldBooleanDef | FieldJSONDef | FieldUnsupportedDef | FieldErrorDef;
 export declare function isFieldTypeDef(f: FieldDef): f is FieldTypeDef;
 export declare function isFieldTimeBased(f: FieldDef): f is FieldTimestampDef | FieldDateDef;
 export declare function isFieldStructDef(f: FieldDef): f is StructDef;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.43-dev230621212545",
+  "version": "0.0.43-dev230622144455",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",