@malloydata/malloy 0.0.203-dev241023171450 → 0.0.203-dev241024163815

package/dist/lang/ast/expressions/binary-boolean.d.ts

@@ -7,7 +7,7 @@ export declare abstract class BinaryBoolean<opType extends BinaryMalloyOperator>
     readonly op: opType;
     readonly right: ExpressionDef;
     elementType: string;
-    legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
+    legalChildTypes: import("../../..").TypeDesc[];
     constructor(left: ExpressionDef, op: opType, right: ExpressionDef);
     getExpression(fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/binary-boolean.js

@@ -23,10 +23,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinaryBoolean = void 0;
-const malloy_types_1 = require("../../../model/malloy_types");
 const ast_utils_1 = require("../ast-utils");
 const fragtype_utils_1 = require("../fragtype-utils");
 const binary_operators_1 = require("../types/binary_operators");
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 class BinaryBoolean extends expression_def_1.ExpressionDef {
     constructor(left, op, right) {
@@ -41,16 +41,14 @@ class BinaryBoolean extends expression_def_1.ExpressionDef {
         const left = this.left.getExpression(fs);
         const right = this.right.getExpression(fs);
         if (this.typeCheck(this.left, left) && this.typeCheck(this.right, right)) {
-            const evalSpace = (0, malloy_types_1.mergeEvalSpaces)(left.evalSpace, right.evalSpace);
-            return {
+            return (0, expr_value_1.computedExprValue)({
                 dataType: 'boolean',
-                expressionType: (0, malloy_types_1.maxExpressionType)(left.expressionType, right.expressionType),
                 value: {
                     node: (0, binary_operators_1.getExprNode)(this.op),
                     kids: { left: left.value, right: right.value },
                 },
-                evalSpace,
-            };
+                from: [left, right],
+            });
         }
         return (0, ast_utils_1.errorFor)('logial required boolean');
     }

package/dist/lang/ast/expressions/case.js

@@ -7,10 +7,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CaseWhen = exports.Case = void 0;
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
 const fragtype_utils_1 = require("../fragtype-utils");
-const model_1 = require("../../../model");
 function typeCoalesce(ev1, ev2) {
     return ev1 === undefined ||
         ev1.dataType === 'null' ||
@@ -36,13 +36,11 @@ class Case extends expression_def_1.ExpressionDef {
                 caseThen: [],
             },
         };
-        let expressionType = 'scalar';
-        let evalSpace = 'constant';
+        const dependents = [];
         let value = undefined;
         if (this.value) {
             value = this.value.getExpression(fs);
-            expressionType = (0, model_1.maxExpressionType)(expressionType, value.expressionType);
-            evalSpace = (0, model_1.mergeEvalSpaces)(evalSpace, value.evalSpace);
+            dependents.push(value);
             resultExpr.kids.caseValue = value.value;
         }
         const choiceValues = [];
@@ -50,6 +48,7 @@ class Case extends expression_def_1.ExpressionDef {
             const when = c.when.getExpression(fs);
             const then = c.then.getExpression(fs);
             choiceValues.push({ when, then });
+            dependents.push(when, then);
         }
         let returnType;
         for (const aChoice of choiceValues) {
@@ -75,8 +74,6 @@ class Case extends expression_def_1.ExpressionDef {
                 });
             }
             returnType = typeCoalesce(returnType, aChoice.then);
-            expressionType = (0, model_1.maxExpressionType)(expressionType, (0, model_1.maxExpressionType)(aChoice.then.expressionType, aChoice.when.expressionType));
-            evalSpace = (0, model_1.mergeEvalSpaces)(evalSpace, aChoice.then.evalSpace, aChoice.when.evalSpace);
             resultExpr.kids.caseWhen.push(aChoice.when.value);
             resultExpr.kids.caseThen.push(aChoice.then.value);
         }
@@ -89,16 +86,14 @@ class Case extends expression_def_1.ExpressionDef {
                 });
             }
             returnType = typeCoalesce(returnType, elseValue);
-            expressionType = (0, model_1.maxExpressionType)(expressionType, elseValue.expressionType);
-            evalSpace = (0, model_1.mergeEvalSpaces)(evalSpace, elseValue.evalSpace);
+            dependents.push(elseValue);
             resultExpr.kids.caseElse = elseValue.value;
         }
-        return {
+        return (0, expr_value_1.computedExprValue)({
             value: resultExpr,
             dataType: (_a = returnType === null || returnType === void 0 ? void 0 : returnType.dataType) !== null && _a !== void 0 ? _a : 'null',
-            expressionType,
-            evalSpace,
-        };
+            from: dependents,
+        });
     }
 }
 exports.Case = Case;

package/dist/lang/ast/expressions/expr-alternation-tree.js

