@malloydata/malloy 0.0.393 → 0.0.395

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

@@ -275,6 +275,7 @@ type MessageParameterTypes = {
     'parameter-name-conflict': string;
     'parameter-shadowing-field': string;
     'invalid-import-url': string;
+    'invalid-table-path': string;
     'no-translator-for-import': string;
     'name-conflict-on-selective-import': string;
     'selective-import-not-found': string;
@@ -292,6 +293,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/parse-malloy.js

@@ -61,6 +61,7 @@ const ast = __importStar(require("./ast"));
 const malloy_to_ast_1 = require("./malloy-to-ast");
 const parse_log_1 = require("./parse-log");
 const find_external_references_1 = require("./parse-tree-walkers/find-external-references");
+const dialect_1 = require("../dialect");
 const zone_1 = require("./zone");
 const document_symbol_walker_1 = require("./parse-tree-walkers/document-symbol-walker");
 const document_completion_walker_1 = require("./parse-tree-walkers/document-completion-walker");
@@ -140,12 +141,9 @@ class ImportsAndTablesStep {
         }
         if (!this.parseReferences) {
             this.parseReferences = (0, find_external_references_1.findReferences)(that, parseReq.parse.tokenStream, parseReq.parse.root);
-            for (const ref in this.parseReferences.tables) {
-                that.root.schemaZone.reference(ref, {
-                    url: that.sourceURL,
-                    range: this.parseReferences.tables[ref].firstReference,
-                });
-            }
+            // Register connection dialects and imports immediately. Table
+            // references are deferred until dialects are resolved, because
+            // validating a table path requires knowing its dialect's grammar.
             for (const connName in this.parseReferences.connectionDialects) {
                 that.root.connectionDialectZone.reference(connName, {
                     url: that.sourceURL,
@@ -180,17 +178,49 @@ class ImportsAndTablesStep {
             return { timingInfo: parseReq.timingInfo };
         }
         let allMissing = {};
+        // Validate each table reference against its dialect's grammar (if
+        // the dialect is resolved) and register the canonical entry. Bad
+        // paths are silently dropped — the AST step re-validates and logs
+        // an error at the precise source range. Entries whose dialect
+        // isn't resolved yet are preserved unchanged and re-processed on a
+        // later step.
+        {
+            const refs = this.parseReferences.tables;
+            const canonical = {};
+            for (const rawKey in refs) {
+                const info = refs[rawKey];
+                let { tablePath } = info;
+                const dialectName = that.root.connectionDialectZone.get(info.connectionName);
+                if (dialectName !== undefined) {
+                    const result = (0, dialect_1.getDialect)(dialectName).sqlValidateTableName(tablePath);
+                    if (!result.ok)
+                        continue;
+                    tablePath = result.canonical;
+                }
+                const key = `${info.connectionName}:${tablePath}`;
+                canonical[key] = { ...info, tablePath };
+                that.root.schemaZone.reference(key, {
+                    url: that.sourceURL,
+                    range: info.firstReference,
+                });
+            }
+            this.parseReferences.tables = canonical;
+        }
         const missingTables = that.root.schemaZone.getUndefined();
         if (missingTables) {
             const tables = {};
             for (const key of missingTables) {
                 const info = this.parseReferences.tables[key];
+                if (info === undefined)
+                    continue;
                 tables[key] = {
                     connectionName: info.connectionName,
                     tablePath: info.tablePath,
                 };
             }
-            allMissing = { tables };
+            if (Object.keys(tables).length > 0) {
+                allMissing = { tables };
+            }
         }
         const missingDialects = that.root.connectionDialectZone.getUndefined();
         if (missingDialects) {

package/dist/lang/parse-tree-walkers/find-external-references.d.ts

@@ -4,27 +4,14 @@ import type { DocumentRange } from '../../model/malloy_types';
 import type { MalloyTranslation } from '../parse-malloy';
 type NeedImports = Record<string, DocumentRange>;
 type NeedTables = Record<string, {
-    connectionName: string | undefined;
+    connectionName: string;
     tablePath: string;
     firstReference: DocumentRange;
 }>;
 type NeedConnectionDialects = Record<string, {
     firstReference: DocumentRange;
 }>;
-export declare function constructTableKey(connectionName: string | undefined, tablePath: string): string;
-/**
- * This function parses an old-style `tableURI` into a connection name and
- * table path. The name includes `deprecated` because it should only be used
- * in the (deprecated) old-style `table('conn:tab')` syntax. Any use of this
- * anywhere else is bad.
- * @param tableURI The sting that is passed into the `table('conn:tab')` syntax.
- * @returns A connection name and table path.
- * @deprecated
- */
-export declare function deprecatedParseTableURI(tableURI: string): {
-    connectionName?: string;
-    tablePath: string;
-};
+export declare function constructTableKey(connectionName: string, tablePath: string): string;
 export interface FindReferencesData {
     tables: NeedTables;
     urls: NeedImports;

package/dist/lang/parse-tree-walkers/find-external-references.js

@@ -23,7 +23,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.constructTableKey = constructTableKey;
-exports.deprecatedParseTableURI = deprecatedParseTableURI;
 exports.findReferences = findReferences;
 const ParseTreeWalker_1 = require("antlr4ts/tree/ParseTreeWalker");
 const parse_utils_1 = require("../parse-utils");
@@ -70,6 +69,11 @@ class FindExternalReferences {
         const tablePath = getPlainString(pcx.tablePath());
         const reference = this.trans.rangeFromContext(pcx);
         this.registerTableReference(connId, tablePath, reference);
+        // Register a need for the connection's dialect so the validator in
+        // ImportsAndTablesStep can run against it.
+        if (!this.needConnectionDialects[connId]) {
+            this.needConnectionDialects[connId] = { firstReference: reference };
+        }
     }
     enterVirtualSource(pcx) {
         const connId = (0, parse_utils_1.getId)(pcx.connectionId());
@@ -87,28 +91,7 @@ class FindExternalReferences {
     }
 }
 function constructTableKey(connectionName, tablePath) {
-    return connectionName === undefined
-        ? tablePath
-        : `${connectionName}:${tablePath}`;
-}
-/**
- * This function parses an old-style `tableURI` into a connection name and
- * table path. The name includes `deprecated` because it should only be used
- * in the (deprecated) old-style `table('conn:tab')` syntax. Any use of this
- * anywhere else is bad.
- * @param tableURI The sting that is passed into the `table('conn:tab')` syntax.
- * @returns A connection name and table path.
- * @deprecated
- */
-function deprecatedParseTableURI(tableURI) {
-    const parts = tableURI.match(/^([^:]*):(.*)$/);
-    if (parts) {
-        const [, firstPart, secondPart] = parts;
-        return { connectionName: firstPart, tablePath: secondPart };
-    }
-    else {
-        return { tablePath: tableURI };
-    }
+    return `${connectionName}:${tablePath}`;
 }
 function findReferences(trans, tokens, parseTree) {
     const finder = new FindExternalReferences(trans, tokens);

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/lang/translate-response.d.ts

@@ -22,7 +22,7 @@ export interface ProblemResponse {
 export type FatalResponse = FinalResponse & ProblemResponse;
 export interface NeedSchemaData {
     tables: Record<string, {
-        connectionName: string | undefined;
+        connectionName: string;
         tablePath: string;
     }>;
 }

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/filter_compilers.js

@@ -129,7 +129,7 @@ exports.FilterCompilers = {
         // For some databases checking NULL combined with a boolean check
         // is faster than a COALESCE, for now, just detect if the expression
         // is just a column reference, and if so, don't use COALECSE.
-        const quoteChar = d.sqlMaybeQuoteIdentifier('select')[0];
+        const quoteChar = d.sqlQuoteIdentifier('select')[0];
         const isColumn = x.match(`^[()${quoteChar}\\w.]+$`);
         if (isColumn) {
             if (bc.operator === 'true') {

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;