@malloydata/malloy 0.0.392 → 0.0.394

package/dist/lang/lib/Malloy/MalloyParserListener.d.ts

@@ -42,6 +42,7 @@ import { ExprCompareContext } from "./MalloyParser";
 import { ExprWarnLikeContext } from "./MalloyParser";
 import { ExprNullCheckContext } from "./MalloyParser";
 import { ExprWarnInContext } from "./MalloyParser";
+import { ExprInGivenContext } from "./MalloyParser";
 import { ExprApplyContext } from "./MalloyParser";
 import { ExprNotContext } from "./MalloyParser";
 import { ExprLogicalAndContext } from "./MalloyParser";
@@ -104,6 +105,7 @@ import { DefineQueryContext } from "./MalloyParser";
 import { DefineGivenStatementContext } from "./MalloyParser";
 import { GivenDefListContext } from "./MalloyParser";
 import { GivenDefContext } from "./MalloyParser";
+import { GivenModifierContext } from "./MalloyParser";
 import { GivenNameDefContext } from "./MalloyParser";
 import { GivenTypeContext } from "./MalloyParser";
 import { TopLevelAnonQueryDefContext } from "./MalloyParser";
@@ -792,6 +794,18 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitExprWarnIn?: (ctx: ExprWarnInContext) => void;
+    /**
+     * Enter a parse tree produced by the `exprInGiven`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     */
+    enterExprInGiven?: (ctx: ExprInGivenContext) => void;
+    /**
+     * Exit a parse tree produced by the `exprInGiven`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     */
+    exitExprInGiven?: (ctx: ExprInGivenContext) => void;
     /**
      * Enter a parse tree produced by the `exprApply`
      * labeled alternative in `MalloyParser.fieldExpr`.
@@ -1506,6 +1520,16 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitGivenDef?: (ctx: GivenDefContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.givenModifier`.
+     * @param ctx the parse tree
+     */
+    enterGivenModifier?: (ctx: GivenModifierContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.givenModifier`.
+     * @param ctx the parse tree
+     */
+    exitGivenModifier?: (ctx: GivenModifierContext) => void;
     /**
      * Enter a parse tree produced by `MalloyParser.givenNameDef`.
      * @param ctx the parse tree

package/dist/lang/lib/Malloy/MalloyParserVisitor.d.ts

@@ -42,6 +42,7 @@ import { ExprCompareContext } from "./MalloyParser";
 import { ExprWarnLikeContext } from "./MalloyParser";
 import { ExprNullCheckContext } from "./MalloyParser";
 import { ExprWarnInContext } from "./MalloyParser";
+import { ExprInGivenContext } from "./MalloyParser";
 import { ExprApplyContext } from "./MalloyParser";
 import { ExprNotContext } from "./MalloyParser";
 import { ExprLogicalAndContext } from "./MalloyParser";
@@ -104,6 +105,7 @@ import { DefineQueryContext } from "./MalloyParser";
 import { DefineGivenStatementContext } from "./MalloyParser";
 import { GivenDefListContext } from "./MalloyParser";
 import { GivenDefContext } from "./MalloyParser";
+import { GivenModifierContext } from "./MalloyParser";
 import { GivenNameDefContext } from "./MalloyParser";
 import { GivenTypeContext } from "./MalloyParser";
 import { TopLevelAnonQueryDefContext } from "./MalloyParser";
@@ -580,6 +582,13 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitExprWarnIn?: (ctx: ExprWarnInContext) => Result;
+    /**
+     * Visit a parse tree produced by the `exprInGiven`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExprInGiven?: (ctx: ExprInGivenContext) => Result;
     /**
      * Visit a parse tree produced by the `exprApply`
      * labeled alternative in `MalloyParser.fieldExpr`.
@@ -999,6 +1008,12 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitGivenDef?: (ctx: GivenDefContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.givenModifier`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitGivenModifier?: (ctx: GivenModifierContext) => Result;
     /**
      * Visit a parse tree produced by `MalloyParser.givenNameDef`.
      * @param ctx the parse tree

package/dist/lang/malloy-to-ast.d.ts

@@ -1,5 +1,5 @@
 import { ParserRuleContext } from 'antlr4ts';
-import type { ParseTree } from 'antlr4ts/tree';
+import type { ParseTree, TerminalNode } from 'antlr4ts/tree';
 import { AbstractParseTreeVisitor } from 'antlr4ts/tree/AbstractParseTreeVisitor';
 import type { MalloyParserVisitor } from './lib/Malloy/MalloyParserVisitor';
 import type * as parse from './lib/Malloy/MalloyParser';
@@ -72,7 +72,13 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     protected getFieldName(cx: HasID): ast.FieldName;
     protected getModelEntryName(cx: HasID): ast.ModelEntryReference;
     defaultResult(): ast.MalloyElement;
-    protected astAt<MT extends ast.MalloyElement>(el: MT, cx: ParserRuleContext): MT;
+    /**
+     * Attach a source location to an AST element and return it. The range
+     * is taken from the supplied parse-tree node — either a
+     * `ParserRuleContext` (entire rule's token span) or a `TerminalNode`
+     * (just that one token).
+     */
+    protected astAt<MT extends ast.MalloyElement>(el: MT, cx: ParserRuleContext | TerminalNode): MT;
     protected getSourceCode(cx: ParserRuleContext): string;
     protected getFilterElement(cx: parse.FieldExprContext): ast.FilterElement;
     protected getFieldDefs(cxList: parse.FieldDefContext[], makeFieldDef: ast.FieldDeclarationConstructor): ast.AtomicFieldDeclaration[];
@@ -275,6 +281,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitExprArrayLiteral(pcx: parse.ExprArrayLiteralContext): ast.ArrayLiteral;
     visitExprWarnLike(pcx: parse.ExprWarnLikeContext): ast.ExprCompare;
     visitExprNullCheck(pcx: parse.ExprNullCheckContext): ast.ExprIsNull;
+    visitExprInGiven(pcx: parse.ExprInGivenContext): ast.ExprInGiven;
     visitExprWarnIn(pcx: parse.ExprWarnInContext): ast.ExprLegacyIn;
     visitTickFilterString(pcx: parse.TickFilterStringContext): ast.ExprFilterExpression;
     visitTripFilterString(pcx: parse.TripFilterStringContext): ast.ExprFilterExpression;

package/dist/lang/malloy-to-ast.js

@@ -195,10 +195,19 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     defaultResult() {
         return new ast.Unimplemented();
     }
+    /**
+     * Attach a source location to an AST element and return it. The range
+     * is taken from the supplied parse-tree node — either a
+     * `ParserRuleContext` (entire rule's token span) or a `TerminalNode`
+     * (just that one token).
+     */
     astAt(el, cx) {
+        const range = cx instanceof antlr4ts_1.ParserRuleContext
+            ? this.rangeFromContext(cx)
+            : (0, utils_1.rangeFromToken)(this.parseInfo.sourceInfo, cx.symbol);
         el.location = {
             url: this.parseInfo.sourceURL,
-            range: this.rangeFromContext(cx),
+            range,
         };
         return el;
     }
@@ -317,7 +326,25 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
                 this.contextError(afterIs, 'given-no-tags-after-is', 'Annotations are not allowed between `is` and the default value of a given; place them above the declaration');
             }
         }
