@malloydata/malloy 0.0.392 → 0.0.394

package/dist/api/foundation/core.d.ts

@@ -278,10 +278,6 @@ export declare class Model implements Taggable {
      * The givens this model surfaces, keyed by caller-facing surface name.
      * Used by whole-model parameter-editor UIs to render input widgets for
      * every given the model can accept.
-     *
-     * Internal-only givens (declared but never surfaced into the namespace,
-     * resolved purely via defaults) are NOT in this map — the caller has no
-     * way to set them, so listing them would mislead a UI.
      */
     get givens(): ReadonlyMap<string, Given>;
     tagParse(spec?: TagParseSpec): MalloyTagParse;

package/dist/api/foundation/core.js

@@ -782,10 +782,6 @@ class Model {
      * The givens this model surfaces, keyed by caller-facing surface name.
      * Used by whole-model parameter-editor UIs to render input widgets for
      * every given the model can accept.
-     *
-     * Internal-only givens (declared but never surfaced into the namespace,
-     * resolved purely via defaults) are NOT in this map — the caller has no
-     * way to set them, so listing them would mislead a UI.
      */
     get givens() {
         var _a, _b;
@@ -799,9 +795,9 @@ class Model {
             if ((_b = (_a = this.runtimeContext) === null || _a === void 0 ? void 0 : _a.finalizedGivens) === null || _b === void 0 ? void 0 : _b.has(surfaceName))
                 continue;
             const decl = givens[entry.id];
-            if (!decl)
-                continue;
-            out.set(surfaceName, new Given(surfaceName, entry.id, decl));
+            if (decl && !decl.inline) {
+                out.set(surfaceName, new Given(surfaceName, entry.id, decl));
+            }
         }
         return out;
     }
@@ -1197,11 +1193,18 @@ class PreparedQuery {
      */
     getPreparedResult(options) {
         const queryModel = this._model.queryModel;
+        // Build the resolved-givens map in two phases:
+        //   1. caller-supplied values (resolveSuppliedGivens)
+        //   2. inline-given defaults eager-evaluated against the map
+        // Result is undefined when no values land — preserves the previous
+        // "no givens path" downstream.
+        const resolved = (options === null || options === void 0 ? void 0 : options.givens)
+            ? (0, given_binding_1.resolveSuppliedGivens)(options.givens, this._modelDef)
+            : new Map();
+        (0, given_binding_1.evaluateInlineGivens)(resolved, this._modelDef);
         const prepareResultOptions = {
             ...options,
-            resolvedGivens: (options === null || options === void 0 ? void 0 : options.givens)
-                ? (0, given_binding_1.resolveSuppliedGivens)(options.givens, this._modelDef)
-                : undefined,
+            resolvedGivens: resolved.size > 0 ? resolved : undefined,
         };
         const translatedQuery = queryModel.compileQuery(this._query, prepareResultOptions);
         return new PreparedResult({

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

@@ -3,6 +3,7 @@ import type { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import type { FieldSpace } from '../types/field-space';
 import { BinaryBoolean } from './binary-boolean';
+import type { GivenReference } from './expr-given';
 export declare class ExprCompare extends BinaryBoolean<CompareMalloyOperator> {
     elementType: string;
     constructor(left: ExpressionDef, op: CompareMalloyOperator, right: ExpressionDef);
@@ -28,3 +29,17 @@ export declare class ExprLegacyIn extends ExpressionDef {
     constructor(expr: ExpressionDef, notIn: boolean, choices: ExpressionDef[]);
     getExpression(fs: FieldSpace): ExprValue;
 }
+/**
+ * `expr in $ARRAY_GIVEN` — runtime test of a basic-typed expression
+ * against the elements of a runtime-bound array given. The translator
+ * verifies the given is `T[]` and the LHS is the same basic `T`; SQL
+ * emission expands the bound array's elements at compile time.
+ */
+export declare class ExprInGiven extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    readonly notIn: boolean;
+    readonly givenRef: GivenReference;
+    elementType: string;
+    constructor(expr: ExpressionDef, notIn: boolean, givenRef: GivenReference);
+    getExpression(fs: FieldSpace): ExprValue;
+}

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

@@ -55,9 +55,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExprLegacyIn = exports.ExprEquality = exports.ExprCompare = void 0;
+exports.ExprInGiven = exports.ExprLegacyIn = exports.ExprEquality = exports.ExprCompare = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const utils_1 = require("../../../model/utils");
 const TDU = __importStar(require("../typedesc-utils"));
 const expr_value_1 = require("../types/expr-value");
+const expr_value_2 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const binary_boolean_1 = require("./binary-boolean");
 const compareTypes = {
@@ -112,7 +115,7 @@ class ExprLegacyIn extends expression_def_1.ExpressionDef {
     getExpression(fs) {
         const lookFor = this.expr.getExpression(fs);
         const oneOf = this.choices.map(e => e.getExpression(fs));
-        return (0, expr_value_1.computedExprValue)({
+        return (0, expr_value_2.computedExprValue)({
             dataType: { type: 'boolean' },
             value: {
                 node: 'in',
@@ -124,4 +127,81 @@ class ExprLegacyIn extends expression_def_1.ExpressionDef {
     }
 }
 exports.ExprLegacyIn = ExprLegacyIn;
+/**
+ * `expr in $ARRAY_GIVEN` — runtime test of a basic-typed expression
+ * against the elements of a runtime-bound array given. The translator
+ * verifies the given is `T[]` and the LHS is the same basic `T`; SQL
+ * emission expands the bound array's elements at compile time.
+ */
+class ExprInGiven extends expression_def_1.ExpressionDef {
+    constructor(expr, notIn, givenRef) {
+        super();
+        this.expr = expr;
+        this.notIn = notIn;
+        this.givenRef = givenRef;
+        this.elementType = 'inGiven';
+        this.has({ expr, givenRef });
+    }
+    getExpression(fs) {
+        const lookFor = this.expr.getExpression(fs);
+        const givenVal = this.givenRef.getExpression(fs);
+        // `in` is logically a boolean — every error path returns a
+        // boolean-typed error so a `where:` clause around us doesn't pile a
+        // "filter must be boolean" complaint on top of our own diagnostic.
+        const boolError = () => (0, expr_value_1.computedErrorExprValue)({
+            dataType: { type: 'boolean' },
+            error: 'in-given type error',
+            from: [lookFor, givenVal],
+        });
+        if (lookFor.type === 'error' || givenVal.type === 'error') {
+            return boolError();
+        }
+        // GivenReference only ever returns a `given` ExprValue on the
+        // success path; the error branch is filtered above. No other case
+        // is reachable here.
+        const givenNode = givenVal.value;
+        if (givenNode.node !== 'given') {
+            throw this.internalError(`expected GivenReference to produce a 'given' node, got '${givenNode.node}'`);
+        }
+        if (!malloy_types_1.TD.isAtomic(givenVal) || givenVal.type !== 'array') {
+            this.logError('in-given-rhs-not-array', {
+                givenName: this.givenRef.name,
+                actualType: malloy_types_1.TD.isAtomic(givenVal)
+                    ? (0, utils_1.typeDefToString)(givenVal)
+                    : givenVal.type,
+            });
+            return boolError();
+        }
+        if ((0, malloy_types_1.isRepeatedRecord)(givenVal)) {
+            this.logError('in-given-rhs-not-basic-array', {
+                givenName: this.givenRef.name,
+                elementType: (0, utils_1.typeDefToString)(givenVal),
+            });
+            return boolError();
+        }
+        // givenVal is BasicArrayTypeDef-shaped — the union for array
+        // AtomicTypeDefs is BasicArray | RepeatedRecord, and the
+        // RepeatedRecord branch returned above.
+        const elemType = givenVal.elementTypeDef;
+        if (!malloy_types_1.TD.isBasicAtomic(lookFor) || lookFor.type !== elemType.type) {
+            this.logError('in-given-type-mismatch', {
+                lhsType: malloy_types_1.TD.isAtomic(lookFor) ? (0, utils_1.typeDefToString)(lookFor) : lookFor.type,
+                elementType: (0, utils_1.typeDefToString)(elemType),
+            });
+            return boolError();
+        }
+        const inGivenNode = {
+            node: 'inGiven',
+            not: this.notIn,
+            givenRef: givenNode,
+            e: lookFor.value,
+        };
+        return (0, expr_value_2.computedExprValue)({
+            dataType: { type: 'boolean' },
+            value: inGivenNode,
+            from: [lookFor, givenVal],
+        });
+    }
+}
+exports.ExprInGiven = ExprInGiven;
 //# sourceMappingURL=expr-compare.js.map

package/dist/lang/ast/statements/define-given.d.ts

@@ -4,24 +4,19 @@ import type { DocStatement, Document } from '../types/malloy-element';
 import { DocStatementList, MalloyElement } from '../types/malloy-element';
 import type { Noteable } from '../types/noteable';
 import { extendNoteMethod } from '../types/noteable';
-/**
- * One named given declaration: `NAME :: TYPE [is EXPR]`.
- */
 export declare class GivenDeclaration extends MalloyElement implements DocStatement, Noteable {
     readonly name: string;
     readonly typeDef: GivenTypeDef;
+    readonly inline: boolean;
     elementType: string;
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
     note?: Annotation;
     readonly default?: ConstantExpression;
-    constructor(name: string, typeDef: GivenTypeDef, defaultExpr?: ConstantExpression);
+    constructor(name: string, typeDef: GivenTypeDef, defaultExpr?: ConstantExpression, inline?: boolean);
     protected varInfo(): string;
     execute(doc: Document): void;
 }
-/**
- * Top-level `given:` block — a sequence of given declarations.
- */
 export declare class DefineGivens extends DocStatementList {
     elementType: string;
     readonly givens: GivenDeclaration[];

package/dist/lang/ast/statements/define-given.js

@@ -6,30 +6,58 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefineGivens = exports.GivenDeclaration = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
+const inline_expr_1 = require("../../../model/inline_expr");
 const source_def_utils_1 = require("../../../model/source_def_utils");
 const utils_1 = require("../../../model/utils");
 const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
 const noteable_1 = require("../types/noteable");
-/**
- * True when exactly one of `declared` and `constVal` is filter-typed.
- * Catches `filter<T>` declared with a non-filter default (and vice versa)
- * at definition time. Inner-content validation of `filter<T>` defaults
- * (syntax + compatibility with `T`) is the filter machinery's job at the
- * use site; we don't try to do it here.
- */
+// `filter<T>` defaults can't be type-checked via TD.eq — the filter
+// expression value shape doesn't match an atomic typeDef. Catch only
+// the gross kind mismatch here; inner-content validation (filter
+// syntax + T compatibility) belongs to the filter machinery at use
+// site.
 function filterTypeMismatch(declared, constVal) {
     return ((declared.type === 'filter expression') !==
         (constVal.type === 'filter expression'));
 }
 /**
- * One named given declaration: `NAME :: TYPE [is EXPR]`.
+ * Walk an Expr tree and collect every node string that isn't in the
+ * allowed inline operator/leaf sets.
+ *
+ * The translator caller is gated on a clean translation of the default
+ * (`constVal.type !== 'error'`): we don't pile bad-operator errors on
+ * top of a default that didn't translate cleanly for more fundamental
+ * reasons (an unknown `$REF`, a type mismatch, etc.). Every bad node
+ * is collected so the author sees the full list in one diagnostic.
  */
+function collectInlineBadOps(e, bad) {
+    if (!inline_expr_1.INLINE_OPS.has(e.node) && !inline_expr_1.INLINE_LEAVES.has(e.node)) {
+        bad.add(e.node);
+    }
+    if ((0, malloy_types_1.exprHasE)(e)) {
+        collectInlineBadOps(e.e, bad);
+    }
+    else if ((0, malloy_types_1.exprHasKids)(e)) {
+        for (const kid of Object.values(e.kids)) {
+            if (kid === null)
+                continue;
+            if (Array.isArray(kid)) {
+                for (const k of kid)
+                    collectInlineBadOps(k, bad);
+            }
+            else {
+                collectInlineBadOps(kid, bad);
+            }
+        }
+    }
+}
 class GivenDeclaration extends malloy_element_1.MalloyElement {
-    constructor(name, typeDef, defaultExpr) {
+    constructor(name, typeDef, defaultExpr, inline = false) {
         super();
         this.name = name;
         this.typeDef = typeDef;
+        this.inline = inline;
         this.elementType = 'given';
         this.isNoteableObj = true;
         this.extendNote = noteable_1.extendNoteMethod;
@@ -42,13 +70,19 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
         return ` ${this.name} :: ${(0, utils_1.typeDefToString)(this.typeDef)}`;
     }
     execute(doc) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         if (this.typeDef.type === 'error')
             return;
         if (doc.modelEntry(this.name)) {
             this.logError('given-definition-name-conflict', `Cannot redefine '${this.name}'`);
             return;
         }
+        // An inline given with no default has nothing to evaluate at bind
+        // time. Log and keep going — the given still registers in the
+        // namespace so downstream errors don't cascade pointlessly.
+        if (this.inline && !this.default) {
+            this.logError('inline-no-default', { name: this.name });
+        }
         // Default expression. ConstantExpression evaluates through a
         // ConstantFieldSpace that errors on every name lookup, so any
         // non-constant subexpression (field refs, aggregates, etc.) gets
@@ -60,11 +94,19 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
         if (this.default) {
             const constVal = this.default.constantValue();
             if (constVal.type !== 'error') {
+                // `X :: timestamp is @2024-01-01` works because date literals
+                // carry a morphic.timestamp. Date/timestamp are the only
+                // MorphicType targets — other declared types fall through to
+                // the TD.eq check below.
+                const morphed = this.typeDef.type === 'date' || this.typeDef.type === 'timestamp'
+                    ? (0, expression_def_1.getMorphicValue)(constVal, this.typeDef.type)
+                    : undefined;
                 // `filter<T>` defaults are filter-expression literals — their
                 // shape doesn't match an atomic typeDef, so type-check there is
                 // owned by the filter machinery, not us. `null` is implicitly
                 // accepted for any declared type.
                 if (constVal.type !== 'null' &&
+                    morphed === undefined &&
                     (filterTypeMismatch(this.typeDef, constVal) ||
                         !malloy_types_1.TD.eq(this.typeDef, constVal))) {
                     const actual = malloy_types_1.TD.isAtomic(constVal)
@@ -79,7 +121,7 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
                     // again at use site. Catches bad filter syntax early.
                     (0, expression_def_1.checkFilterExpression)(this.default, this.typeDef.filterType, constVal.value);
                 }
-                defaultExpr = constVal.value;
+                defaultExpr = (_a = morphed === null || morphed === void 0 ? void 0 : morphed.value) !== null && _a !== void 0 ? _a : constVal.value;
                 // Build the transitive closure of givens reachable through this
                 // default's expression. We only include direct refs PLUS each
                 // referenced given's already-precomputed transitive (which is
@@ -100,7 +142,7 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
                         seen.add(g.id);
                         closure.push(g);
                         const refDecl = doc.documentGivens.get(g.id);
-                        for (const t of (_a = refDecl === null || refDecl === void 0 ? void 0 : refDecl.givenUsage) !== null && _a !== void 0 ? _a : []) {
+                        for (const t of (_b = refDecl === null || refDecl === void 0 ? void 0 : refDecl.givenUsage) !== null && _b !== void 0 ? _b : []) {
                             if (seen.has(t.id))
                                 continue;
                             seen.add(t.id);
@@ -109,10 +151,21 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
                     }
                     givenUsage = closure;
                 }
+                // Ensure inline expression is resolveable at compile time.
+                if (this.inline) {
+                    const bad = new Set();
+                    collectInlineBadOps(defaultExpr, bad);
+                    if (bad.size > 0) {
+                        this.default.logError('inline-bad-operator', {
+                            name: this.name,
+                            operators: [...bad].sort().join(', '),
+                        });
+                    }
+                }
             }
         }
-        const id = (0, source_def_utils_1.mkGivenID)(this.name, (_b = this.location) === null || _b === void 0 ? void 0 : _b.url);
-        const defaultText = defaultExpr !== undefined ? (_c = this.default) === null || _c === void 0 ? void 0 : _c.code : undefined;
+        const id = (0, source_def_utils_1.mkGivenID)(this.name, (_c = this.location) === null || _c === void 0 ? void 0 : _c.url);
+        const defaultText = defaultExpr !== undefined ? (_d = this.default) === null || _d === void 0 ? void 0 : _d.code : undefined;
         const givenIR = {
             name: this.name,
             type: this.typeDef,
@@ -121,6 +174,7 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
             givenUsage,
             location: this.location,
             annotation: this.note,
+            ...(this.inline ? { inline: true } : {}),
         };
         doc.documentGivens.set(id, givenIR);
         const entry = { type: 'given', name: this.name, id };
@@ -132,7 +186,7 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
         this.addReference({
             type: 'givenReference',
             text: this.name,
-            location: (_d = this.location) !== null && _d !== void 0 ? _d : {
+            location: (_e = this.location) !== null && _e !== void 0 ? _e : {
                 url: '',
                 range: {
                     start: { line: 0, character: 0 },
@@ -149,9 +203,6 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
     }
 }
 exports.GivenDeclaration = GivenDeclaration;
-/**
- * Top-level `given:` block — a sequence of given declarations.
- */
 class DefineGivens extends malloy_element_1.DocStatementList {
     constructor(givens) {
         super(givens);

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

@@ -239,10 +239,12 @@ class MalloyElement {
             const kiddle = this.children[kidLabel];
             if (kiddle instanceof MalloyElement) {
                 yield kiddle;
+                yield* kiddle.walk();
             }
             else {
                 for (const k of kiddle) {
                     yield k;
+                    yield* k.walk();
                 }
             }
         }