@@ -23,7 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprAlternationTree = void 0;
-const malloy_types_1 = require("../../../model/malloy_types");
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const binary_operators_1 = require("../types/binary_operators");
 /**
@@ -76,21 +76,15 @@ class ExprAlternationTree extends expression_def_1.ExpressionDef {
             if (inList.length > 0 && (applyOp === '=' || applyOp === '!=')) {
                 const isIn = expr.getExpression(fs);
                 const values = inList.map(v => v.getExpression(fs));
-                let { evalSpace, expressionType } = isIn;
-                for (const value of values) {
-                    evalSpace = (0, malloy_types_1.mergeEvalSpaces)(evalSpace, value.evalSpace);
-                    expressionType = (0, malloy_types_1.maxExpressionType)(expressionType, value.expressionType);
-                }
-                return {
+                return (0, expr_value_1.computedExprValue)({
                     dataType: 'boolean',
-                    evalSpace,
-                    expressionType,
                     value: {
                         node: 'in',
                         not: applyOp === '!=',
                         kids: { e: isIn.value, oneOf: values.map(v => v.value) },
                     },
-                };
+                    from: [isIn, ...values],
+                });
             }
             if (inList.length === 0 && warnOnComplexTree) {
                 this.logWarning('or-choices-only', `Only | seperated values are legal when used with ${applyOp} operator`);
@@ -98,15 +92,14 @@ class ExprAlternationTree extends expression_def_1.ExpressionDef {
         }
         const choice1 = this.left.apply(fs, applyOp, expr);
         const choice2 = this.right.apply(fs, applyOp, expr);
-        return {
+        return (0, expr_value_1.computedExprValue)({
             dataType: 'boolean',
-            expressionType: (0, malloy_types_1.maxExpressionType)(choice1.expressionType, choice2.expressionType),
-            evalSpace: (0, malloy_types_1.mergeEvalSpaces)(choice1.evalSpace, choice2.evalSpace),
             value: {
                 node: this.op === '&' ? 'and' : 'or',
                 kids: { left: choice1.value, right: choice2.value },
             },
-        };
+            from: [choice1, choice2],
+        });
     }
     requestExpression(_fs) {
         return undefined;

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

@@ -24,6 +24,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprCast = void 0;
 const time_utils_1 = require("../time-utils");
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 class ExprCast extends expression_def_1.ExpressionDef {
     constructor(expr, castType, safe = false) {
@@ -55,12 +56,11 @@ class ExprCast extends expression_def_1.ExpressionDef {
                 }
             }
         }
-        return {
+        return (0, expr_value_1.computedExprValue)({
             dataType,
-            expressionType: expr.expressionType,
             value: (0, time_utils_1.castTo)(this.castType, expr.value, expr.dataType, this.safe),
-            evalSpace: expr.evalSpace,
-        };
+            from: [expr],
+        });
     }
 }
 exports.ExprCast = ExprCast;

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

@@ -26,6 +26,7 @@ exports.ExprFunc = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const ast_utils_1 = require("../ast-utils");
 const struct_space_field_base_1 = require("../field-space/struct-space-field-base");
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const field_space_1 = require("../types/field-space");
 const utils_1 = require("../../../model/utils");
@@ -78,11 +79,9 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         var _a, _b, _c, _d;
         const argExprsWithoutImplicit = this.args.map(arg => arg.getExpression(fs));
         if (this.isRaw) {
-            let expressionType = 'scalar';
             let collectType;
             const funcCall = [`${this.name}(`];
             for (const expr of argExprsWithoutImplicit) {
-                expressionType = (0, malloy_types_1.maxExpressionType)(expressionType, expr.expressionType);
                 if (collectType) {
                     funcCall.push(',');
                 }
@@ -93,12 +92,11 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             }
             funcCall.push(')');
             const dataType = (_b = (_a = this.rawType) !== null && _a !== void 0 ? _a : collectType) !== null && _b !== void 0 ? _b : 'number';
-            return {
+            return (0, expr_value_1.computedExprValue)({
                 dataType,
-                expressionType,
                 value: (0, utils_1.composeSQLExpr)(funcCall),
-                evalSpace: (0, malloy_types_1.mergeEvalSpaces)(...argExprsWithoutImplicit.map(e => e.evalSpace)),
-            };
+                from: argExprsWithoutImplicit,
+            });
         }
         const dialect = (_c = fs.dialectObj()) === null || _c === void 0 ? void 0 : _c.name;
         const { found: func, error } = this.findFunctionDef(dialect);
@@ -110,7 +108,8 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         let implicitExpr = undefined;
         let structPath = (_d = this.source) === null || _d === void 0 ? void 0 : _d.path;
         if (this.source) {
-            const sourceFoot = this.source.getField(fs).found;
+            const lookup = this.source.getField(fs);
+            const sourceFoot = lookup.found;
             if (sourceFoot) {
                 const footType = sourceFoot.typeDesc();
                 if ((0, malloy_types_1.isAtomicFieldType)(footType.dataType)) {
@@ -306,6 +305,8 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             : (0, malloy_types_1.expressionIsScalar)(expressionType)
                 ? maxEvalSpace
                 : 'output';
+        // TODO consider if I can use `computedExprValue` here...
+        // seems like the rules for the evalSpace is a bit different from normal though
         return {
             dataType: type.dataType,
             expressionType,

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

@@ -102,12 +102,12 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
         const one = { node: 'numberLiteral', literal: '1' };
         if (begin.dataType === 'timestamp') {
             const beginTS = expr_time_1.ExprTime.fromValue('timestamp', begin);
-            const endTS = new expr_time_1.ExprTime('timestamp', (0, time_utils_1.timeOffset)('timestamp', begin.value, '+', one, this.units), begin.expressionType);
+            const endTS = new expr_time_1.ExprTime('timestamp', (0, time_utils_1.timeOffset)('timestamp', begin.value, '+', one, this.units), [begin]);
             return new range_1.Range(beginTS, endTS);
         }
-        const beginDate = new expr_time_1.ExprTime('date', begin.value, begin.expressionType);
+        const beginDate = new expr_time_1.ExprTime('date', begin.value, [begin]);
         const endAt = (0, time_utils_1.timeOffset)('date', begin.value, '+', one, this.units);
-        const endDate = new expr_time_1.ExprTime('date', endAt, begin.expressionType);
+        const endDate = new expr_time_1.ExprTime('date', endAt, [begin]);
         return new range_1.Range(beginDate, endDate);
     }
 }

package/dist/lang/ast/expressions/expr-id-reference.js

@@ -42,6 +42,7 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
             if (def.isOutputField) {
                 return {
                     ...td,
+                    // TODO what about literal??
                     evalSpace: td.evalSpace === 'constant' ? 'constant' : 'output',
                     value: { node: 'outputField', name: this.refString },
                 };

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

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprNULL = void 0;
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 class ExprNULL extends expression_def_1.ExpressionDef {
     constructor() {
@@ -30,12 +31,10 @@ class ExprNULL extends expression_def_1.ExpressionDef {
         this.elementType = 'NULL';
     }
     getExpression() {
-        return {
+        return (0, expr_value_1.literalExprValue)({
             dataType: 'null',
             value: { node: 'null' },
-            expressionType: 'scalar',
-            evalSpace: 'literal',
-        };
+        });
     }
 }
 exports.ExprNULL = ExprNULL;

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

@@ -23,7 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprNumber = void 0;
-const fragtype_utils_1 = require("../fragtype-utils");
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 class ExprNumber extends expression_def_1.ExpressionDef {
     constructor(n) {
@@ -35,11 +35,10 @@ class ExprNumber extends expression_def_1.ExpressionDef {
         return this.constantExpression();
     }
     constantExpression() {
-        return {
-            ...fragtype_utils_1.FT.numberT,
-            evalSpace: 'literal',
+        return (0, expr_value_1.literalExprValue)({
+            dataType: 'number',
             value: { node: 'numberLiteral', literal: this.n },
-        };
+        });
     }
 }
 exports.ExprNumber = ExprNumber;

package/dist/lang/ast/expressions/expr-record-literal.js

@@ -32,10 +32,10 @@ class RecordLiteral extends expression_def_1.ExpressionDef {
         //   node: 'recordLiteral',
         //   kids: {},
         // };
-        // let resultExprType: ExpressionType = 'scalar';
+        // const dependents: ExprValue[] = [];
         // for (const el of this.pairs) {
         //   const xVal = el.value.getExpression(fs);
-        //   const expr: TypedExpr = {typeDef: 'error', ...xVal.value};
+        //   const expr: TypedExpr = {typeDef: {type: 'error'}, ...xVal.value};
         //   if (TD.isError(expr.typeDef) && isAtomicFieldType(xVal.dataType)) {
         //     expr.typeDef = xVal.dataType;
         //   }
@@ -46,14 +46,13 @@ class RecordLiteral extends expression_def_1.ExpressionDef {
         //     );
         //   }
         //   recLit.kids[el.key] = expr;
-        //   resultExprType = maxExpressionType(xVal.expressionType, resultExprType);
+        //   dependents.push(xVal);
         // }
-        // return {
+        // return computedExprValue({
         //   dataType: 'record',
         //   value: recLit,
-        //   expressionType: resultExprType,
-        //   evalSpace: 'literal',
-        // };
+        //   from: dependents,
+        // });
     }
 }
 exports.RecordLiteral = RecordLiteral;

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

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprRegEx = void 0;
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 class ExprRegEx extends expression_def_1.ExpressionDef {
     constructor(regex) {
@@ -31,12 +32,10 @@ class ExprRegEx extends expression_def_1.ExpressionDef {
         this.elementType = 'regular expression literal';
     }
     getExpression() {
-        return {
+        return (0, expr_value_1.literalExprValue)({
             dataType: 'regular expression',
-            expressionType: 'scalar',
             value: { node: 'regexpLiteral', literal: this.regex },
-            evalSpace: 'literal',
-        };
+        });
     }
 }
 exports.ExprRegEx = ExprRegEx;

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

@@ -24,7 +24,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprString = void 0;
 const expression_def_1 = require("../types/expression-def");
-const fragtype_utils_1 = require("../fragtype-utils");
+const expr_value_1 = require("../types/expr-value");
 class ExprString extends expression_def_1.ExpressionDef {
     constructor(src) {
         super();
@@ -32,11 +32,10 @@ class ExprString extends expression_def_1.ExpressionDef {
         this.value = src;
     }
     getExpression(_fs) {
-        return {
-            ...fragtype_utils_1.FT.stringT,
+        return (0, expr_value_1.literalExprValue)({
+            dataType: 'string',
             value: { node: 'stringLiteral', literal: this.value },
-            evalSpace: 'literal',
-        };
+        });
     }
 }
 exports.ExprString = ExprString;

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

@@ -24,7 +24,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprTimeExtract = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
-const ast_utils_1 = require("../ast-utils");
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const range_1 = require("./range");
 class ExprTimeExtract extends expression_def_1.ExpressionDef {
@@ -53,15 +53,12 @@ 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 {
+                    return (0, expr_value_1.computedErrorExprValue)({
                         dataType: 'number',
-                        expressionType,
-                        evalSpace,
-                        value: (0, ast_utils_1.errorFor)('extract from error').value,
-                    };
+                        error: 'extract from error',
+                        from: [first, last],
+                    });
                 }
                 if (!(0, malloy_types_1.isTemporalField)(first.dataType)) {
                     return from.first.loggedErrorExpr('invalid-type-for-time-extraction', `Can't extract ${extractTo} from '${first.dataType}'`);
@@ -97,10 +94,8 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                 if (!(0, malloy_types_1.isTimestampUnit)(extractTo)) {
                     return this.loggedErrorExpr('invalid-time-extraction-unit', `Cannot extract ${extractTo} from a range`);
                 }
-                return {
+                return (0, expr_value_1.computedExprValue)({
                     dataType: 'number',
-                    expressionType,
-                    evalSpace,
                     value: {
                         node: 'timeDiff',
                         units: extractTo,
@@ -109,32 +104,30 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                             right: (0, malloy_types_1.mkTemporal)(last.value, valueType),
                         },
                     },
-                };
+                    from: [first, last],
+                });
             }
             else {
                 const argV = from.getExpression(fs);
                 if ((0, malloy_types_1.isTemporalField)(argV.dataType)) {
-                    return {
+                    return (0, expr_value_1.computedExprValue)({
                         dataType: 'number',
-                        expressionType: argV.expressionType,
-                        evalSpace: argV.evalSpace,
                         value: {
                             node: 'extract',
                             e: (0, malloy_types_1.mkTemporal)(argV.value, argV.dataType),
                             units: extractTo,
                         },
-                    };
+                        from: [argV],
+                    });
                 }
                 if (argV.dataType !== 'error') {
                     this.logError('unsupported-type-for-time-extraction', `${this.extractText}() requires time type, not '${argV.dataType}'`);
                 }
-                return {
+                return (0, expr_value_1.computedErrorExprValue)({
                     dataType: 'number',
-                    expressionType: argV.expressionType,
-                    evalSpace: argV.evalSpace,
-                    value: (0, ast_utils_1.errorFor)(`${this.extractText} bad type ${argV.dataType}`)
-                        .value,
-                };
+                    error: `${this.extractText} bad type ${argV.dataType}`,
+                    from: [argV],
+                });
             }
         }
         throw this.internalError(`Illegal extraction unit '${this.extractText}'`);

package/dist/lang/ast/expressions/expr-time.d.ts

@@ -1,11 +1,11 @@
-import { Expr, ExpressionType, TemporalFieldType } from '../../../model/malloy_types';
+import { Expr, TemporalFieldType } from '../../../model/malloy_types';
 import { FieldSpace } from '../types/field-space';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 export declare class ExprTime extends ExpressionDef {
     elementType: string;
     readonly translationValue: ExprValue;
-    constructor(timeType: TemporalFieldType, value: Expr, expressionType?: ExpressionType);
+    constructor(timeType: TemporalFieldType, value: Expr, from?: ExprValue[]);
     getExpression(_fs: FieldSpace): ExprValue;
     static fromValue(timeType: TemporalFieldType, expr: ExprValue): ExprTime;
 }

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

@@ -24,18 +24,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprTime = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 class ExprTime extends expression_def_1.ExpressionDef {
-    constructor(timeType, value, expressionType = 'scalar') {
+    constructor(timeType, value, from) {
         super();
         this.elementType = 'timestampOrDate';
         this.elementType = timeType;
-        this.translationValue = {
+        this.translationValue = (0, expr_value_1.computedExprValue)({
             dataType: timeType,
-            expressionType,
             value,
-            evalSpace: 'constant',
-        };
+            from: from !== null && from !== void 0 ? from : [],
+        });
     }
     getExpression(_fs) {
         return this.translationValue;
@@ -54,7 +54,7 @@ class ExprTime extends expression_def_1.ExpressionDef {
             }
             value = toTs;
         }
-        return new ExprTime(timeType, value, expr.expressionType);
+        return new ExprTime(timeType, value, [expr]);
     }
 }
 exports.ExprTime = ExprTime;

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

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

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

@@ -23,10 +23,10 @@
  */
 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");
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const expr_time_1 = require("./expr-time");
 const range_1 = require("./range");