-        const decl = new ast.GivenDeclaration(name, typeDef, defVal);
+        // The modifier slot accepts any identifier and rejects anything but
+        // `inline` at AST-build — this keeps `inline` from being a reserved
+        // word elsewhere in the language (fields, sources, view names, etc.
+        // can still be called `inline`). The cost: a slightly later error
+        // surface if someone misspells the modifier.
+        // Case-insensitive match: Malloy keywords are case-insensitive in
+        // the lexer, so accept `inline`, `INLINE`, `Inline`, etc.
+        const modCx = pcx.givenModifier();
+        let inline = false;
+        if (modCx) {
+            const modText = (0, parse_utils_1.getId)(modCx);
+            if (modText.toLowerCase() === 'inline') {
+                inline = true;
+            }
+            else {
+                this.contextError(modCx, 'invalid-given-modifier', { modifier: modText });
+            }
+        }
+        const decl = new ast.GivenDeclaration(name, typeDef, defVal, inline);
         decl.extendNote({ notes: this.getNotes(pcx.tags()) });
         return this.astAt(decl, pcx);
     }
@@ -1766,6 +1793,14 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const expr = pcx.fieldExpr();
         return this.astAt(new ast.ExprIsNull(this.getFieldExpr(expr), pcx.NOT() ? '!=' : '='), pcx);
     }
