@malloydata/malloy 0.0.405 → 0.0.407

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

@@ -161,6 +161,26 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
                             operators: [...bad].sort().join(', '),
                         });
                     }
+                    // An inline default may fold an unsupplied `$REF` to that
+                    // given's declared default, so every reachable regular default
+                    // must also be inline-reducible. The closure is flat; inline
+                    // members self-validate at their own declaration, so only
+                    // regular ones need checking here.
+                    for (const g of givenUsage !== null && givenUsage !== void 0 ? givenUsage : []) {
+                        const refDecl = doc.documentGivens.get(g.id);
+                        if (!refDecl || refDecl.inline || refDecl.default === undefined) {
+                            continue;
+                        }
+                        const refBad = new Set();
+                        collectInlineBadOps(refDecl.default, refBad);
+                        if (refBad.size > 0) {
+                            this.default.logError('inline-bad-operator-in-ref', {
+                                name: this.name,
+                                refName: refDecl.name,
+                                operators: [...refBad].sort().join(', '),
+                            });
+                        }
+                    }
                 }
             }
         }

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

@@ -315,6 +315,11 @@ type MessageParameterTypes = {
         name: string;
         operators: string;
     };
+    'inline-bad-operator-in-ref': {
+        name: string;
+        refName: string;
+        operators: string;
+    };
     'invalid-given-modifier': {
         modifier: string;
     };

package/dist/lang/parse-log.js

