@malloydata/malloy 0.0.427 → 0.0.428

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

@@ -39,7 +39,6 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprDuration = exports.ExpressionDef = exports.ATNodeType = void 0;
 exports.getMorphicValue = getMorphicValue;
-exports.applyBinary = applyBinary;
 exports.checkFilterExpression = checkFilterExpression;
 const malloy_types_1 = require("../../../model/malloy_types");
 const TDU = __importStar(require("../typedesc-utils"));
@@ -52,6 +51,31 @@ const binary_operators_1 = require("./binary_operators");
 const malloy_filter_1 = require("@malloydata/malloy-filter");
 class TypeMismatch extends Error {
 }
+/**
+ * Mark a value as belonging to everyone. Writing into a memoized value writes
+ * into every other holder's copy and into whatever the IR already stored;
+ * freezing turns that from a silent miscompile into a TypeError naming the
+ * line which did it. Own fields only -- walking every Expr on every
+ * evaluation would cost more than the memo saves.
+ */
+function shareable(v) {
+    var _a, _b;
+    Object.freeze(v);
+    for (const share of [
+        v.value,
+        v.morphic,
+        v.refSummary,
+        (_a = v.refSummary) === null || _a === void 0 ? void 0 : _a.fieldUsage,
+        (_b = v.refSummary) === null || _b === void 0 ? void 0 : _b.givenUsage,
+        v.requiresGroupBy,
+        v.ungroupings,
+    ]) {
+        if (share !== undefined) {
+            Object.freeze(share);
+        }
+    }
+    return v;
+}
 /** Node types in an alternation tree */
 var ATNodeType;
 (function (ATNodeType) {
@@ -62,9 +86,9 @@ var ATNodeType;
 })(ATNodeType || (exports.ATNodeType = 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.
  */
 class ExpressionDef extends malloy_element_1.MalloyElement {
     constructor() {
@@ -74,6 +98,53 @@ class ExpressionDef extends malloy_element_1.MalloyElement {
     granular() {
         return false;
     }
+    /**
+     * 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.
+     */
+    getExpression(fs) {
+        const initialGeneration = fs.generation();
+        if (this.memoValue !== undefined &&
+            this.memoFs === fs &&
+            this.memoGen === initialGeneration) {
+            return this.memoValue;
+        }
+        // If we get here and memoFs is set and memoGen is not set, then somewhere
+        // inside this expression is a recursive call asking this node for the
+        // value it is in the middle of computing. There is nothing to return and
+        // computing one would recurse again, so throw. An abandoned computation
+        // does not look like this -- see the finally below.
+        if (this.memoFs !== undefined && this.memoGen === undefined) {
+            throw this.internalError(`ExpressionDef.getExpression memoization failure on ${this.elementType}`);
+        }
+        this.memoFs = fs;
+        this.memoGen = undefined;
+        try {
+            const value = this.computeExpression(fs);
+            if (initialGeneration === fs.generation()) {
+                this.memoGen = initialGeneration;
+                this.memoValue = shareable(value);
+            }
+            return value;
+        }
+        finally {
+            if (this.memoGen === undefined) {
+                // Threw, or a name was rebound while we ran. Leave no stamp: a caller
+                // which recovers must get a fresh computation, not our remains.
+                this.memoFs = undefined;
+            }
+        }
+    }
     /**
      * Some operators want to give the right hand value a chance to
      * rewrite itself. This requests a translation for a rewrite,
@@ -110,17 +181,38 @@ class ExpressionDef extends malloy_element_1.MalloyElement {
         return 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, op, left, _warnOnComplexTree = false) {
-        return applyBinary(fs, left, op, this);
+        if ((0, binary_operators_1.isEquality)(op)) {
+            return equality(fs, left, op, this);
+        }
+        if ((0, binary_operators_1.isComparison)(op)) {
+            return compare(fs, left, op, this);
+        }
+        if (op === '+' || op === '-') {
+            return delta(fs, left, op, this);
+        }
+        if (op === '*') {
+            return numeric(fs, left, op, this);
+        }
+        if (op === '/' || op === '%') {
+            return divmod(fs, left, op, this);
+        }
+        return left.loggedErrorExpr('unexpected-binary-operator', `Cannot use ${op} operator here`);
     }
     canSupportPartitionBy() {
         return false;
@@ -178,7 +270,7 @@ class ExprDuration extends ExpressionDef {
         }
         return super.apply(fs, op, left);
     }
-    getExpression(fs) {
+    computeExpression(fs) {
         const num = this.n.getExpression(fs);
         return (0, expr_value_1.computedErrorExprValue)({
             dataType: { type: 'duration' },
@@ -402,6 +494,30 @@ function numeric(fs, left, op, right) {
     }
     return (0, ast_utils_1.errorFor)('numbers required');
 }
+function divmod(fs, left, op, right) {
+    const num = left.getExpression(fs);
+    const denom = right.getExpression(fs);
+    const noGo = unsupportError(left, num, right, denom);
+    if (noGo)
+        return noGo;
+    const err = errorCascade('number', num, denom);
+    if (err)
+        return err;
+    if (num.type !== 'number') {
+        left.logError('arithmetic-operation-type-mismatch', 'Numerator must be a number');
+    }
+    else if (denom.type !== 'number') {
+        right.logError('arithmetic-operation-type-mismatch', 'Denominator must be a number');
+    }
+    else {
+        return (0, expr_value_1.computedExprValue)({
+            dataType: mergeNumberTypes(num, denom, op),
+            value: { node: op, kids: { left: num.value, right: denom.value } },
+            from: [num, denom],
+        });
+    }
+    return (0, ast_utils_1.errorFor)('divide type mismatch');
+}
 function delta(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
@@ -430,60 +546,6 @@ function delta(fs, left, op, right) {
     }
     return numeric(fs, left, op, right);
 }
-/**
- * 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
- */
-function applyBinary(fs, left, op, right) {
-    if ((0, binary_operators_1.isEquality)(op)) {
-        return equality(fs, left, op, right);
-    }
-    if ((0, binary_operators_1.isComparison)(op)) {
-        return compare(fs, left, op, right);
-    }
-    if (op === '+' || op === '-') {
-        return delta(fs, left, op, right);
-    }
-    if (op === '*') {
-        return numeric(fs, left, op, right);
-    }
-    if (op === '/' || op === '%') {
-        const num = left.getExpression(fs);
-        const denom = right.getExpression(fs);
-        const noGo = unsupportError(left, num, right, denom);
-        if (noGo)
-            return noGo;
-        const err = errorCascade('number', num, denom);
-        if (err)
-            return err;
-        if (num.type !== 'number') {
-            left.logError('arithmetic-operation-type-mismatch', 'Numerator must be a number');
-        }
-        else if (denom.type !== 'number') {
-            right.logError('arithmetic-operation-type-mismatch', 'Denominator must be a number');
-        }
-        else {
-            const divmod = {
-                node: op,
-                kids: { left: num.value, right: denom.value },
-            };
-            return (0, expr_value_1.computedExprValue)({
-                dataType: mergeNumberTypes(num, denom, op),
-                value: divmod,
-                from: [num, denom],
-            });
-        }
-        return (0, ast_utils_1.errorFor)('divide type mismatch');
-    }
-    return left.loggedErrorExpr('unexpected-binary-operator', `Cannot use ${op} operator here`);
-}
 function errorCascade(type, ...es) {
     if (es.some(e => e.type === 'error')) {
         return (0, expr_value_1.computedExprValue)({

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

@@ -4,6 +4,14 @@ import type { QueryOperationSpace } from '../field-space/query-spaces';
 import type { LookupResult } from './lookup-result';
 import { MalloyElement } from './malloy-element';
 import type { SpaceEntry } from './space-entry';
+export declare function currentGeneration(): number;
+/**
+ * Called by every field space operation that binds, rebinds or unbinds a
+ * name. Lazily materializing a space's entries from its StructDef is not
+ * such an operation -- the bindings were already logically present, so
+ * nothing a cache observed can have changed.
+ */
+export declare function noteRebinding(): void;
 /**
  * A FieldSpace is a hierarchy of namespaces, where the leaf nodes
  * are fields. A FieldSpace can lookup fields, and generate a StructDef
@@ -20,6 +28,12 @@ export interface FieldSpace {
     connectionName(): string;
     isQueryFieldSpace(): this is QueryFieldSpace;
     accessProtectionLevel(): AccessModifierLabel;
+    /**
+     * A value which changes whenever any name binding changes. A result
+     * computed by consulting this space may be reused only while this is
+     * unchanged. See `noteRebinding` above.
+     */
+    generation(): number;
 }
 export interface SourceFieldSpace extends FieldSpace {
     structDef(): SourceDef;

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

@@ -5,7 +5,43 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FieldName = void 0;
+exports.currentGeneration = currentGeneration;
+exports.noteRebinding = noteRebinding;
 const malloy_element_1 = require("./malloy-element");
+/**
+ * Some field spaces are static, some are dynamic. We are computing a very
+ * conservative process wide "generation" which moves forward when any
+ * dynamic field space changes. We can be very certain that if the field space
+ * generation has not changed, computations depending on the contents of
+ * field spaces are still valid.
+ *
+ * A more fine grained validity is hard to compute and possibly a fragile
+ * computation. Spaces delegate to each other -- a passthrough wraps another
+ * space, a query output space resolves names through its input space -- so a
+ * per-space generation has to forward through every one of those paths, and a
+ * path we missed is a stale cache we never notice. We think this simple
+ * approach will be good enough for a long time, possibly forever.
+ *
+ * This does not cover a computation which reads something other than a field
+ * space. `GivenReference` ignores the FieldSpace it is handed and reads the
+ * Document namespace, which never moves this counter. Nothing is known to
+ * depend on that, since document definitions happen between statements, but
+ * do not assume a cache is covered here just because it consults a field
+ * space as well.
+ */
+let bindingGeneration = 0;
+function currentGeneration() {
+    return bindingGeneration;
+}
+/**
+ * Called by every field space operation that binds, rebinds or unbinds a
+ * name. Lazily materializing a space's entries from its StructDef is not
+ * such an operation -- the bindings were already logically present, so
+ * nothing a cache observed can have changed.
+ */
+function noteRebinding() {
+    bindingGeneration += 1;
+}
 class FieldName extends malloy_element_1.MalloyElement {
     constructor(name) {
         super();

package/dist/model/malloy_types.d.ts

@@ -801,19 +801,6 @@ export declare function mkRefSummary({ fieldUsage, givenUsage, }: {
  * untouched without each call site having to know about them.
  */
 export declare function mapFieldUsage(rs: RefSummary | undefined, fn: (u: FieldUsageEntry) => FieldUsageEntry): RefSummary | undefined;
-/**
- * Mutating setter for a node's `fieldUsage`. When the node already has a
- * `refSummary`, replaces just the `fieldUsage` slice (preserving `givenUsage`
- * and any future RefSummary fields). When it doesn't, creates a fresh
- * `refSummary` with the supplied usages.
- *
- * Use at sites that mutate an already-constructed IR node; for sites that
- * build a node from a literal, write `{fieldUsage: [...]}` directly or use
- * `mkRefSummary` for possibly-undefined inputs.
- */
-export declare function setFieldUsage(target: {
-    refSummary?: RefSummary;
-}, usages: FieldUsage): void;
 export interface QuerySegment extends Filtered, Ordered, SegmentUsageSummary {
     type: 'reduce' | 'project' | 'partial';
     queryFields: QueryFieldDef[];

package/dist/model/malloy_types.js

@@ -64,7 +64,6 @@ exports.fieldUsageFrom = fieldUsageFrom;
 exports.givenUsageFrom = givenUsageFrom;
 exports.mkRefSummary = mkRefSummary;
 exports.mapFieldUsage = mapFieldUsage;
-exports.setFieldUsage = setFieldUsage;
 exports.isSegmentSQL = isSegmentSQL;
 exports.isSegmentSource = isSegmentSource;
 exports.isSourceRegistryReference = isSourceRegistryReference;
@@ -491,24 +490,6 @@ function mkRefSummary({ fieldUsage, givenUsage, }) {
 function mapFieldUsage(rs, fn) {
     return rs && { ...rs, fieldUsage: rs.fieldUsage.map(fn) };
 }
-/**
- * Mutating setter for a node's `fieldUsage`. When the node already has a
- * `refSummary`, replaces just the `fieldUsage` slice (preserving `givenUsage`
- * and any future RefSummary fields). When it doesn't, creates a fresh
- * `refSummary` with the supplied usages.
- *
- * Use at sites that mutate an already-constructed IR node; for sites that
- * build a node from a literal, write `{fieldUsage: [...]}` directly or use
- * `mkRefSummary` for possibly-undefined inputs.
- */
-function setFieldUsage(target, usages) {
-    if (target.refSummary) {
-        target.refSummary.fieldUsage = usages;
-    }
-    else {
-        target.refSummary = { fieldUsage: usages };
-    }
-}
 function isSegmentSQL(f) {
     return 'sql' in f;
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.427";
+export declare const MALLOY_VERSION = "0.0.428";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.427';
+exports.MALLOY_VERSION = '0.0.428';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.427",
+  "version": "0.0.428",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -51,9 +51,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.427",
-    "@malloydata/malloy-interfaces": "0.0.427",
-    "@malloydata/malloy-tag": "0.0.427",
+    "@malloydata/malloy-filter": "0.0.428",
+    "@malloydata/malloy-interfaces": "0.0.428",
+    "@malloydata/malloy-tag": "0.0.428",
     "@noble/hashes": "^1.8.0",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",