+    visitExprInGiven(pcx) {
+        this.inExperiment('givens', pcx);
+        const lhs = this.getFieldExpr(pcx.fieldExpr());
+        const isNot = !!pcx.NOT();
+        const givenName = pcx.GIVEN_REF().text.slice(1);
+        const givenRef = this.astAt(new ast.GivenReference(givenName), pcx.GIVEN_REF());
+        return this.astAt(new ast.ExprInGiven(lhs, isNot, givenRef), pcx);
+    }
     visitExprWarnIn(pcx) {
         const expr = this.getFieldExpr(pcx.fieldExpr());
         const isNot = !!pcx.NOT();

package/dist/lang/parse-log.d.ts

@@ -292,6 +292,28 @@ type MessageParameterTypes = {
     'given-reference-not-implemented': string;
     'given-not-found': string;
     'given-no-tags-after-is': string;
+    'in-given-rhs-not-array': {
+        givenName: string;
+        actualType: string;
+    };
+    'in-given-rhs-not-basic-array': {
+        givenName: string;
+        elementType: string;
+    };
+    'in-given-type-mismatch': {
+        lhsType: string;
+        elementType: string;
+    };
+    'inline-no-default': {
+        name: string;
+    };
+    'inline-bad-operator': {
+        name: string;
+        operators: string;
+    };
+    'invalid-given-modifier': {
+        modifier: string;
+    };
     'illegal-filter-type': string;
     'invalid-source-from-given': string;
     'aggregate-analytic-in-select': string;

package/dist/lang/parse-log.js

@@ -95,6 +95,12 @@ exports.MESSAGE_FORMATTERS = {
     'case-else-type-does-not-match': e => `Case else type ${e.elseType} does not match return type ${e.returnType}`,
     'case-when-must-be-boolean': e => `Case when expression must be boolean, not ${e.whenType}`,
     'case-when-type-does-not-match': e => `Case when type ${e.whenType} does not match value type ${e.valueType}`,
+    'in-given-rhs-not-array': e => `\`in $${e.givenName}\` requires \`${e.givenName}\` to be an array , but it is \`${e.actualType}\``,
+    'in-given-rhs-not-basic-array': e => `\`in $${e.givenName}\` requires \`${e.givenName}\` to be an array of a basic type (string, number, etc.), but its element type is \`${e.elementType}\``,
+    'in-given-type-mismatch': e => `\`in\` left-hand side type \`${e.lhsType}\` does not match the array element type \`${e.elementType}\``,
+    'inline-no-default': e => `inline given \`${e.name}\` must have a value — there is nothing to inline without one`,
+    'inline-bad-operator': e => `inline given \`${e.name}\` uses operator(s) not allowed in inline expressions: ${e.operators}`,
+    'invalid-given-modifier': e => `Unknown modifier \`${e.modifier}\` on \`given:\` declaration; the only modifier allowed here is \`inline\``,
 };
 function makeLogMessage(code, parameters, options) {
     var _a, _b, _c, _d, _e;

package/dist/lang/test/expr-to-str.js

@@ -82,6 +82,9 @@ function exprToStr(e, symbols) {
                 .map(o => `${subExpr(o)}`)
                 .join(',')}}}`;
         }
+        case 'inGiven': {
+            return `{${subExpr(e.e)} ${e.not ? 'not in' : 'in'} $${e.givenRef.refName}}`;
+        }
         case 'genericSQLExpr': {
             let sql = '';
             let i = 0;

package/dist/model/expression_compiler.js

@@ -185,6 +185,23 @@ function compileExpr(resultSet, context, expr, state = new utils_1.GenerateState
                 const oneOf = expr.kids.oneOf.map(o => o.sql).join(',');
                 return `${expr.kids.e.sql} ${expr.not ? 'NOT IN' : 'IN'} (${oneOf})`;
             }
+            case 'inGiven': {
+                const bound = resolveGivenBoundExpr(context, expr.givenRef.id, expr.givenRef.refName);
+                // null binding collapses to empty-set semantics — not the SQL
+                // `IN (NULL)` shape, which has confusing NULL-membership rules.
+                if (bound.node === 'null') {
+                    return expr.not ? 'TRUE' : 'FALSE';
+                }
+                if (bound.node !== 'arrayLiteral') {
+                    throw new Error(`Internal compiler error: 'inGiven' bound to '${bound.node}', expected 'arrayLiteral'. The translator should have rejected a non-array given here.`);
+                }
+                if (bound.kids.values.length === 0) {
+                    return expr.not ? 'TRUE' : 'FALSE';
+                }
+                const elemSqls = bound.kids.values.map(v => exprToSQL(resultSet, context, v, state));
+                const verb = expr.not ? 'NOT IN' : 'IN';
+                return `${expr.e.sql} ${verb} (${elemSqls.join(',')})`;
+            }
             case 'like':
             case '!like': {
                 const likeIt = expr.node === 'like' ? 'LIKE' : 'NOT LIKE';
@@ -599,20 +616,30 @@ function generateParameterFragment(resultSet, context, expr, state) {
     }
     throw new Error(`Can't generate SQL, no value for ${expr.path}`);
 }