@@ -82,6 +82,7 @@ exports.MESSAGE_FORMATTERS = {
     '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}`,
+    'inline-bad-operator-in-ref': e => `inline given \`${e.name}\` references \`${e.refName}\`, whose default 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\``,
     'restricted-construct-forbidden': e => ({
         message: e,

package/dist/lang/parse-malloy.js

@@ -166,45 +166,37 @@ 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;
+        // A path can only be canonicalized once its dialect is known; references
+        // whose dialect isn't resolved yet are skipped and re-scanned next round.
+        // Invalid paths are dropped here and re-reported by the AST step.
+        // tableRequests feeds the missing-table loop below.
+        const tableRequests = {};
+        for (const rawKey in this.parseReferences.tables) {
+            const info = this.parseReferences.tables[rawKey];
+            const dialectName = that.root.connectionDialectZone.get(info.connectionName);
+            if (dialectName === undefined)
+                continue;
+            const result = (0, dialect_1.getDialect)(dialectName).sqlValidateTableName(info.tablePath);
+            if (!result.ok)
+                continue;
+            const key = `${info.connectionName}:${result.canonical}`;
+            tableRequests[key] = {
+                connectionName: info.connectionName,
+                tablePath: result.canonical,
+            };
+            that.root.schemaZone.reference(key, {
+                url: that.sourceURL,
+                range: info.firstReference,
+            });
         }
         const missingTables = that.root.schemaZone.getUndefined();
         if (missingTables) {
             const tables = {};
             for (const key of missingTables) {
-                const info = this.parseReferences.tables[key];
-                if (info === undefined)
+                const request = tableRequests[key];
+                if (request === undefined)
                     continue;
-                tables[key] = {
-                    connectionName: info.connectionName,
-                    tablePath: info.tablePath,
-                };
+                tables[key] = request;
             }
             if (Object.keys(tables).length > 0) {
                 allMissing = { tables };

package/dist/model/expression_compiler.js

@@ -30,6 +30,7 @@ const filter_compilers_1 = require("./filter_compilers");
 const utils_1 = require("./utils");
 const query_node_1 = require("./query_node");
 const malloy_compile_error_1 = require("./malloy_compile_error");
+const given_binding_1 = require("./given_binding");
 const NUMERIC_DECIMAL_PRECISION = 9;
 function sqlSumDistinct(dialect, sqlExp, sqlDistintKey) {
     const precision = 9;
@@ -628,13 +629,10 @@ function generateParameterFragment(resultSet, context, expr, state) {
  * and the `'inGiven'` SQL-emit case ($ARR in `expr in $ARR`).
  */
 function resolveGivenBoundExpr(context, ref) {
-    var _a, _b;
-    const supplied = (_b = (_a = context.prepareResultOptions) === null || _a === void 0 ? void 0 : _a.resolvedGivens) === null || _b === void 0 ? void 0 : _b.get(ref.id);
-    if (supplied !== undefined)
-        return supplied;
-    const decl = context.getModel().givens[ref.id];
-    if ((decl === null || decl === void 0 ? void 0 : decl.default) !== undefined)
-        return decl.default;
+    var _a;
+    const value = (0, given_binding_1.lookupGivenValue)((_a = context.prepareResultOptions) === null || _a === void 0 ? void 0 : _a.resolvedGivens, context.getModel().givens, ref.id);
+    if (value !== undefined)
+        return value;
     throw new malloy_compile_error_1.MalloyCompileError(unsatisfiedGivenMessage(ref.refName), 'compiler-given-no-value', ref.at);
 }
 function generateGivenFragment(resultSet, context, expr, state) {

package/dist/model/given_binding.d.ts

@@ -1,4 +1,13 @@
-import type { Expr, GivenID, GivenValue, ModelDef } from './malloy_types';
+import type { Expr, Given, GivenID, GivenValue, ModelDef } from './malloy_types';
+/**
+ * The one definition of "what value does a given reference stand for":
+ * the caller-supplied value if one is bound, otherwise the declaration
+ * default. Returns undefined when neither exists — callers decide how to
+ * report that, since the right diagnostic differs by site (a bind-time
+ * inline fold vs. SQL emission). Shared by `evaluateInlineGivens` here
+ * and `resolveGivenBoundExpr` in the compiler.
+ */
+export declare function lookupGivenValue(bound: Map<GivenID, Expr> | undefined, givens: Record<GivenID, Given> | undefined, id: GivenID): Expr | undefined;
 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
@@ -10,8 +19,11 @@ export declare function resolveSuppliedGivens(supplied: Record<string, GivenValu
  * `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.
+ * Malloy's no-forward-refs rule) is also topological order. An inline
+ * default that references another inline given relies on this: the
+ * referenced one was declared first, so it is already folded into
+ * `bound` by the time this one reads it. A reference to a regular given
+ * resolves straight to its supplied value or declaration default (see
+ * `resolveGiven`), which needs no ordering.
  */
 export declare function evaluateInlineGivens(bound: Map<GivenID, Expr>, modelDef: ModelDef | undefined): Map<GivenID, Expr>;

package/dist/model/given_binding.js

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupGivenValue = lookupGivenValue;
 exports.resolveSuppliedGivens = resolveSuppliedGivens;
 exports.evaluateInlineGivens = evaluateInlineGivens;
 const luxon_1 = require("luxon");
@@ -11,6 +12,18 @@ const closest_match_1 = require("../util/closest_match");
 const inline_expr_1 = require("./inline_expr");
 const malloy_types_1 = require("./malloy_types");
 const malloy_compile_error_1 = require("./malloy_compile_error");
+/**
+ * The one definition of "what value does a given reference stand for":
+ * the caller-supplied value if one is bound, otherwise the declaration
+ * default. Returns undefined when neither exists — callers decide how to
+ * report that, since the right diagnostic differs by site (a bind-time
+ * inline fold vs. SQL emission). Shared by `evaluateInlineGivens` here
+ * and `resolveGivenBoundExpr` in the compiler.
+ */
+function lookupGivenValue(bound, givens, id) {
+    var _a, _b;
+    return (_a = bound === null || bound === void 0 ? void 0 : bound.get(id)) !== null && _a !== void 0 ? _a : (_b = givens === null || givens === void 0 ? void 0 : givens[id]) === null || _b === void 0 ? void 0 : _b.default;
+}
 function resolveSuppliedGivens(supplied, modelDef) {
     var _a;
     const out = new Map();
@@ -57,15 +70,28 @@ function resolveSuppliedGivens(supplied, modelDef) {
  * `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.
+ * Malloy's no-forward-refs rule) is also topological order. An inline
+ * default that references another inline given relies on this: the
+ * referenced one was declared first, so it is already folded into
+ * `bound` by the time this one reads it. A reference to a regular given
+ * resolves straight to its supplied value or declaration default (see
+ * `resolveGiven`), which needs no ordering.
  */
 function evaluateInlineGivens(bound, modelDef) {
     var _a;
     if (!modelDef)
         return bound;
     const givens = (_a = modelDef.givens) !== null && _a !== void 0 ? _a : {};
+    // A `$REF` in an inline default resolves to its supplied value, else
+    // its declaration default; a reference with neither is a caller error.
+    // `bound` is read live, so a given folded earlier in the loop is
+    // visible to one folded later.
+    const resolveGiven = (id, refName) => {
+        const v = lookupGivenValue(bound, givens, id);
+        if (v !== undefined)
+            return v;
+        throw new malloy_compile_error_1.MalloyCompileError(`Inline given depends on '${refName}', which has no supplied value and no default. Supply a value for '${refName}' or give it a declaration default.`, 'runtime-given-unsatisfied-inline', undefined);
+    };
     for (const [, entry] of Object.entries(modelDef.contents)) {
         if (entry.type !== 'given')
             continue;
@@ -76,7 +102,7 @@ function evaluateInlineGivens(bound, modelDef) {
             continue;
         if (decl.default === undefined)
             continue;
-        bound.set(entry.id, (0, inline_expr_1.inlineExpr)(decl.default, bound));
+        bound.set(entry.id, (0, inline_expr_1.inlineExpr)(decl.default, resolveGiven));
     }
     return bound;
 }

package/dist/model/inline_expr.d.ts

@@ -18,13 +18,19 @@ export declare const INLINE_OPS: ReadonlySet<string>;
  */
 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).
+ * Bind-time evaluator for `inline` given defaults. Walks the Expr tree
+ * and returns a literal Expr (string/number/boolean/null/arrayLiteral).
+ *
+ * A pure folder: it does not know how given references get their values.
+ * `resolveGiven` is handed a given reference's id and surface name (both
+ * a `$NAME` ref and the array of an `expr in $NAME`) and returns the Expr
+ * that reference stands for — caller-supplied value, declaration default,
+ * or a thrown error if neither. That policy lives with the caller
+ * (`given_binding.ts`), not here — see `lookupGivenValue`.
  *
  * 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;
+export declare function inlineExpr(e: Expr, resolveGiven: (id: GivenID, refName: string) => Expr): Expr;

package/dist/model/inline_expr.js

@@ -45,16 +45,22 @@ exports.INLINE_LEAVES = new Set([
     '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).
+ * Bind-time evaluator for `inline` given defaults. Walks the Expr tree
+ * and returns a literal Expr (string/number/boolean/null/arrayLiteral).
+ *
+ * A pure folder: it does not know how given references get their values.
+ * `resolveGiven` is handed a given reference's id and surface name (both
+ * a `$NAME` ref and the array of an `expr in $NAME`) and returns the Expr
+ * that reference stands for — caller-supplied value, declaration default,
+ * or a thrown error if neither. That policy lives with the caller
+ * (`given_binding.ts`), not here — see `lookupGivenValue`.
  *
  * 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) {
+function inlineExpr(e, resolveGiven) {
     switch (e.node) {
         case 'stringLiteral':
         case 'numberLiteral':
@@ -63,23 +69,18 @@ function inlineExpr(e, bound) {
         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 'given':
+            return inlineExpr(resolveGiven(e.id, e.refName), resolveGiven);
         case '()':
-            return inlineExpr(e.e, bound);
+            return inlineExpr(e.e, resolveGiven);
         case 'not': {
-            const inner = inlineExpr(e.e, bound);
+            const inner = inlineExpr(e.e, resolveGiven);
             return toBoolLiteral(!exprAsBool(inner));
         }
         case 'and':
         case 'or': {
-            const left = exprAsBool(inlineExpr(e.kids.left, bound));
-            const right = exprAsBool(inlineExpr(e.kids.right, bound));
+            const left = exprAsBool(inlineExpr(e.kids.left, resolveGiven));
+            const right = exprAsBool(inlineExpr(e.kids.right, resolveGiven));
             return toBoolLiteral(e.node === 'and' ? left && right : left || right);
         }
         case '=':
@@ -88,23 +89,20 @@ function inlineExpr(e, bound) {
         case '<':
         case '>=':
         case '<=': {
-            const left = inlineExpr(e.kids.left, bound);
-            const right = inlineExpr(e.kids.right, bound);
+            const left = inlineExpr(e.kids.left, resolveGiven);
+            const right = inlineExpr(e.kids.right, resolveGiven);
             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') {
+            const lhs = inlineExpr(e.e, resolveGiven);
+            const arr = inlineExpr(resolveGiven(e.givenRef.id, e.givenRef.refName), resolveGiven);
+            if (arr.node === 'null') {
                 return toBoolLiteral(e.not);
             }
-            if (arrBound.node !== 'arrayLiteral') {
-                throw new Error(`inlineExpr: 'inGiven' bound to '${arrBound.node}', expected 'arrayLiteral'`);
+            if (arr.node !== 'arrayLiteral') {
+                throw new Error(`inlineExpr: 'inGiven' resolved to '${arr.node}', expected 'arrayLiteral'`);
             }
-            const found = arrBound.kids.values.some(v => compareLiterals('=', lhs, inlineExpr(v, bound)));
+            const found = arr.kids.values.some(v => compareLiterals('=', lhs, inlineExpr(v, resolveGiven)));
             return toBoolLiteral(e.not ? !found : found);
         }
         default:

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.405";
+export declare const MALLOY_VERSION = "0.0.407";

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.405",
+  "version": "0.0.407",
   "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.405",
-    "@malloydata/malloy-interfaces": "0.0.405",
-    "@malloydata/malloy-tag": "0.0.405",
+    "@malloydata/malloy-filter": "0.0.407",
+    "@malloydata/malloy-interfaces": "0.0.407",
+    "@malloydata/malloy-tag": "0.0.407",
     "@noble/hashes": "^1.8.0",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",