@malloydata/malloy 0.0.427 → 0.0.428

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

@@ -15,15 +15,18 @@ class ExprParens extends expression_def_1.ExpressionDef {
     requestExpression(fs) {
         return this.expr.requestExpression(fs);
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const subExpr = this.expr.getExpression(fs);
         return { ...subExpr, value: { node: '()', e: subExpr.value } };
     }
     apply(fs, op, left, doWarn) {
         if (this.expr.atNodeType() === expression_def_1.ATNodeType.Or) {
+            // Parens are invisible to `?`/`=`, so hand the tree the operator and
+            // doWarn, which decides whether an un-collapsible `|` list is worth a
+            // warning. The base ignores doWarn, which is why it is not passed on.
             return this.expr.apply(fs, op, left, doWarn);
         }
-        return (0, expression_def_1.applyBinary)(fs, left, op, this);
+        return super.apply(fs, op, left);
     }
     atNodeType() {
         return this.expr.atNodeType();

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

@@ -10,7 +10,7 @@ export declare class ExprProps extends ExpressionDef {
     legalChildTypes: import("../../..").TypeDesc[];
     constructor(expr: ExpressionDef, statements: FieldPropStatement[]);
     private getFilteredExpression;
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     getGroupedBys(fs: FieldSpace, expr: ExprValue, groupedBys: GroupedBy[]): {
         requiresGroupBy: import("../../../model").RequiredGroupBy[] | undefined;
         type: "string";

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

@@ -87,7 +87,7 @@ class ExprProps extends expression_def_1.ExpressionDef {
         }
         return expr;
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const partitionBys = [];
         let limit;
         const orderBys = [];

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

@@ -19,7 +19,7 @@ export declare class RecordLiteral extends ExpressionDef {
     readonly pairs: RecordElement[];
     elementType: string;
     constructor(pairs: RecordElement[]);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     getRecord(fs: FieldSpace, kidNames: string[]): ExprValue;
     getNextElement(fs: FieldSpace, headValue: ExprValue): ExprValue;
 }

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

@@ -70,7 +70,7 @@ class RecordLiteral extends expression_def_1.ExpressionDef {
         this.elementType = 'record literal';
         this.has({ pairs });
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         return this.getRecord(fs, []);
     }
     getRecord(fs, kidNames) {

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

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

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

@@ -13,7 +13,7 @@ class ExprRegEx extends expression_def_1.ExpressionDef {
         this.regex = regex;
         this.elementType = 'regular expression literal';
     }
-    getExpression() {
+    computeExpression() {
         return (0, expr_value_1.literalExprValue)({
             dataType: { type: 'regular expression' },
             value: { node: 'regexpLiteral', literal: this.regex },

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

@@ -6,6 +6,6 @@ export declare class ExprString extends ExpressionDef {
     elementType: string;
     value: string;
     constructor(src: string);
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
     getStableLiteral(): Malloy.LiteralValue;
 }

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

@@ -13,7 +13,7 @@ class ExprString extends expression_def_1.ExpressionDef {
         this.elementType = 'string literal';
         this.value = src;
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return (0, expr_value_1.literalExprValue)({
             dataType: { type: 'string' },
             value: { node: 'stringLiteral', literal: this.value },

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

@@ -9,5 +9,5 @@ export declare class ExprTimeExtract extends ExpressionDef {
     static pluralMap: Record<string, ExtractUnit>;
     static extractor(funcName: string): ExtractUnit | undefined;
     constructor(extractText: string, args: ExpressionDef[]);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -25,7 +25,7 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
         this.args = args;
         this.elementType = 'timeExtract';
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const extractTo = ExprTimeExtract.extractor(this.extractText);
         if (extractTo) {
             if (this.args.length !== 1) {

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

@@ -6,6 +6,6 @@ export declare class ExprTime extends ExpressionDef {
     elementType: string;
     readonly translationValue: ExprValue;
     constructor(timeType: TemporalFieldType, value: Expr, from?: ExprValue[]);
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
     static fromValue(timeType: TemporalFieldType, expr: ExprValue): ExprTime;
 }

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

@@ -19,7 +19,7 @@ class ExprTime extends expression_def_1.ExpressionDef {
             from: from !== null && from !== void 0 ? from : [],
         });
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return this.translationValue;
     }
     static fromValue(timeType, expr) {

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

@@ -8,5 +8,5 @@ export declare class ExprUngroup extends ExpressionDef {
     legalChildTypes: import("../../..").TypeDesc[];
     elementType: string;
     constructor(control: 'all' | 'exclude', expr: ExpressionDef, fields: FieldName[]);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -52,7 +52,7 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
         this.legalChildTypes = TDU.anyAtomicT;
         this.elementType = 'ungroup';
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         var _a;
         const exprVal = this.expr.getExpression(fs);
         if (!(0, malloy_types_1.expressionIsAggregate)(exprVal.expressionType)) {

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

@@ -12,5 +12,5 @@ export declare class ForRange extends ExpressionDef {
     constructor(from: ExpressionDef, duration: ExpressionDef, timeframe: Timeframe);
     apply(fs: FieldSpace, op: BinaryMalloyOperator, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
 }

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

@@ -110,7 +110,7 @@ class ForRange extends expression_def_1.ExpressionDef {
     requestExpression(_fs) {
         return undefined;
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return this.loggedErrorExpr('range-as-value', 'A Range is not a value');
     }
 }

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

@@ -10,6 +10,6 @@ export declare class PartialCompare extends ExpressionDef {
     granular(): boolean;
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): ExprValue | undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
     atNodeType(): ATNodeType;
 }

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

@@ -22,7 +22,7 @@ class PartialCompare extends expression_def_1.ExpressionDef {
     requestExpression(_fs) {
         return undefined;
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return this.loggedErrorExpr('partial-as-value', 'Partial comparison does not have a value');
     }
     atNodeType() {

package/dist/lang/ast/expressions/pick-when.d.ts

@@ -9,7 +9,7 @@ export declare class Pick extends ExpressionDef {
     constructor(choices: PickWhen[], elsePick?: ExpressionDef | undefined);
     requestExpression(fs: FieldSpace): ExprValue | undefined;
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }
 export declare class PickWhen extends MalloyElement {
     readonly pick: ExpressionDef | undefined;

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

@@ -138,7 +138,7 @@ class Pick extends expression_def_1.ExpressionDef {
             from: dependents,
         });
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const pick = {
             node: 'case',
             kids: {

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

@@ -9,5 +9,5 @@ export declare class Range extends ExpressionDef {
     constructor(first: ExpressionDef, last: ExpressionDef);
     apply(fs: FieldSpace, op: BinaryMalloyOperator, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
 }

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

@@ -56,7 +56,7 @@ class Range extends expression_def_1.ExpressionDef {
     requestExpression(_fs) {
         return undefined;
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         this.logError('range-as-value', 'A Range is not a value');
         return (0, ast_utils_1.errorFor)('a range is not a value');
     }

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

@@ -31,7 +31,7 @@ export declare abstract class TimeLiteral extends ExpressionDef {
     }) | (import("../../../model").TimestamptzTypeDef & import("../../../model").TypeInfo & import("../types/expr-result").WithValue & {
         timeframe?: TimestampUnit;
     });
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     getNext(fs: FieldSpace): ExprValue | undefined;
     granular(): boolean;
 }
@@ -62,7 +62,7 @@ export declare class LiteralHour extends GranularLiteral {
  */
 declare abstract class DateBasedLiteral extends GranularLiteral {
     constructor(tm: TimeText, units: TimestampUnit, nextLit: string);
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
     getNext(fs: FieldSpace): ExprValue | undefined;
 }
 export declare class LiteralDay extends DateBasedLiteral {

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

@@ -107,7 +107,7 @@ class TimeLiteral extends expression_def_1.ExpressionDef {
             timeframe: this.units,
         });
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         return this.makeValue(fs, this.literalPart, this.timeType);
     }
     getNext(fs) {
@@ -249,7 +249,7 @@ class DateBasedLiteral extends GranularLiteral {
     constructor(tm, units, nextLit) {
         super(tm, units, 'date', nextLit);
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const dateValue = this.makeValue(fs, this.literalPart, 'date');
         const timestamp = this.makeLiteral(fs, `${this.literalPart} 00:00:00`, 'timestamp', this.units);
         return { ...dateValue, morphic: { timestamp }, evalSpace: 'literal' };

package/dist/lang/ast/field-space/parameter-space.d.ts

@@ -18,4 +18,5 @@ export declare class ParameterSpace implements FieldSpace {
     dialectObj(): Dialect | undefined;
     isQueryFieldSpace(): this is QueryFieldSpace;
     accessProtectionLevel(): AccessModifierLabel;
+    generation(): number;
 }

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

@@ -5,6 +5,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParameterSpace = void 0;
+const field_space_1 = require("../types/field-space");
 const space_param_1 = require("../types/space-param");
 class ParameterSpace {
     constructor(parameters) {
@@ -80,6 +81,11 @@ class ParameterSpace {
     accessProtectionLevel() {
         return 'private';
     }
+    // Bindings are fixed by the constructor and never change, so this space
+    // contributes no invalidation of its own.
+    generation() {
+        return (0, field_space_1.currentGeneration)();
+    }
 }
 exports.ParameterSpace = ParameterSpace;
 //# sourceMappingURL=parameter-space.js.map

package/dist/lang/ast/field-space/passthrough-space.d.ts

@@ -19,4 +19,5 @@ export declare class PassthroughSpace implements FieldSpace {
     inputSpace(): import("..").SourceFieldSpace;
     accessProtectionLevel(): AccessModifierLabel;
     connectionName(): string;
+    generation(): number;
 }

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

@@ -52,6 +52,9 @@ class PassthroughSpace {
     connectionName() {
         return this.realFS.connectionName();
     }
+    generation() {
+        return this.realFS.generation();
+    }
 }
 exports.PassthroughSpace = PassthroughSpace;
 //# sourceMappingURL=passthrough-space.js.map

package/dist/lang/ast/field-space/static-space.d.ts

@@ -18,6 +18,14 @@ export declare class StaticSpace implements FieldSpace {
     defToSpaceField(from: FieldDef): SpaceField;
     private get map();
     accessProtectionLevel(): AccessModifierLabel;
+    /**
+     * StaticSpace itself never rebinds anything after construction, but
+     * DynamicSpace extends it and the three mutators below are the whole
+     * write surface for both -- `memoMap` is private, and every caller
+     * goes through these. That is what makes "every rebinding bumps the
+     * generation" checkable rather than a hope.
+     */
+    generation(): number;
     protected dropEntries(): void;
     protected dropEntry(name: string): void;
     entry(name: string): SpaceEntry | undefined;

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

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StaticSourceSpace = exports.StructSpaceField = exports.StaticSpace = void 0;
 const dialect_map_1 = require("../../../dialect/dialect_map");
 const malloy_types_1 = require("../../../model/malloy_types");
+const field_space_1 = require("../types/field-space");
 const space_param_1 = require("../types/space-param");
 const space_field_1 = require("../types/space-field");
 const struct_space_field_base_1 = require("./struct-space-field-base");
@@ -64,10 +65,22 @@ class StaticSpace {
     accessProtectionLevel() {
         return 'internal';
     }
+    /**
+     * StaticSpace itself never rebinds anything after construction, but
+     * DynamicSpace extends it and the three mutators below are the whole
+     * write surface for both -- `memoMap` is private, and every caller
+     * goes through these. That is what makes "every rebinding bumps the
+     * generation" checkable rather than a hope.
+     */
+    generation() {
+        return (0, field_space_1.currentGeneration)();
+    }
     dropEntries() {
+        (0, field_space_1.noteRebinding)();
         this.memoMap = new Map();
     }
     dropEntry(name) {
+        (0, field_space_1.noteRebinding)();
         this.map.delete(name);
     }
     // TODO this was protected
@@ -75,6 +88,7 @@ class StaticSpace {
         return this.map.get(name);
     }
     setEntry(name, value) {
+        (0, field_space_1.noteRebinding)();
         this.map.set(name, value);
     }
     entries() {

package/dist/lang/ast/query-builders/index-builder.js

@@ -94,7 +94,7 @@ class IndexBuilder {
             path: [],
             uniqueKeyRequirement: { isCount: true },
         });
-        (0, malloy_types_1.setFieldUsage)(indexSegment, fieldUsage);
+        indexSegment.refSummary = { ...indexSegment.refSummary, fieldUsage };
         return indexSegment;
     }
 }

package/dist/lang/ast/query-properties/drill.d.ts

@@ -13,7 +13,7 @@ export declare class DrillField extends ExpressionDef {
     readonly typeDesc: TypeDesc;
     elementType: string;
     constructor(expr: Expr, typeDesc: TypeDesc);
-    getExpression(_fs: FieldSpace): ExprValue;
+    protected computeExpression(_fs: FieldSpace): ExprValue;
 }
 export declare class Drill extends Filter implements QueryPropertyInterface {
     elementType: string;

package/dist/lang/ast/query-properties/drill.js

@@ -25,7 +25,7 @@ class DrillField extends expression_def_1.ExpressionDef {
         this.typeDesc = typeDesc;
         this.elementType = 'drillField';
     }
-    getExpression(_fs) {
+    computeExpression(_fs) {
         return {
             value: this.expr,
             ...this.typeDesc,

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

@@ -13,20 +13,53 @@ export declare enum ATNodeType {
 }
 /**
  * Root node for any element in an expression. These essentially
- * create a sub-tree in the larger AST. Expression nodes know
- * how to write themselves as SQL (or rather, generate the
- * template for SQL required by the query writer)
+ * create a sub-tree in the larger AST. An ExpressionDef, when
+ * given a FieldSpace, can be evaluated to produce an ExprValue
+ * which is the IR for an Expr along with its type and other metadata.
  */
 export declare abstract class ExpressionDef extends MalloyElement {
     abstract elementType: string;
     granular(): boolean;
     /**
-     * Returns the "translation" or template for SQL generation. When asking
+     * Returns the "translation" or Expr tree for SQL generation. When asking
      * for a translation you may pass the types you can accept, allowing
      * the translation code a chance to convert to match your expectations
      * @param space Namespace for looking up field references
+     *
+     * THE RETURNED ExprValue IS SHARED -- TREAT IT AS IMMUTABLE. Asking twice
+     * yields the same object, so to derive a value from one, build a new one:
+     * `{...operand, type: 'boolean'}` or `computedExprValue({…, from: [operand]})`.
+     *
+     * DO NOT OVERRIDE THIS. Nodes implement `computeExpression`; an override
+     * here bypasses the memo, which for `+`/`-` chains is the difference
+     * between linear and exponential compile time.
      */
-    abstract getExpression(fs: FieldSpace): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
+    /**
+     * The last value this node computed, and what it was computed against.
+     * Three states, distinguished by memoGen:
+     *
+     *   memoFs undefined              -- nothing computed, or abandoned
+     *   memoFs set, memoGen undefined -- computing right now, and only that,
+     *                                    since abandoning clears memoFs
+     *   memoFs set, memoGen set       -- memoValue is that computation's result
+     *
+     * Both halves of the stamp are needed: a node can be evaluated under more
+     * than one field space -- ConstantExpression evaluates its child against a
+     * ConstantFieldSpace whatever it was handed -- and a field space can rebind
+     * a name under us.
+     *
+     * One slot, not a map. A node which alternates between two field spaces
+     * simply misses and recomputes, which costs time and never correctness.
+     */
+    private memoFs?;
+    private memoGen?;
+    private memoValue?;
+    /**
+     * Evaluate this node. Implemented by every expression node; called only
+     * by `getExpression` above, never directly.
+     */
+    protected abstract computeExpression(fs: FieldSpace): ExprValue;
     legalChildTypes: import("../../..").TypeDesc[];
     /**
      * Some operators want to give the right hand value a chance to
@@ -45,13 +78,19 @@ export declare abstract class ExpressionDef extends MalloyElement {
     typeCheck(eNode: ExpressionDef, eVal: ExprValue): boolean;
     drillExpression(): Malloy.Expression | undefined;
     /**
-     * This is the operation which makes partial comparison and value trees work
-     * The default implementation merely constructs LEFT OP RIGHT, but specialized
-     * nodes like alternation trees or or partial comparison can control how
-     * the appplication gets generated
+     * This is the operation which makes partial comparison and value trees work.
+     * `this` is the RIGHT operand; the left arrives here as an argument. All of
+     * the magic of malloy expressions eventually flows through here, where an
+     * operator is applied to two values -- depending on the operator and the
+     * value types that may transform the values or even the operator.
+     *
+     * Specialized nodes like alternation trees and partial comparisons override
+     * this to control how the application gets generated. They are the reason
+     * the right operand is in charge: a partial has no bound left operand, and
+     * only learns it here.
      * @param fs The symbol table
      * @param op The operator being applied
-     * @param expr The "other" (besdies 'this') value
+     * @param left The "other" (besides 'this') value
      * @return The translated expression
      */
     apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef, _warnOnComplexTree?: boolean): ExprValue;
@@ -69,20 +108,8 @@ export declare class ExprDuration extends ExpressionDef {
     legalChildTypes: import("../../..").TypeDesc[];
     constructor(n: ExpressionDef, timeframe: TimestampUnit);
     apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
-    getExpression(fs: FieldSpace): ExprValue;
+    protected computeExpression(fs: FieldSpace): ExprValue;
 }
 export type MorphicType = 'date' | 'timestamp';
 export declare function getMorphicValue(mv: ExprValue, mt: MorphicType): ExprValue | undefined;
-/**
- * All of the magic of malloy expressions eventually flows to here,
- * where an operator is applied to two values. Depending on the
- * operator and value types this may involve transformations of
- * the values or even the operator.
- * @param fs FieldSpace for the symbols
- * @param left Left value
- * @param op The operator
- * @param right Right Value
- * @return ExprValue of the expression
- */
-export declare function applyBinary(fs: FieldSpace, left: ExpressionDef, op: BinaryMalloyOperator, right: ExpressionDef): ExprValue;
 export declare function checkFilterExpression(logTo: MalloyElement, ft: FilterExprType, fexpr: Expr): void;