-function generateGivenFragment(resultSet, context, expr, state) {
+/**
+ * Resolve a given to the Expr that should stand in for it at SQL emit:
+ * supplied value if the caller bound one, otherwise the declaration's
+ * default. Throws when neither is available — that case is a query the
+ * compiler can't satisfy.
+ *
+ * Shared by `generateGivenFragment` ($NAME directly in an expression)
+ * and the `'inGiven'` SQL-emit case ($ARR in `expr in $ARR`).
+ */
+function resolveGivenBoundExpr(context, id, refName) {
     var _a, _b;
-    const id = expr.id;
     const supplied = (_b = (_a = context.prepareResultOptions) === null || _a === void 0 ? void 0 : _a.resolvedGivens) === null || _b === void 0 ? void 0 : _b.get(id);
-    if (supplied !== undefined) {
-        return exprToSQL(resultSet, context, supplied, state);
-    }
-    // The default may itself be a `$OTHER`-bearing expression — recursive
-    // compile handles default chains.
+    if (supplied !== undefined)
+        return supplied;
     const decl = context.getModel().givens[id];
-    if ((decl === null || decl === void 0 ? void 0 : decl.default) !== undefined) {
-        return exprToSQL(resultSet, context, decl.default, state);
-    }
-    throw new Error(unsatisfiedGivenMessage(expr.refName));
+    if ((decl === null || decl === void 0 ? void 0 : decl.default) !== undefined)
+        return decl.default;
+    throw new Error(unsatisfiedGivenMessage(refName));
+}
+function generateGivenFragment(resultSet, context, expr, state) {
+    // The bound expr may itself be a `$OTHER`-bearing expression; recursive
+    // compile handles default chains.
+    const bound = resolveGivenBoundExpr(context, expr.id, expr.refName);
+    return exprToSQL(resultSet, context, bound, state);
 }
 function unsatisfiedGivenMessage(refName) {
     return (`Given '${refName}' has no value and no default. ` +

package/dist/model/given_binding.d.ts

@@ -1,2 +1,17 @@
 import type { Expr, GivenID, GivenValue, ModelDef } from './malloy_types';
 export declare function resolveSuppliedGivens(supplied: Record<string, GivenValue> | undefined, modelDef: ModelDef | undefined): Map<GivenID, Expr>;
+/**
+ * Evaluate every `inline` given's default to a literal Expr and add it
+ * to the bound map. Mutates and returns `bound` for convenience.
+ *
+ * Givens already in `bound` (caller supplied a value) are left alone —
+ * the caller's value wins over the inline default. Inline givens with
+ * no default are skipped here; the translator already logged the
+ * `inline-no-default` error at declaration time.
+ *
+ * Iteration follows `modelDef.contents` insertion order, which (by
+ * Malloy's no-forward-refs rule) is also topological order: if inline
+ * A's default references inline B, B's declaration came first and is
+ * already in the map by the time A runs.
+ */
+export declare function evaluateInlineGivens(bound: Map<GivenID, Expr>, modelDef: ModelDef | undefined): Map<GivenID, Expr>;

package/dist/model/given_binding.js

@@ -5,8 +5,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveSuppliedGivens = resolveSuppliedGivens;
+exports.evaluateInlineGivens = evaluateInlineGivens;
 const luxon_1 = require("luxon");
 const closest_match_1 = require("../util/closest_match");
+const inline_expr_1 = require("./inline_expr");
 const malloy_types_1 = require("./malloy_types");
 function resolveSuppliedGivens(supplied, modelDef) {
     var _a;
@@ -43,6 +45,39 @@ function resolveSuppliedGivens(supplied, modelDef) {
     }
     return out;
 }
+/**
+ * Evaluate every `inline` given's default to a literal Expr and add it
+ * to the bound map. Mutates and returns `bound` for convenience.
+ *
+ * Givens already in `bound` (caller supplied a value) are left alone —
+ * the caller's value wins over the inline default. Inline givens with
+ * no default are skipped here; the translator already logged the
+ * `inline-no-default` error at declaration time.
+ *
+ * Iteration follows `modelDef.contents` insertion order, which (by
+ * Malloy's no-forward-refs rule) is also topological order: if inline
+ * A's default references inline B, B's declaration came first and is
+ * already in the map by the time A runs.
+ */
+function evaluateInlineGivens(bound, modelDef) {
+    var _a;
+    if (!modelDef)
+        return bound;
+    const givens = (_a = modelDef.givens) !== null && _a !== void 0 ? _a : {};
+    for (const [, entry] of Object.entries(modelDef.contents)) {
+        if (entry.type !== 'given')
+            continue;
+        if (bound.has(entry.id))
+            continue;
+        const decl = givens[entry.id];
+        if (!(decl === null || decl === void 0 ? void 0 : decl.inline))
+            continue;
+        if (decl.default === undefined)
+            continue;
+        bound.set(entry.id, (0, inline_expr_1.inlineExpr)(decl.default, bound));
+    }
+    return bound;
+}
 function valueToExpr(path, type, value) {
     var _a, _b;
     if (value === null) {

package/dist/model/inline_expr.d.ts

@@ -0,0 +1,30 @@
+import type { Expr, GivenID } from './malloy_types';
+/**
+ * Operator node types allowed inside an `inline` given's default. Single
+ * source of truth — both the translator-side validator
+ * (`GivenDeclaration.execute`) and the bind-time evaluator below read
+ * this set when deciding whether an expression is reducible to a
+ * literal at bind time.
+ *
+ * Add a new operator here AND a corresponding `case` to `inlineExpr`'s
+ * switch in the same commit; the two are intentionally co-located so
+ * they can't drift apart.
+ */
+export declare const INLINE_OPS: ReadonlySet<string>;
+/**
+ * Leaf-shaped node types that are valid inside an inline expression but
+ * aren't "operators." Literals are returned as-is by the evaluator;
+ * `given` nodes resolve through the bound values map.
+ */
+export declare const INLINE_LEAVES: ReadonlySet<string>;
+/**
+ * Bind-time evaluator for `inline` given defaults. Walks the Expr tree,
+ * recursing on bound values for given-refs, and returns a literal Expr
+ * (string/number/boolean/null/arrayLiteral).
+ *
+ * Throws on any node outside `INLINE_OPS ∪ INLINE_LEAVES`. The
+ * translator's pre-flight check should have rejected such defaults
+ * already, so a throw here flags a compiler bug rather than a caller
+ * error.
+ */
+export declare function inlineExpr(e: Expr, bound: Map<GivenID, Expr>): Expr;

package/dist/model/inline_expr.js

@@ -0,0 +1,184 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INLINE_LEAVES = exports.INLINE_OPS = void 0;
+exports.inlineExpr = inlineExpr;
+/**
+ * Operator node types allowed inside an `inline` given's default. Single
+ * source of truth — both the translator-side validator
+ * (`GivenDeclaration.execute`) and the bind-time evaluator below read
+ * this set when deciding whether an expression is reducible to a
+ * literal at bind time.
+ *
+ * Add a new operator here AND a corresponding `case` to `inlineExpr`'s
+ * switch in the same commit; the two are intentionally co-located so
+ * they can't drift apart.
+ */
+exports.INLINE_OPS = new Set([
+    'and',
+    'or',
+    'not',
+    '=',
+    '!=',
+    '>',
+    '<',
+    '>=',
+    '<=',
+    'inGiven',
+    '()',
+]);
+/**
+ * Leaf-shaped node types that are valid inside an inline expression but
+ * aren't "operators." Literals are returned as-is by the evaluator;
+ * `given` nodes resolve through the bound values map.
+ */
+exports.INLINE_LEAVES = new Set([
+    'stringLiteral',
+    'numberLiteral',
+    'true',
+    'false',
+    'null',
+    'arrayLiteral',
+    'given',
+]);
+/**
+ * Bind-time evaluator for `inline` given defaults. Walks the Expr tree,
+ * recursing on bound values for given-refs, and returns a literal Expr
+ * (string/number/boolean/null/arrayLiteral).
+ *
+ * Throws on any node outside `INLINE_OPS ∪ INLINE_LEAVES`. The
+ * translator's pre-flight check should have rejected such defaults
+ * already, so a throw here flags a compiler bug rather than a caller
+ * error.
+ */
+function inlineExpr(e, bound) {
+    switch (e.node) {
+        case 'stringLiteral':
+        case 'numberLiteral':
+        case 'true':
+        case 'false':
+        case 'null':
+        case 'arrayLiteral':
+            return e;
+        case 'given': {
+            const v = bound.get(e.id);
+            if (v === undefined) {
+                throw new Error(`inlineExpr: given '${e.refName}' has no bound value and no default — translator should have caught this earlier`);
+            }
+            return inlineExpr(v, bound);
+        }
+        case '()':
+            return inlineExpr(e.e, bound);
+        case 'not': {
+            const inner = inlineExpr(e.e, bound);
+            return toBoolLiteral(!exprAsBool(inner));
+        }
+        case 'and':
+        case 'or': {
+            const left = exprAsBool(inlineExpr(e.kids.left, bound));
+            const right = exprAsBool(inlineExpr(e.kids.right, bound));
+            return toBoolLiteral(e.node === 'and' ? left && right : left || right);
+        }
+        case '=':
+        case '!=':
+        case '>':
+        case '<':
+        case '>=':
+        case '<=': {
+            const left = inlineExpr(e.kids.left, bound);
+            const right = inlineExpr(e.kids.right, bound);
+            return toBoolLiteral(compareLiterals(e.node, left, right));
+        }
+        case 'inGiven': {
+            const lhs = inlineExpr(e.e, bound);
+            const arrBound = bound.get(e.givenRef.id);
+            if (arrBound === undefined) {
+                throw new Error(`inlineExpr: given '${e.givenRef.refName}' has no bound value and no default — translator should have caught this earlier`);
+            }
+            if (arrBound.node === 'null') {
+                return toBoolLiteral(e.not);
+            }
+            if (arrBound.node !== 'arrayLiteral') {
+                throw new Error(`inlineExpr: 'inGiven' bound to '${arrBound.node}', expected 'arrayLiteral'`);
+            }
+            const found = arrBound.kids.values.some(v => compareLiterals('=', lhs, inlineExpr(v, bound)));
+            return toBoolLiteral(e.not ? !found : found);
+        }
+        default:
+            throw new Error(`inlineExpr: unexpected node '${e.node}' — translator should have rejected this`);
+    }
+}
+function toBoolLiteral(b) {
+    return { node: b ? 'true' : 'false' };
+}
+/**
+ * Read a literal Expr as a JS boolean. The evaluator only ever produces
+ * 'true' / 'false' / 'null' / scalar literals here; anything else means
+ * we tried to use a non-boolean where a boolean was expected, which is a
+ * translator type-check bug.
+ */
+function exprAsBool(e) {
+    if (e.node === 'true')
+        return true;
+    if (e.node === 'false')
+        return false;
+    // `null` in boolean position is treated as false — matches the
+    // implicit SQL coalesce that Malloy does for filter expressions.
+    if (e.node === 'null')
+        return false;
+    throw new Error(`inlineExpr: expected boolean literal, got '${e.node}' — translator should have type-checked this`);
+}
+/**
+ * JS-side comparison of two literal Exprs. Only the literal nodes
+ * produced by the evaluator are supported.
+ *
+ * SQL nullability: any operand being null produces false (matching
+ * Malloy's COALESCE-to-true / COALESCE-to-false behavior elsewhere).
+ */
+function compareLiterals(op, left, right) {
+    if (left.node === 'null' || right.node === 'null') {
+        // Mirror SQL: comparisons with NULL are unknown; treat as false for
+        // = / > / < / >= / <=, true for !=.
+        return op === '!=';
+    }
+    const l = literalToJS(left);
+    const r = literalToJS(right);
+    switch (op) {
+        case '=':
+            return l === r;
+        case '!=':
+            return l !== r;
+        case '>':
+            return l > r;
+        case '<':
+            return l < r;
+        case '>=':
+            return l >= r;
+        case '<=':
+            return l <= r;
+    }
+}
+/**
+ * Convert a literal Expr to a comparable JS value. Numbers come through
+ * `numberLiteral` as a string (full precision preserved); we parse to a
+ * JS number for ordering — bind-time precision loss here is fine
+ * because the result of an inline expression is a boolean for SQL.
+ */
+function literalToJS(e) {
+    switch (e.node) {
+        case 'stringLiteral':
+            return e.literal;
+        case 'numberLiteral':
+            return Number(e.literal);
+        case 'true':
+            return true;
+        case 'false':
+            return false;
+        default:
+            throw new Error(`inlineExpr: cannot compare non-literal node '${e.node}'`);
+    }
+}
+//# sourceMappingURL=inline_expr.js.map

package/dist/model/malloy_types.d.ts

@@ -36,7 +36,7 @@ export type AnyExpr = ExprE | ExprOptionalE | ExprWithKids | ExprLeaf;
 export declare function exprHasKids(e: AnyExpr): e is ExprWithKids;
 export declare function exprHasE(e: AnyExpr): e is ExprE;
 export declare function exprIsLeaf(e: AnyExpr): boolean;
-export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | GivenRefNode | NowNode | MeasureTimeExpr | TimeExtractExpr | TimeDeltaExpr | TimeTruncExpr | DateLiteralNode | TimestampLiteralNode | TimestamptzLiteralNode | TypecastExpr | RegexMatchExpr | RegexLiteralNode | FilterMatchExpr | FilterLiteralExpr | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | RecordLiteralNode | ArrayLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | CaseExpr | InCompareExpr | CompositeFieldExpr | ErrorNode;
+export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | GivenRefNode | NowNode | MeasureTimeExpr | TimeExtractExpr | TimeDeltaExpr | TimeTruncExpr | DateLiteralNode | TimestampLiteralNode | TimestamptzLiteralNode | TypecastExpr | RegexMatchExpr | RegexLiteralNode | FilterMatchExpr | FilterLiteralExpr | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | RecordLiteralNode | ArrayLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | CaseExpr | InCompareExpr | InGivenExpr | CompositeFieldExpr | ErrorNode;
 export type BinaryOperator = '+' | '-' | '*' | '%' | '/' | 'and' | 'or' | '=' | '!=' | '>' | '<' | '>=' | '<=' | 'coalesce' | 'like' | '!like';
 export interface BinaryExpr extends ExprWithKids {
     node: BinaryOperator;
@@ -289,6 +289,19 @@ export interface InCompareExpr extends ExprWithKids {
         oneOf: Expr[];
     };
 }
+/**
+ * Test against a runtime-bound array given: `expr in $ARRAY_GIVEN`.
+ *
+ * Uses ExprE (one child `e`, the LHS). The given reference is embedded
+ * as a top-level field rather than a kid so the auto-visitor in
+ * `compileExpr` doesn't descend into it; resolution and per-element
+ * SQL emission happen in the `case 'inGiven':` handler.
+ */
+export interface InGivenExpr extends ExprE {
+    node: 'inGiven';
+    not: boolean;
+    givenRef: GivenRefNode;
+}
 export type ExpressionType = 'scalar' | 'aggregate' | 'scalar_analytic' | 'aggregate_analytic' | 'ungrouped_aggregate';
 export interface Expression {
     e?: Expr;
@@ -341,6 +354,11 @@ export interface Given extends HasLocation, HasAnnotation {
      *  its own default. Empty/undefined when the default is a closed
      *  literal. */
     givenUsage?: GivenUsage;
+    /** Marked with the `inline` modifier — the default is eager-evaluated
+     *  to a literal at bind time and substituted as that literal in SQL.
+     *  Translator validates the default is eager-evaluable; bind-time
+     *  evaluator (`model/inline_expr.ts`) performs the reduction. */
+    inline?: boolean;
 }
 export interface GivenEntry {
     type: 'given';

package/dist/model/query_query.d.ts

@@ -103,7 +103,7 @@ export declare class QueryQuery extends QueryField {
     generateTurtlePipelineSQL(fi: FieldInstanceResult, stageWriter: StageWriter, sourceSQLExpression: string): {
         structDef: QueryResultDef;
         pipeOut: any;
-        repeatedResultType: "nested" | "inline_all_numbers" | "inline";
+        repeatedResultType: "inline" | "nested" | "inline_all_numbers";
     };
     generateComplexSQL(stageWriter: StageWriter): string;
     generateSQL(stageWriter: StageWriter): string;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.392";
+export declare const MALLOY_VERSION = "0.0.394";

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.392';
+exports.MALLOY_VERSION = '0.0.394';
 //# sourceMappingURL=version.js.map