@malloydata/malloy 0.0.427 → 0.0.428

package/dist/lang/ast/expressions/apply.d.ts

@@ -7,5 +7,5 @@ export declare class Apply extends ExprCompare {
     readonly right: ExpressionDef;
     elementType: string;
     constructor(left: ExpressionDef, right: ExpressionDef);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -15,7 +15,7 @@ class Apply extends expr_compare_1.ExprCompare {
         this.right = right;
         this.elementType = 'apply';
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         let right = this.right;
         if (!this.right.granular()) {
             const rhs = this.right.requestExpression(fs);
@@ -27,7 +27,7 @@ class Apply extends expr_compare_1.ExprCompare {
         if (right instanceof expr_granular_time_1.ExprGranularTime) {
             return right.toRange(fs).apply(fs, this.op, this.left);
         }
-        return super.getExpression(fs);
+        return super.computeExpression(fs);
     }
 }
 exports.Apply = Apply;

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

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

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

@@ -52,7 +52,7 @@ class BinaryBoolean extends expression_def_1.ExpressionDef {
         this.elementType = 'abstract boolean binary';
         this.legalChildTypes = [TDU.boolT];
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const left = this.left.getExpression(fs);
         const right = this.right.getExpression(fs);
         if (this.typeCheck(this.left, left) && this.typeCheck(this.right, right)) {

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

@@ -8,5 +8,5 @@ export declare abstract class BinaryNumeric<opType extends ArithmeticMalloyOpera
     readonly right: ExpressionDef;
     elementType: string;
     constructor(left: ExpressionDef, op: opType, right: ExpressionDef);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -49,7 +49,7 @@ class BinaryNumeric extends expression_def_1.ExpressionDef {
         this.elementType = 'numeric binary abstract';
         this.legalChildTypes = [TDU.numberT];
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         return this.right.apply(fs, this.op, this.left);
     }
 }

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

@@ -5,6 +5,6 @@ export declare class Boolean extends ExpressionDef {
     readonly value: 'true' | 'false';
     elementType: string;
     constructor(value: 'true' | 'false');
-    getExpression(): ExprValue;
+    protected computeExpression(): ExprValue;
     getStableLiteral(): Malloy.LiteralValue;
 }

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

@@ -46,7 +46,7 @@ class Boolean extends expression_def_1.ExpressionDef {
         this.value = value;
         this.elementType = 'boolean literal';
     }
-    getExpression() {
+    computeExpression() {
         return { ...TDU.boolT, value: { node: this.value } };
     }
     getStableLiteral() {

package/dist/lang/ast/expressions/case.d.ts

@@ -8,7 +8,7 @@ export declare class Case extends ExpressionDef {
     readonly elseValue?: ExpressionDef | undefined;
     elementType: string;
     constructor(value: ExpressionDef | undefined, choices: CaseWhen[], elseValue?: ExpressionDef | undefined);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }
 export declare class CaseWhen extends MalloyElement {
     readonly when: ExpressionDef;

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

@@ -56,7 +56,7 @@ class Case extends expression_def_1.ExpressionDef {
         this.elementType = 'case';
         this.has({ elseValue, value });
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const resultExpr = {
             node: 'case',
             kids: {

package/dist/lang/ast/expressions/constant-expression.d.ts

@@ -17,13 +17,14 @@ export declare class ConstantFieldSpace implements FieldSpace {
     connectionName(): string;
     isQueryFieldSpace(): this is QueryFieldSpace;
     accessProtectionLevel(): AccessModifierLabel;
+    generation(): number;
 }
 export declare class ConstantExpression extends ExpressionDef {
     readonly expr: ExpressionDef;
     elementType: string;
     private cfs?;
     constructor(expr: ExpressionDef);
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
     private get constantFs();
     constantValue(): ExprValue;
     apply(fs: FieldSpace, op: BinaryMalloyOperator, expr: ExpressionDef): ExprValue;

package/dist/lang/ast/expressions/constant-expression.js

@@ -6,6 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstantExpression = exports.ConstantFieldSpace = void 0;
 const expression_def_1 = require("../types/expression-def");
+const field_space_1 = require("../types/field-space");
 class ConstantFieldSpace {
     constructor() {
         this.type = 'fieldSpace';
@@ -46,6 +47,10 @@ class ConstantFieldSpace {
     accessProtectionLevel() {
         return 'private';
     }
+    // Binds nothing at all -- every lookup is an error.
+    generation() {
+        return (0, field_space_1.currentGeneration)();
+    }
 }
 exports.ConstantFieldSpace = ConstantFieldSpace;
 class ConstantExpression extends expression_def_1.ExpressionDef {
@@ -54,7 +59,7 @@ class ConstantExpression extends expression_def_1.ExpressionDef {
         this.expr = expr;
         this.elementType = 'constantExpression';
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return this.constantValue();
     }
     get constantFs() {

package/dist/lang/ast/expressions/expr-aggregate-function.d.ts

@@ -13,7 +13,7 @@ export declare abstract class ExprAggregateFunction extends ExpressionDef {
     legalChildTypes: import("../../..").TypeDesc[];
     constructor(func: AggregateFunctionType, expr?: ExpressionDef, explicitSource?: boolean);
     abstract returns(fromExpr: ExprValue): ExprValue;
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     isSymmetricFunction(): boolean;
     getJoinUsage(fs: FieldSpace): JoinPath[];
 }

package/dist/lang/ast/expressions/expr-aggregate-function.js

@@ -59,7 +59,7 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
             this.has({ expr: expr });
         }
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         var _a, _b, _c;
         // It is never useful to use output fields in an aggregate expression
         // so we don't even allow them to be referenced at all
@@ -162,15 +162,22 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
             if (structPath && structPath.length > 0) {
                 f.structPath = structPath;
             }
+            // `returns` is identity for sum and a shallow copy for avg, so
+            // returnExpr shares the operand's refSummary -- build a new one rather
+            // than writing into it.
             const returnExpr = this.returns(exprVal);
-            if (!this.isSymmetricFunction()) {
-                (0, malloy_types_1.setFieldUsage)(returnExpr, [
-                    ...(0, malloy_types_1.fieldUsageFrom)(returnExpr.refSummary),
-                    { path: structPath || [], uniqueKeyRequirement: { isCount: false } },
-                ]);
-            }
+            const refSummary = this.isSymmetricFunction()
+                ? returnExpr.refSummary
+                : {
+                    ...returnExpr.refSummary,
+                    fieldUsage: [
+                        ...(0, malloy_types_1.fieldUsageFrom)(returnExpr.refSummary),
+                        { path: structPath || [], uniqueKeyRequirement: { isCount: false } },
+                    ],
+                };
             return {
                 ...returnExpr,
+                refSummary,
                 expressionType: 'aggregate',
                 value: f,
                 evalSpace: 'output',

package/dist/lang/ast/expressions/expr-alternation-tree.d.ts

@@ -12,6 +12,6 @@ export declare class ExprAlternationTree extends ExpressionDef {
     equalityList(): ExpressionDef[];
     apply(fs: FieldSpace, applyOp: BinaryMalloyOperator, expr: ExpressionDef, warnOnComplexTree: boolean): ExprValue;
     requestExpression(_fs: FieldSpace): ExprValue | undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
     atNodeType(): ATNodeType;
 }

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

@@ -86,7 +86,7 @@ class ExprAlternationTree extends expression_def_1.ExpressionDef {
     requestExpression(_fs) {
         return undefined;
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return this.loggedErrorExpr('alternation-as-value', 'Alternation tree has no value');
     }
     atNodeType() {

package/dist/lang/ast/expressions/expr-array-literal.d.ts

@@ -5,5 +5,5 @@ export declare class ArrayLiteral extends ExpressionDef {
     readonly elements: ExpressionDef[];
     elementType: string;
     constructor(elements: ExpressionDef[]);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -49,7 +49,7 @@ class ArrayLiteral extends expression_def_1.ExpressionDef {
         this.elementType = 'array literal';
         this.has({ elements });
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const values = [];
         const fromValues = [];
         let firstValue = undefined;

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

@@ -12,5 +12,5 @@ export declare class ExprCast extends ExpressionDef {
     constructor(expr: ExpressionDef, castType: AtomicTypeDef | {
         raw: string;
     }, safe?: boolean);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -18,7 +18,7 @@ class ExprCast extends expression_def_1.ExpressionDef {
     }
     // TODO: Validate senseless casts (e.g. scalar to record) at translate time
     // for better error messages than what the dialect/database produces.
-    getExpression(fs) {
+    computeExpression(fs) {
         const expr = this.expr.getExpression(fs);
         let dataType = { type: 'error' };
         if ('type' in this.castType) {

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

@@ -7,5 +7,5 @@ export declare class ExprCoalesce extends ExpressionDef {
     elementType: string;
     legalChildTypes: import("../../..").TypeDesc[];
     constructor(expr: ExpressionDef, altExpr: ExpressionDef);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -50,7 +50,7 @@ class ExprCoalesce extends expression_def_1.ExpressionDef {
         this.elementType = 'coalesce expression';
         this.legalChildTypes = TDU.anyAtomicT;
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const maybeNull = this.expr.getExpression(fs);
         const whenNull = this.altExpr.getExpression(fs);
         if (maybeNull.type === 'null') {

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

@@ -7,7 +7,7 @@ import type { GivenReference } from './expr-given';
 export declare class ExprCompare extends BinaryBoolean<CompareMalloyOperator> {
     elementType: string;
     constructor(left: ExpressionDef, op: CompareMalloyOperator, right: ExpressionDef);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }
 /**
  * The parser makes equality nodes, an application of ?
@@ -18,7 +18,7 @@ export declare class ExprCompare extends BinaryBoolean<CompareMalloyOperator> {
 export declare class ExprEquality extends ExprCompare {
     elementType: string;
     constructor(left: ExpressionDef, op: EqualityMalloyOperator, right: ExpressionDef);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
 }
 export declare class ExprLegacyIn extends ExpressionDef {
@@ -27,7 +27,7 @@ export declare class ExprLegacyIn extends ExpressionDef {
     readonly choices: ExpressionDef[];
     elementType: string;
     constructor(expr: ExpressionDef, notIn: boolean, choices: ExpressionDef[]);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }
 /**
  * `expr in $ARRAY_GIVEN` — runtime test of a basic-typed expression
@@ -41,5 +41,5 @@ export declare class ExprInGiven extends ExpressionDef {
     readonly givenRef: GivenReference;
     elementType: string;
     constructor(expr: ExpressionDef, notIn: boolean, givenRef: GivenReference);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -61,7 +61,7 @@ class ExprCompare extends binary_boolean_1.BinaryBoolean {
         this.elementType = 'a<=>b';
         this.legalChildTypes = compareTypes[op];
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         return this.right.apply(fs, this.op, this.left);
     }
 }
@@ -77,7 +77,7 @@ class ExprEquality extends ExprCompare {
         super(left, op, right);
         this.elementType = 'a~=b';
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         return this.right.apply(fs, this.op, this.left, true);
     }
     apply(fs, op, left) {
@@ -94,7 +94,7 @@ class ExprLegacyIn extends expression_def_1.ExpressionDef {
         this.elementType = 'in';
         this.has({ expr, choices });
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const lookFor = this.expr.getExpression(fs);
         const oneOf = this.choices.map(e => e.getExpression(fs));
         return (0, expr_value_2.computedExprValue)({
@@ -124,7 +124,7 @@ class ExprInGiven extends expression_def_1.ExpressionDef {
         this.elementType = 'inGiven';
         this.has({ expr, givenRef });
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const lookFor = this.expr.getExpression(fs);
         const givenVal = this.givenRef.getExpression(fs);
         // `in` is logically a boolean — every error path returns a

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

@@ -8,5 +8,5 @@ export declare class ExprCount extends ExprAggregateFunction {
     constructor(source?: FieldReference | undefined);
     defaultFieldName(): string | undefined;
     returns(ev: ExprValue): ExprValue;
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
 }

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

@@ -29,7 +29,7 @@ class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
             refSummary: ev.refSummary,
         };
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         const ret = {
             node: 'aggregate',
             function: 'count',

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

@@ -4,5 +4,5 @@ export declare class ExprFilterExpression extends ExpressionDef {
     readonly filterText: string;
     elementType: string;
     constructor(filterText: string);
-    getExpression(): ExprValue;
+    protected computeExpression(): ExprValue;
 }

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

@@ -12,7 +12,7 @@ class ExprFilterExpression extends expression_def_1.ExpressionDef {
         this.filterText = filterText;
         this.elementType = 'filter expression literal';
     }
-    getExpression() {
+    computeExpression() {
         return {
             type: 'filter expression',
             value: { node: 'filterLiteral', filterSrc: this.filterText },

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

@@ -17,7 +17,7 @@ export declare class ExprFunc extends ExpressionDef {
     canSupportPartitionBy(): boolean;
     canSupportOrderBy(): boolean;
     canSupportLimit(): boolean;
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     private findFunctionDef;
     getPropsExpression(fs: FieldSpace, props?: {
         partitionBys?: PartitionBy[];

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

@@ -79,7 +79,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
     canSupportLimit() {
         return true;
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         if (this.isRaw && this.isRestricted()) {
             const typeStr = this.explicitType
                 ? (0, utils_1.typeDefToString)(this.explicitType)

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

@@ -14,5 +14,5 @@ export declare class GivenReference extends ExpressionDef {
     readonly name: string;
     elementType: string;
     constructor(name: string);
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
 }

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

@@ -23,7 +23,7 @@ class GivenReference extends expression_def_1.ExpressionDef {
         this.name = name;
         this.elementType = 'givenReference';
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         var _a;
         const doc = this.document();
         const entry = (_a = doc === null || doc === void 0 ? void 0 : doc.getEntry(this.name)) === null || _a === void 0 ? void 0 : _a.entry;

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

@@ -20,6 +20,6 @@ export declare class ExprGranularTime extends ExpressionDef {
     constructor(expr: ExpressionDef, units: TimestampUnit, truncate: boolean);
     granular(): boolean;
     drillExpression(): Malloy.Expression | undefined;
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     toRange(fs: FieldSpace): Range;
 }

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

@@ -77,7 +77,7 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
             truncation: this.units,
         };
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         var _a;
         const timeframe = this.units;
         const exprVal = this.expr.getExpression(fs);

package/dist/lang/ast/expressions/expr-id-reference.d.ts

@@ -9,5 +9,5 @@ export declare class ExprIdReference extends ExpressionDef {
     constructor(fieldReference: FieldReference);
     get refString(): string;
     drillExpression(): Malloy.Expression | undefined;
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -24,7 +24,7 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
             path: this.fieldReference.path.slice(0, -1),
         };
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const def = this.fieldReference.getField(fs);
         if (def.found) {
             // TODO Currently the join usage is always equivalent to the reference path here;

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

@@ -5,5 +5,5 @@ export declare class ExprMinus extends ExpressionDef {
     readonly expr: ExpressionDef;
     elementType: string;
     constructor(expr: ExpressionDef);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -48,7 +48,7 @@ class ExprMinus extends expression_def_1.ExpressionDef {
         this.elementType = 'unary minus';
         this.legalChildTypes = [TDU.numberT];
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const expr = this.expr.getExpression(fs);
         if (TDU.typeIn(expr, this.legalChildTypes)) {
             return {

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

@@ -6,5 +6,5 @@ export declare class ExprNot extends Unary {
     elementType: string;
     legalChildTypes: import("../../..").TypeDesc[];
     constructor(expr: ExpressionDef);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -46,7 +46,7 @@ class ExprNot extends unary_1.Unary {
         this.elementType = 'not';
         this.legalChildTypes = [TDU.boolT, TDU.nullT];
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         var _a;
         const notThis = this.expr.getExpression(fs);
         if (((_a = fs.dialectObj()) === null || _a === void 0 ? void 0 : _a.booleanType) !== 'supported') {

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

@@ -3,5 +3,5 @@ import type { FieldSpace } from '../types/field-space';
 import { ExpressionDef } from '../types/expression-def';
 export declare class ExprNow extends ExpressionDef {
     elementType: string;
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
 }

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

@@ -11,7 +11,7 @@ class ExprNow extends expression_def_1.ExpressionDef {
         super(...arguments);
         this.elementType = 'timestamp';
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return {
             type: 'timestamp',
             expressionType: 'scalar',

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

@@ -3,7 +3,7 @@ import type { ExprValue } from '../types/expr-value';
 import { ATNodeType, ExpressionDef } from '../types/expression-def';
 export declare class ExprNULL extends ExpressionDef {
     elementType: string;
-    getExpression(): ExprValue;
+    protected computeExpression(): ExprValue;
     apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
 }
 export declare class PartialIsNull extends ExpressionDef {
@@ -12,7 +12,7 @@ export declare class PartialIsNull extends ExpressionDef {
     constructor(op: '=' | '!=');
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): ExprValue | undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
     atNodeType(): ATNodeType;
 }
 export declare class ExprIsNull extends ExpressionDef {
@@ -20,5 +20,5 @@ export declare class ExprIsNull extends ExpressionDef {
     readonly op: '=' | '!=';
     elementType: string;
     constructor(expr: ExpressionDef, op: '=' | '!=');
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -8,20 +8,25 @@ exports.ExprIsNull = exports.PartialIsNull = exports.ExprNULL = void 0;
 const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 function doIsNull(fs, op, expr) {
+    // Build a new value rather than retyping the operand's in place: what
+    // getExpression hands back is shared, and the operand is usually asked for
+    // its value again after this.
     const nullCmp = expr.getExpression(fs);
-    nullCmp.type = 'boolean';
-    nullCmp.value = {
-        node: op === '=' ? 'is-null' : 'is-not-null',
-        e: nullCmp.value,
-    };
-    return nullCmp;
+    return (0, expr_value_1.computedExprValue)({
+        dataType: { type: 'boolean' },
+        value: {
+            node: op === '=' ? 'is-null' : 'is-not-null',
+            e: nullCmp.value,
+        },
+        from: [nullCmp],
+    });
 }
 class ExprNULL extends expression_def_1.ExpressionDef {
     constructor() {
         super(...arguments);
         this.elementType = 'NULL';
     }
-    getExpression() {
+    computeExpression() {
         return (0, expr_value_1.literalExprValue)({
             dataType: { type: 'null' },
             value: { node: 'null' },
@@ -47,7 +52,7 @@ class PartialIsNull extends expression_def_1.ExpressionDef {
     requestExpression(_fs) {
         return undefined;
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return this.loggedErrorExpr('partial-as-value', 'Partial null check does not have a value');
     }
     atNodeType() {
@@ -63,7 +68,7 @@ class ExprIsNull extends expression_def_1.ExpressionDef {
         this.elementType = 'is null';
         this.has({ expr });
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         return doIsNull(fs, this.op, this.expr);
     }
 }

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

@@ -6,7 +6,7 @@ export declare class ExprNumber extends ExpressionDef {
     readonly n: string;
     elementType: string;
     constructor(n: string);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     /**
      * Default number type when no dialect is available.
      * Integers default to bigint for safety, floats to float.

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

@@ -13,7 +13,7 @@ class ExprNumber extends expression_def_1.ExpressionDef {
         this.n = n;
         this.elementType = 'numeric literal';
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         var _a;
         const dialect = fs.dialectObj();
         const dataType = (_a = dialect === null || dialect === void 0 ? void 0 : dialect.literalNumberType(this.n)) !== null && _a !== void 0 ? _a : this.defaultNumberType();

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

@@ -7,7 +7,7 @@ export declare class ExprParens extends ExpressionDef {
     elementType: string;
     constructor(expr: ExpressionDef);
     requestExpression(fs: FieldSpace): ExprValue | undefined;
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef, doWarn: boolean): ExprValue;
     atNodeType(): ATNodeType;
     atExpr(): ExpressionDef;