@@ -50,12 +50,11 @@ class ForRange extends expression_def_1.ExpressionDef {
             if (nV.dataType !== 'error') {
                 this.logError('invalid-duration-quantity', `FOR duration count must be a number, not '${nV.dataType}'`);
             }
-            return {
+            return (0, expr_value_1.computedErrorExprValue)({
                 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,
-            };
+                error: 'for not number',
+                from: [startV, checkV],
+            });
         }
         const units = this.timeframe.text;
         // If the duration resolution is smaller than date, we have
@@ -86,10 +85,10 @@ class ForRange extends expression_def_1.ExpressionDef {
             else {
                 from = (0, time_utils_1.castTo)('timestamp', from, 'date');
             }
-            rangeStart = new expr_time_1.ExprTime('timestamp', from, startV.expressionType);
+            rangeStart = new expr_time_1.ExprTime('timestamp', from, [startV]);
         }
         const to = (0, time_utils_1.timeOffset)('timestamp', from, '+', nV.value, units);
-        const rangeEnd = new expr_time_1.ExprTime('timestamp', to, startV.expressionType);
+        const rangeEnd = new expr_time_1.ExprTime('timestamp', to, [startV, nV]);
         return new range_1.Range(rangeStart, rangeEnd).apply(fs, op, applyTo);
     }
     requestExpression(_fs) {

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

@@ -23,8 +23,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PickWhen = exports.Pick = void 0;
-const malloy_types_1 = require("../../../model/malloy_types");
 const fragtype_utils_1 = require("../fragtype-utils");
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
 function typeCoalesce(ev1, ev2) {
@@ -61,6 +61,7 @@ class Pick extends expression_def_1.ExpressionDef {
         return this.getExpression(fs);
     }
     apply(fs, op, expr) {
+        var _a;
         const caseValue = {
             node: 'case',
             kids: {
@@ -69,15 +70,13 @@ class Pick extends expression_def_1.ExpressionDef {
             },
         };
         let returnType;
-        let anyExpressionType = 'scalar';
-        let anyEvalSpace = 'constant';
+        const dependents = [];
         for (const choice of this.choices) {
             const whenExpr = choice.when.apply(fs, '=', expr);
             const thenExpr = choice.pick
                 ? choice.pick.getExpression(fs)
                 : expr.getExpression(fs);
-            anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(whenExpr.expressionType, thenExpr.expressionType));
-            anyEvalSpace = (0, malloy_types_1.mergeEvalSpaces)(anyEvalSpace, whenExpr.evalSpace, thenExpr.evalSpace);
+            dependents.push(whenExpr, thenExpr);
             if (returnType && !fragtype_utils_1.FT.typeEq(returnType, thenExpr, true)) {
                 return this.loggedErrorExpr('pick-type-does-not-match', {
                     pickType: thenExpr.dataType,
@@ -88,30 +87,33 @@ class Pick extends expression_def_1.ExpressionDef {
             caseValue.kids.caseWhen.push(whenExpr.value);
             caseValue.kids.caseThen.push(thenExpr.value);
         }
-        const elsePart = this.elsePick || expr;
-        const elseVal = elsePart.getExpression(fs);
-        returnType = typeCoalesce(returnType, elseVal);
-        if (!fragtype_utils_1.FT.typeEq(returnType, elseVal, true)) {
+        const elseVal = (_a = this.elsePick) === null || _a === void 0 ? void 0 : _a.getExpression(fs);
+        const exprVal = expr.getExpression(fs);
+        dependents.push(exprVal);
+        if (elseVal)
+            dependents.push(elseVal);
+        const defaultVal = elseVal !== null && elseVal !== void 0 ? elseVal : exprVal;
+        returnType = typeCoalesce(returnType, defaultVal);
+        if (!fragtype_utils_1.FT.typeEq(returnType, defaultVal, true)) {
             if (this.elsePick) {
                 return this.loggedErrorExpr('pick-else-type-does-not-match', {
-                    elseType: elseVal.dataType,
+                    elseType: defaultVal.dataType,
                     returnType: returnType.dataType,
                 });
             }
             else {
                 return this.loggedErrorExpr('pick-default-type-does-not-match', {
-                    defaultType: elseVal.dataType,
+                    defaultType: defaultVal.dataType,
                     returnType: returnType.dataType,
                 });
             }
         }
-        caseValue.kids.caseElse = elseVal.value;
-        return {
+        caseValue.kids.caseElse = defaultVal.value;
+        return (0, expr_value_1.computedExprValue)({
             dataType: returnType.dataType,
-            expressionType: (0, malloy_types_1.maxExpressionType)(anyExpressionType, elseVal.expressionType),
-            evalSpace: (0, malloy_types_1.mergeEvalSpaces)(anyEvalSpace, elseVal.evalSpace),
             value: caseValue,
-        };
+            from: dependents,
+        });
     }
     getExpression(fs) {
         const pick = {
@@ -125,6 +127,7 @@ class Pick extends expression_def_1.ExpressionDef {
             return this.loggedErrorExpr('pick-missing-else', "pick incomplete, missing 'else'");
         }
         const choiceValues = [];
+        const dependents = [];
         for (const c of this.choices) {
             if (c.pick === undefined) {
                 return this.loggedErrorExpr('pick-missing-value', 'pick with no value can only be used with apply');
@@ -133,14 +136,12 @@ class Pick extends expression_def_1.ExpressionDef {
             if (caseWhen === undefined) {
                 this.loggedErrorExpr('pick-illegal-partial', 'pick with partial when can only be used with apply');
             }
-            choiceValues.push({
-                pick: c.pick.getExpression(fs),
-                when: c.when.getExpression(fs),
-            });
+            const pick = c.pick.getExpression(fs);
+            const when = c.when.getExpression(fs);
+            choiceValues.push({ pick, when });
+            dependents.push(pick, when);
         }
         let returnType;
-        let anyExpressionType = 'scalar';
-        let anyEvalSpace = 'constant';
         for (const aChoice of choiceValues) {
             if (!fragtype_utils_1.FT.typeEq(aChoice.when, fragtype_utils_1.FT.boolT)) {
                 return this.loggedErrorExpr('pick-when-must-be-boolean', {
@@ -154,14 +155,11 @@ class Pick extends expression_def_1.ExpressionDef {
                 });
             }
             returnType = typeCoalesce(returnType, aChoice.pick);
-            anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(aChoice.pick.expressionType, aChoice.when.expressionType));
-            anyEvalSpace = (0, malloy_types_1.mergeEvalSpaces)(anyEvalSpace, aChoice.pick.evalSpace, aChoice.when.evalSpace);
             pick.kids.caseWhen.push(aChoice.when.value);
             pick.kids.caseThen.push(aChoice.pick.value);
         }
         const defVal = this.elsePick.getExpression(fs);
-        anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, defVal.expressionType);
-        anyEvalSpace = (0, malloy_types_1.mergeEvalSpaces)(anyEvalSpace, defVal.evalSpace);
+        dependents.push(defVal);
         returnType = typeCoalesce(returnType, defVal);
         if (!fragtype_utils_1.FT.typeEq(returnType, defVal, true)) {
             return this.elsePick.loggedErrorExpr('pick-else-type-does-not-match', {
@@ -170,12 +168,11 @@ class Pick extends expression_def_1.ExpressionDef {
             });
         }
         pick.kids.caseElse = defVal.value;
-        return {
+        return (0, expr_value_1.computedExprValue)({
             dataType: returnType.dataType,
-            expressionType: anyExpressionType,
             value: pick,
-            evalSpace: anyEvalSpace,
-        };
+            from: dependents,
+        });
     }
 }
 exports.Pick = Pick;

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

@@ -23,8 +23,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Range = void 0;
-const malloy_types_1 = require("../../../model/malloy_types");
 const ast_utils_1 = require("../ast-utils");
+const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 class Range extends expression_def_1.ExpressionDef {
     constructor(first, last) {
@@ -42,15 +42,14 @@ class Range extends expression_def_1.ExpressionDef {
                 const op3 = op === '=' ? '<' : '>=';
                 const fromValue = this.first.apply(fs, op1, expr);
                 const toValue = this.last.apply(fs, op3, expr);
-                return {
+                return (0, expr_value_1.computedExprValue)({
                     dataType: 'boolean',
-                    expressionType: (0, malloy_types_1.maxExpressionType)(fromValue.expressionType, toValue.expressionType),
-                    evalSpace: (0, malloy_types_1.mergeEvalSpaces)(fromValue.evalSpace, toValue.evalSpace),
                     value: {
                         node: op2,
                         kids: { left: fromValue.value, right: toValue.value },
                     },
-                };
+                    from: [fromValue, toValue],
+                });
             }
             /**
              * This is a little surprising, but is actually how you comapre a

package/dist/lang/ast/expressions/time-literal.js

@@ -25,6 +25,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiteralYear = exports.LiteralQuarter = exports.LiteralMonth = exports.LiteralWeek = exports.LiteralDay = exports.LiteralHour = exports.LiteralTimestamp = exports.TimeFormatError = void 0;
 const luxon_1 = require("luxon");
 const malloy_types_1 = require("../../../model/malloy_types");
+const expr_value_1 = require("../types/expr-value");
 const range_1 = require("./range");
 const expr_time_1 = require("./expr-time");
 const expression_def_1 = require("../types/expression-def");
@@ -80,19 +81,8 @@ class TimeLiteral extends expression_def_1.ExpressionDef {
         return timeFrag;
     }
     makeValue(val, dataType) {
-        const timeFrag = this.makeLiteral(val, dataType);
-        const expressionType = 'scalar';
-        const value = timeFrag;
-        if (this.units) {
-            return {
-                dataType,
-                expressionType,
-                value,
-                timeframe: this.units,
-                evalSpace: 'literal',
-            };
-        }
-        return { dataType, expressionType, value, evalSpace: 'literal' };
+        const value = this.makeLiteral(val, dataType);
+        return (0, expr_value_1.literalTimeResult)({ value, dataType, timeframe: this.units });
     }
     getExpression(_fs) {
         return this.makeValue(this.literalPart, this.timeType);

package/dist/lang/ast/types/expr-value.d.ts

@@ -1,3 +1,54 @@
+import { Expr, FieldValueType, TemporalFieldType, TimestampUnit } from '../../../model';
 import { ExprResult } from './expr-result';
 import { TimeResult } from './time-result';
 export type ExprValue = ExprResult | TimeResult;
+export declare function computedExprValue({ value, dataType, rawType, from, }: {
+    value: Expr;
+    dataType: FieldValueType;
+    rawType?: string;
+    from: ExprValue[];
+}): ExprValue;
+export declare function computedTimeResult({ value, dataType, rawType, from, timeframe, }: {
+    value: Expr;
+    rawType?: string;
+    dataType: TemporalFieldType;
+    timeframe?: TimestampUnit;
+    from: ExprValue[];
+}): {
+    timeframe: TimestampUnit | undefined;
+    value: Expr;
+    morphic?: {
+        [x: string]: Expr;
+    } | undefined;
+    dataType: FieldValueType;
+    expressionType: import("../../../model").ExpressionType;
+    rawType?: string | undefined;
+    evalSpace: import("../../../model").EvalSpace;
+} | {
+    timeframe: TimestampUnit | undefined;
+    dataType: TemporalFieldType;
+    value: Expr;
+    morphic?: {
+        [x: string]: Expr;
+    } | undefined;
+    expressionType: import("../../../model").ExpressionType;
+    rawType?: string | undefined;
+    evalSpace: import("../../../model").EvalSpace;
+};
+export declare function computedErrorExprValue({ dataType, rawType, from, error, }: {
+    error: string;
+    rawType?: string;
+    dataType?: FieldValueType;
+    from: ExprValue[];
+}): ExprValue;
+export declare function literalExprValue(options: {
+    value: Expr;
+    rawType?: string;
+    dataType: FieldValueType;
+}): ExprValue;
+export declare function literalTimeResult({ value, dataType, rawType, timeframe, }: {
+    value: Expr;
+    rawType?: string;
+    dataType: TemporalFieldType;
+    timeframe?: TimestampUnit;
+}): TimeResult;

package/dist/lang/ast/types/expr-value.js

@@ -22,4 +22,42 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.literalTimeResult = exports.literalExprValue = exports.computedErrorExprValue = exports.computedTimeResult = exports.computedExprValue = void 0;
+const model_1 = require("../../../model");
+function computedExprValue({ value, dataType, rawType, from, }) {
+    return {
+        value,
+        dataType,
+        rawType,
+        expressionType: (0, model_1.maxOfExpressionTypes)(from.map(e => e.expressionType)),
+        evalSpace: (0, model_1.mergeEvalSpaces)(...from.map(e => e.evalSpace)),
+    };
+}
+exports.computedExprValue = computedExprValue;
+function computedTimeResult({ value, dataType, rawType, from, timeframe, }) {
+    return { ...computedExprValue({ value, dataType, rawType, from }), timeframe };
+}
+exports.computedTimeResult = computedTimeResult;
+function computedErrorExprValue({ dataType, rawType, from, error, }) {
+    return computedExprValue({
+        dataType: dataType || 'error',
+        rawType,
+        value: { node: 'error', message: error },
+        from,
+    });
+}
+exports.computedErrorExprValue = computedErrorExprValue;
+function literalExprValue(options) {
+    // Makes literal, output, scalar because from is empty
+    return computedExprValue({ ...options, from: [] });
+}
+exports.literalExprValue = literalExprValue;
+function literalTimeResult({ value, dataType, rawType, timeframe, }) {
+    return {
+        ...computedExprValue({ value, dataType, rawType, from: [] }),
+        dataType,
+        timeframe,
+    };
+}
+exports.literalTimeResult = literalTimeResult;
 //# sourceMappingURL=expr-value.js.map

package/dist/lang/ast/types/expression-def.d.ts

@@ -67,7 +67,7 @@ export declare class ExprDuration extends ExpressionDef {
     legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
     constructor(n: ExpressionDef, timeframe: TimestampUnit);
     apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
-    getExpression(_fs: FieldSpace): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare function getMorphicValue(mv: ExprValue, mt: FieldValueType): ExprValue | undefined;
 /**

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

@@ -26,6 +26,7 @@ exports.applyBinary = exports.getMorphicValue = exports.ExprDuration = exports.E
 const malloy_types_1 = require("../../../model/malloy_types");
 const ast_utils_1 = require("../ast-utils");
 const fragtype_utils_1 = require("../fragtype-utils");
+const expr_value_1 = require("./expr-value");
 const time_utils_1 = require("../time-utils");
 const granular_result_1 = require("./granular-result");
 const malloy_element_1 = require("./malloy-element");
@@ -143,36 +144,25 @@ class ExprDuration extends ExpressionDef {
             if ((0, granular_result_1.isGranularResult)(lhs) && lhs.timeframe === this.timeframe) {
                 resultGranularity = lhs.timeframe;
             }
-            if (lhs.dataType === 'timestamp') {
-                const result = (0, time_utils_1.timeOffset)('timestamp', lhs.value, op, num.value, this.timeframe);
-                return (0, time_utils_1.mkTimeResult)({
-                    dataType: 'timestamp',
-                    expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
-                    evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, num.evalSpace),
-                    value: result,
-                }, resultGranularity);
-            }
-            if ((0, malloy_types_1.isDateUnit)(this.timeframe)) {
-                return (0, time_utils_1.mkTimeResult)({
-                    dataType: 'date',
-                    expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
-                    evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, num.evalSpace),
-                    value: (0, time_utils_1.timeOffset)('date', lhs.value, op, num.value, this.timeframe),
-                }, resultGranularity);
-            }
-            else {
+            if (lhs.dataType === 'date' && !(0, malloy_types_1.isDateUnit)(this.timeframe)) {
                 return this.loggedErrorExpr('invalid-timeframe-for-time-offset', `Cannot offset date by ${this.timeframe}`);
             }
+            return (0, expr_value_1.computedTimeResult)({
+                dataType: lhs.dataType,
+                value: (0, time_utils_1.timeOffset)(lhs.dataType, lhs.value, op, num.value, this.timeframe),
+                timeframe: resultGranularity,
+                from: [lhs, num],
+            });
         }
         return super.apply(fs, op, left);
     }
-    getExpression(_fs) {
-        return {
+    getExpression(fs) {
+        const num = this.n.getExpression(fs);
+        return (0, expr_value_1.computedErrorExprValue)({
             dataType: 'duration',
-            expressionType: 'scalar',
-            value: { node: 'error', message: 'Duration is not a value' },
-            evalSpace: 'constant',
-        };
+            error: 'Duration is not a value',
+            from: [num],
+        });
     }
 }
 exports.ExprDuration = ExprDuration;
@@ -301,12 +291,11 @@ function equality(fs, left, op, right) {
             }
         }
     }
-    return {
+    return (0, expr_value_1.computedExprValue)({
         dataType: 'boolean',
-        expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType),
-        evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, rhs.evalSpace),
         value,
-    };
+        from: [lhs, rhs],
+    });
 }
 function compare(fs, left, op, right) {
     const lhs = left.getExpression(fs);
@@ -314,7 +303,6 @@ function compare(fs, left, op, right) {
     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) {
         return { ...noCompare, dataType: 'boolean' };
@@ -323,12 +311,11 @@ function compare(fs, left, op, right) {
         node: (0, binary_operators_1.getExprNode)(op),
         kids: { left: lhs.value, right: rhs.value },
     };
-    return {
+    return (0, expr_value_1.computedExprValue)({
         dataType: 'boolean',
-        expressionType,
-        evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, rhs.evalSpace),
-        value: value,
-    };
+        value,
+        from: [lhs, rhs],
+    });
 }
 function numeric(fs, left, op, right) {
     const lhs = left.getExpression(fs);
@@ -339,7 +326,6 @@ function numeric(fs, left, op, right) {
     const noGo = unsupportError(left, lhs, right, rhs);
     if (noGo)
         return noGo;
-    const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
     if (lhs.dataType !== 'number') {
         left.logError('arithmetic-operation-type-mismatch', `The '${op}' operator requires a number, not a '${lhs.dataType}'`);
     }
@@ -347,12 +333,11 @@ function numeric(fs, left, op, right) {
         right.logError('arithmetic-operation-type-mismatch', `The '${op}' operator requires a number, not a '${rhs.dataType}'`);
     }
     else {
-        return {
+        return (0, expr_value_1.computedExprValue)({
             dataType: 'number',
-            expressionType,
             value: { node: op, kids: { left: lhs.value, right: rhs.value } },
-            evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, rhs.evalSpace),
-        };
+            from: [lhs, rhs],
+        });
     }
     return (0, ast_utils_1.errorFor)('numbers required');
 }
@@ -428,12 +413,11 @@ function applyBinary(fs, left, op, right) {
                 node: op,
                 kids: { left: num.value, right: denom.value },
             };
-            return {
+            return (0, expr_value_1.computedExprValue)({
                 dataType: 'number',
-                expressionType: (0, malloy_types_1.maxExpressionType)(num.expressionType, denom.expressionType),
-                evalSpace: (0, malloy_types_1.mergeEvalSpaces)(num.evalSpace, denom.evalSpace),
                 value: divmod,
-            };
+                from: [num, denom],
+            });
         }
         return (0, ast_utils_1.errorFor)('divide type mismatch');
     }
@@ -442,24 +426,22 @@ function applyBinary(fs, left, op, right) {
 exports.applyBinary = applyBinary;
 function errorCascade(dataType, ...es) {
     if (es.some(e => e.dataType === 'error')) {
-        return {
+        return (0, expr_value_1.computedExprValue)({
             dataType,
-            expressionType: (0, malloy_types_1.maxOfExpressionTypes)(es.map(e => e.expressionType)),
             value: { node: 'error', message: 'cascading error' },
-            evalSpace: (0, malloy_types_1.mergeEvalSpaces)(...es.map(e => e.evalSpace)),
-        };
+            from: es,
+        });
     }
 }
 /**
  * Return an error if a binary operation includes unsupported types.
  */
 function unsupportError(l, lhs, r, rhs) {
-    const ret = {
+    const ret = (0, expr_value_1.computedExprValue)({
         dataType: lhs.dataType,
-        expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType),
         value: { node: 'error', message: 'sql-native unsupported' },
-        evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, rhs.evalSpace),
-    };
+        from: [lhs, rhs],
+    });
     if (lhs.dataType === 'sql native') {
         l.logError('sql-native-not-allowed-in-expression', { rawType: lhs.rawType });
         ret.dataType = rhs.dataType;

package/dist/model/malloy_types.js

@@ -337,7 +337,10 @@ function isLiteral(evalSpace) {
 }
 exports.isLiteral = isLiteral;
 function mergeEvalSpaces(...evalSpaces) {
-    if (evalSpaces.every(e => e === 'constant' || e === 'literal')) {
+    if (evalSpaces.length <= 1 && evalSpaces.every(e => e === 'literal')) {
+        return 'literal';
+    }
+    else if (evalSpaces.every(e => e === 'constant' || e === 'literal')) {
         return 'constant';
     }
     else if (evalSpaces.every(e => e === 'output' || e === 'constant' || e === 'literal')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.203-dev241023171450",
+  "version": "0.0.203-dev241024163815",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",