@malloydata/malloy 0.0.394 → 0.0.396

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

@@ -92,10 +92,11 @@ const LEGAL_FILTER_TYPES = 'string, number, boolean, date, timestamp, timestampt
  * AST from an ANTLR parse tree.
  */
 class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
-    constructor(parseInfo, msgLog, compilerFlagSrc) {
+    constructor(parseInfo, msgLog, compilerFlagSrc, restrictedMode = false) {
         super();
         this.parseInfo = parseInfo;
         this.msgLog = msgLog;
+        this.restrictedMode = restrictedMode;
         this.timer = new timing_1.Timer('generate_ast');
         const parseCompilerFlagsTimer = new timing_1.Timer('parse_compiler_flags');
         this.compilerFlagSrc = [...DEFAULT_COMPILER_FLAGS, ...compilerFlagSrc];
@@ -1498,6 +1499,15 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     }
     updateCompilerFlags(tags) {
         const parseCompilerFlagsTimer = new timing_1.Timer('parse_compiler_flags');
+        if (this.restrictedMode) {
+            // `##!` lines in restricted text never become active flags. The
+            // user-facing rejection is logged at execute time (see
+            // ModelAnnotation.execute) so it doesn't short-circuit ASTStep,
+            // which lets every other restricted-mode violation in the same
+            // compile log its own diagnostic.
+            this.timer.contribute([parseCompilerFlagsTimer.stop()]);
+            return;
+        }
         const newLines = tags.getCompilerFlagLines();
         if (newLines.length > 0) {
             const oldLength = this.compilerFlagSrc.length;

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;
@@ -429,6 +430,7 @@ type MessageParameterTypes = {
     'missing-required-group-by': string;
     'invalid-partition-composite': string;
     'integer-literal-out-of-range': string;
+    'restricted-construct-forbidden': string;
 };
 export declare const MESSAGE_FORMATTERS: PartialErrorCodeMessageMap;
 export type MessageCode = keyof MessageParameterTypes;

package/dist/lang/parse-log.js

@@ -101,6 +101,10 @@ exports.MESSAGE_FORMATTERS = {
     '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\``,
+    'restricted-construct-forbidden': e => ({
+        message: e,
+        tag: 'restricted-mode',
+    }),
 };
 function makeLogMessage(code, parameters, options) {
     var _a, _b, _c, _d, _e;

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

@@ -193,6 +193,7 @@ export declare class MalloyChildTranslator extends MalloyTranslation {
  */
 export declare class MalloyTranslator extends MalloyTranslation {
     private readonly eventStream;
+    readonly restrictedMode: boolean;
     schemaZone: Zone<SourceDef>;
     importZone: Zone<string>;
     pretranslatedModels: Map<string, ModelDef>;
@@ -200,8 +201,10 @@ export declare class MalloyTranslator extends MalloyTranslation {
     connectionDialectZone: Zone<string>;
     logger: BaseMessageLogger;
     readonly root: MalloyTranslator;
-    constructor(rootURL: string, importURL?: string | null, preload?: ParseUpdate | null, eventStream?: EventStream | null);
+    constructor(rootURL: string, importURL?: string | null, preload?: ParseUpdate | null, eventStream?: EventStream | null, restrictedMode?: boolean);
     update(dd: ParseUpdate): void;
+    private lockZonesIfRestricted;
+    translate(extendingModel?: ModelDef): TranslateResponse;
     logError<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: Omit<LogMessageOptions, 'severity'>): T;
 }
 interface ErrorData {

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");
@@ -138,14 +139,17 @@ class ImportsAndTablesStep {
         if (parseReq.parse === undefined) {
             return parseReq;
         }
+        // Every reference this step would register — connection dialects,
+        // imports, table schemas — is for a construct that's forbidden in
+        // restricted code.
+        if (that.root.restrictedMode) {
+            return { timingInfo: parseReq.timingInfo };
+        }
         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 +184,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) {
@@ -248,7 +284,7 @@ class ASTStep {
             throw new Error('TRANSLATOR INTERNAL ERROR: Translator parse response had no errors, but also no parser');
         }
         stepTimer.incorporate(parseResponse.timingInfo);
-        const secondPass = new malloy_to_ast_1.MalloyToAST(parse, that.root.logger, that.compilerFlagSrc);
+        const secondPass = new malloy_to_ast_1.MalloyToAST(parse, that.root.logger, that.compilerFlagSrc, that.root.restrictedMode);
         const { ast: newAST, compilerFlagSrc, timingInfo } = secondPass.run();
         stepTimer.contribute([timingInfo]);
         that.compilerFlagSrc = compilerFlagSrc;
@@ -436,10 +472,13 @@ class TranslateStep {
                 modelWasModified: false,
             };
         }
-        // begin with the compiler flags of the model we are extending
+        // Layer the extending model's compiler flags on top of whatever was
+        // there already. In production the array starts empty so push vs.
+        // overwrite produce the same result; the push lets constructor-time
+        // seeding (e.g. TestTranslator's compilerFlags option) survive.
         if (extendingModel && !this.importedAnnotations) {
             const parseCompilerFlagsTimer = new timing_1.Timer('parse_compiler_flags');
-            that.compilerFlagSrc = (0, annotation_1.annotationToTaglines)(extendingModel.annotation, /^##! /);
+            that.compilerFlagSrc.push(...(0, annotation_1.annotationToTaglines)(extendingModel.annotation, /^##! /));
             stepTimer.contribute([parseCompilerFlagsTimer.stop()]);
             this.importedAnnotations = true;
         }
@@ -791,9 +830,10 @@ exports.MalloyChildTranslator = MalloyChildTranslator;
  * no need to call again, the translation is finished or error'd.
  */
 class MalloyTranslator extends MalloyTranslation {
-    constructor(rootURL, importURL = null, preload = null, eventStream = null) {
+    constructor(rootURL, importURL = null, preload = null, eventStream = null, restrictedMode = false) {
         super(rootURL, importURL);
         this.eventStream = eventStream;
+        this.restrictedMode = restrictedMode;
         this.schemaZone = new zone_1.Zone();
         this.importZone = new zone_1.Zone();
         this.pretranslatedModels = new Map();
@@ -815,6 +855,18 @@ class MalloyTranslator extends MalloyTranslation {
             this.pretranslatedModels.set(url, dd.translations[url]);
         }
     }
+    lockZonesIfRestricted() {
+        if (!this.restrictedMode)
+            return;
+        this.schemaZone.lock();
+        this.importZone.lock();
+        this.sqlQueryZone.lock();
+        this.connectionDialectZone.lock();
+    }
+    translate(extendingModel) {
+        this.lockZonesIfRestricted();
+        return super.translate(extendingModel);
+    }
     logError(code, parameters, options) {
         this.logger.log((0, parse_log_1.makeLogMessage)(code, parameters, { severity: 'error', ...options }));
         return code;

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/test-translator.d.ts

@@ -42,12 +42,27 @@ export declare class TestChildTranslator extends MalloyChildTranslator {
     translate(): TranslateResponse;
     addChild(url: string): void;
 }
+export interface TestTranslatorOptions {
+    rootRule?: string;
+    importBaseURL?: string | null;
+    eventStream?: EventStream | null;
+    internalModel?: ModelDef;
+    restrictedMode?: boolean;
+    /**
+     * Each entry is a compiler-flag tag fragment — the content that
+     * would follow `##! ` in a Malloy source annotation. Rendered to
+     * `##! <flag>\n` and pushed onto compilerFlagSrc before any
+     * TranslateStep seeding, so the flags are active during AST-build
+     * inExperiment() checks.
+     */
+    compilerFlags?: string[];
+}
 export declare class TestTranslator extends MalloyTranslator {
     readonly testSrc: string;
     allDialectsEnabled: boolean;
     testRoot?: TestRoot;
     internalModel: ModelDef;
-    constructor(testSrc: string, importBaseURL?: string | null, eventStream?: EventStream | null, rootRule?: string, internalModel?: ModelDef);
+    constructor(testSrc: string, options?: TestTranslatorOptions);
     translate(): TranslateResponse;
     addChild(url: string): void;
     ast(): MalloyElement | undefined;
@@ -64,7 +79,7 @@ export declare class TestTranslator extends MalloyTranslator {
 export declare class BetaExpression extends TestTranslator {
     readonly sourceName: string;
     private compiled?;
-    constructor(src: string, model?: ModelDef, sourceName?: string);
+    constructor(src: string, model?: ModelDef, sourceName?: string, options?: Omit<TestTranslatorOptions, 'rootRule' | 'internalModel'>);
     private testFS;
     compile(): void;
     generated(): ExprValue;
@@ -85,12 +100,11 @@ interface HasTranslator<TT extends TestTranslator> extends MarkedSource {
 }
 export declare function expr(unmarked: TemplateStringsArray, ...marked: string[]): HasTranslator<BetaExpression>;
 export declare function model(unmarked: TemplateStringsArray, ...marked: string[]): HasTranslator<TestTranslator>;
-export declare function makeModelFunc(options: {
-    model?: ModelDef;
+export declare function makeModelFunc(options: TestTranslatorOptions & {
     prefix?: string;
     wrap?: (code: string) => string;
 }): (unmarked: TemplateStringsArray, ...marked: string[]) => HasTranslator<TestTranslator>;
-export declare function makeExprFunc(model: ModelDef, sourceName: string): (unmarked: TemplateStringsArray, ...marked: string[]) => HasTranslator<TestTranslator>;
+export declare function makeExprFunc(model?: ModelDef, sourceName?: string, options?: Omit<TestTranslatorOptions, 'rootRule' | 'internalModel'>): (unmarked: TemplateStringsArray, ...marked: string[]) => HasTranslator<TestTranslator>;
 export declare function markSource(unmarked: TemplateStringsArray, ...marked: string[]): MarkedSource;
 export declare function getSelectOneStruct(sqlBlock: SQLSourceRequest): {
     [key: string]: SQLSourceDef;

package/dist/lang/test/test-translator.js

@@ -330,8 +330,9 @@ class TestChildTranslator extends parse_malloy_1.MalloyChildTranslator {
 exports.TestChildTranslator = TestChildTranslator;
 const testURI = 'internal://test/langtests/root.malloy';
 class TestTranslator extends parse_malloy_1.MalloyTranslator {
-    constructor(testSrc, importBaseURL = null, eventStream = null, rootRule = 'malloyDocument', internalModel) {
-        super(testURI, importBaseURL, null, eventStream);
+    constructor(testSrc, options = {}) {
+        var _a, _b, _c, _d, _e;
+        super(testURI, (_a = options.importBaseURL) !== null && _a !== void 0 ? _a : null, null, (_b = options.eventStream) !== null && _b !== void 0 ? _b : null, (_c = options.restrictedMode) !== null && _c !== void 0 ? _c : false);
         this.testSrc = testSrc;
         this.allDialectsEnabled = true;
         /*
@@ -415,16 +416,19 @@ class TestTranslator extends parse_malloy_1.MalloyTranslator {
                 },
             },
         };
-        this.grammarRule = rootRule;
+        this.grammarRule = (_d = options.rootRule) !== null && _d !== void 0 ? _d : 'malloyDocument';
         this.importZone.define(testURI, testSrc);
-        if (internalModel !== undefined) {
-            this.internalModel = internalModel;
+        if (options.internalModel !== undefined) {
+            this.internalModel = options.internalModel;
         }
         for (const actualSchema of exports.mockSchema) {
             this.schemaZone.define(`${actualSchema.connection}:${actualSchema.tablePath}`, actualSchema);
         }
         this.connectionDialectZone.define('_db_', exports.TEST_DIALECT);
         this.connectionDialectZone.define('_bq_', 'standardsql');
+        for (const flag of (_e = options.compilerFlags) !== null && _e !== void 0 ? _e : []) {
+            this.compilerFlagSrc.push(`##! ${flag}\n`);
+        }
     }
     translate() {
         return super.translate(this.internalModel);
@@ -532,8 +536,8 @@ class TestTranslator extends parse_malloy_1.MalloyTranslator {
 exports.TestTranslator = TestTranslator;
 TestTranslator.inspectCompile = false;
 class BetaExpression extends TestTranslator {
-    constructor(src, model, sourceName = 'ab') {
-        super(src, null, null, 'debugExpr', model);
+    constructor(src, model, sourceName = 'ab', options = {}) {
+        super(src, { ...options, rootRule: 'debugExpr', internalModel: model });
         this.sourceName = sourceName;
     }
     testFS() {
@@ -627,21 +631,20 @@ function model(unmarked, ...marked) {
 }
 function makeModelFunc(options) {
     return function model(unmarked, ...marked) {
-        var _a;
         const ms = markSource(unmarked, ...marked);
+        const { prefix, wrap, ...ttOptions } = options;
         return {
             ...ms,
-            translator: new TestTranslator(((_a = options.prefix) !== null && _a !== void 0 ? _a : '') +
-                (options.wrap ? options.wrap(ms.code) : ms.code), null, null, undefined, options === null || options === void 0 ? void 0 : options.model),
+            translator: new TestTranslator((prefix !== null && prefix !== void 0 ? prefix : '') + (wrap ? wrap(ms.code) : ms.code), ttOptions),
         };
     };
 }
-function makeExprFunc(model, sourceName) {
+function makeExprFunc(model, sourceName = 'ab', options = {}) {
     return function expr(unmarked, ...marked) {
         const ms = markSource(unmarked, ...marked);
         return {
             ...ms,
-            translator: new BetaExpression(ms.code, model, sourceName),
+            translator: new BetaExpression(ms.code, model, sourceName, options),
         };
     };
 }

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

@@ -28,7 +28,9 @@ export type ZoneEntry<T> = EntryPresent<T> | ReferenceEntry | EntryErrored;
 export declare class Zone<TValue> {
     zone: Map<string, ZoneEntry<TValue>>;
     location: Record<string, DocumentLocation>;
+    private locked;
     constructor();
+    lock(): void;
     get(str: string): TValue | undefined;
     getEntry(str: string): ZoneEntry<TValue>;
     /**

package/dist/lang/zone.js

@@ -33,8 +33,12 @@ exports.Zone = void 0;
 class Zone {
     constructor() {
         this.location = {};
+        this.locked = false;
         this.zone = new Map();
     }
+    lock() {
+        this.locked = true;
+    }
     get(str) {
         const zst = this.zone.get(str);
         if ((zst === null || zst === void 0 ? void 0 : zst.status) === 'present') {
@@ -57,6 +61,8 @@ class Zone {
      * @param val
      */
     define(str, val) {
+        if (this.locked)
+            return;
         this.zone.set(str, { status: 'present', value: val });
     }
     /**
@@ -65,6 +71,8 @@ class Zone {
      * @param loc The location of the reference
      */
     reference(str, loc) {
+        if (this.locked)
+            return;
         const zst = this.zone.get(str);
         if ((zst === null || zst === void 0 ? void 0 : zst.status) === undefined) {
             this.zone.set(str, { status: 'reference', firstReference: loc });
@@ -89,6 +97,8 @@ class Zone {
      * @param errorData Pass on errors encountered during fetch
      */
     updateFrom(updateData, errorData) {
+        if (this.locked)
+            return;
         if (updateData) {
             for (const [updateKey, updateVal] of Object.entries(updateData)) {
                 if (updateVal !== undefined) {

package/dist/model/constant_expression_compiler.js

@@ -14,11 +14,20 @@ const field_instance_1 = require("./field_instance");
  * Used to distinguish expected errors from unexpected ones.
  */
 class ConstantExpressionError extends Error {
-    constructor(message) {
+    constructor(message, at) {
         super(message);
+        this.at = at;
         this.name = 'ConstantExpressionError';
     }
 }
+function locSuffix(at) {
+    if (!at)
+        return '';
+    // Display 1-based line/column; range positions are 0-based.
+    const line = at.range.start.line + 1;
+    const col = at.range.start.character + 1;
+    return ` at ${at.url}:${line}:${col}`;
+}
 /**
  * Minimal FieldInstanceResultRoot for constant expressions.
  * This serves as both the result set and its own root, providing
@@ -106,11 +115,11 @@ class ConstantQueryStruct extends query_node_1.QueryStruct {
     /**
      * These methods should not be called for constant expressions
      */
-    getFieldByName(path) {
-        throw new ConstantExpressionError(`Illegal reference to '${path.join('.')}' in constant expressions`);
+    getFieldByName(path, at) {
+        throw new ConstantExpressionError(`Illegal reference to '${path.join('.')}' in constant expressions${locSuffix(at)}`, at);
     }
-    getStructByName(path) {
-        throw new ConstantExpressionError(`Illegal reference to '${path.join('.')}' in constant expressions`);
+    getStructByName(path, at) {
+        throw new ConstantExpressionError(`Illegal reference to '${path.join('.')}' in constant expressions${locSuffix(at)}`, at);
     }
     getSQLIdentifier() {
         throw new ConstantExpressionError('Constant expressions do not need SQL identifiers');

package/dist/model/expression_compiler.js

@@ -29,6 +29,7 @@ const field_instance_1 = require("./field_instance");
 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 NUMERIC_DECIMAL_PRECISION = 9;
 function sqlSumDistinct(dialect, sqlExp, sqlDistintKey) {
     const precision = 9;
@@ -186,7 +187,7 @@ function compileExpr(resultSet, context, expr, state = new utils_1.GenerateState
                 return `${expr.kids.e.sql} ${expr.not ? 'NOT IN' : 'IN'} (${oneOf})`;
             }
             case 'inGiven': {
-                const bound = resolveGivenBoundExpr(context, expr.givenRef.id, expr.givenRef.refName);
+                const bound = resolveGivenBoundExpr(context, expr.givenRef);
                 // null binding collapses to empty-set semantics — not the SQL
                 // `IN (NULL)` shape, which has confusing NULL-membership rules.
                 if (bound.node === 'null') {
@@ -280,27 +281,27 @@ function generateAppliedFilter(context, filterMatchExpr, qi) {
             filterExpr = argument.value;
         }
         else {
-            throw new Error(`Parameter ${name} was expected to be a filter expression`);
+            throw new malloy_compile_error_1.MalloyCompileError(`Parameter '${name}' has no value, but a filter expression is required here.`, 'compiler-filter-parameter-no-value', filterExpr.at);
         }
     }
     if (filterExpr.node === 'given') {
-        const id = filterExpr.id;
-        const supplied = (_c = (_b = context.prepareResultOptions) === null || _b === void 0 ? void 0 : _b.resolvedGivens) === null || _c === void 0 ? void 0 : _c.get(id);
+        const supplied = (_c = (_b = context.prepareResultOptions) === null || _b === void 0 ? void 0 : _b.resolvedGivens) === null || _c === void 0 ? void 0 : _c.get(filterExpr.id);
         if (supplied !== undefined) {
             filterExpr = supplied;
         }
         else {
-            const decl = context.getModel().givens[id];
+            const decl = context.getModel().givens[filterExpr.id];
             if ((decl === null || decl === void 0 ? void 0 : decl.default) !== undefined) {
                 filterExpr = decl.default;
             }
             else {
-                throw new Error(unsatisfiedGivenMessage(filterExpr.refName));
+                throw new malloy_compile_error_1.MalloyCompileError(unsatisfiedGivenMessage(filterExpr.refName), 'compiler-given-no-value', filterExpr.at);
             }
         }
     }
     if (filterExpr.node !== 'filterLiteral') {
-        throw new Error('Can only use filter expression literals or parameters as filter expressions');
+        throw new malloy_compile_error_1.MalloyCompileError("Filter context requires a filter-expression literal (e.g., `f'...'`) " +
+            `or a parameter that resolves to one; got node '${filterExpr.node}'.`, 'compiler-filter-not-literal', undefined);
     }
     const filterSrc = filterExpr.filterSrc;
     let fParse;
@@ -320,10 +321,11 @@ function generateAppliedFilter(context, filterMatchExpr, qi) {
             fParse = malloy_filter_1.TemporalFilterExpression.parse(filterSrc);
             break;
         default:
-            throw new Error(`unsupported filter type ${filterMatchExpr.dataType}`);
+            throw new malloy_compile_error_1.MalloyCompileError(`Filter type '${filterMatchExpr.dataType}' is not supported. ` +
+                'Supported filter types: string, number, boolean, date, timestamp, timestamptz.', 'compiler-filter-type-unsupported', undefined);
     }
     if (fParse.log.length > 0) {
-        throw new Error(`Filter expression parse error: ${fParse.log[0]}`);
+        throw new malloy_compile_error_1.MalloyCompileError(`Filter expression parse error: ${fParse.log[0]}.`, 'compiler-filter-parse-error', undefined);
     }
     return filter_compilers_1.FilterCompilers.compile(filterMatchExpr.dataType, fParse.parsed, filterMatchExpr.kids.expr.sql || '', context.dialect, qi);
 }
@@ -581,7 +583,7 @@ function generateFunctionCallExpression(resultSet, context, frag, state) {
 }
 function generateFieldFragment(resultSet, context, expr, state) {
     // find the structDef and return the path to the field...
-    const fieldRef = context.getFieldByName(expr.path);
+    const fieldRef = context.getFieldByName(expr.path, expr.at);
     if ((0, malloy_types_1.hasExpression)(fieldRef.fieldDef)) {
         const ret = exprToSQL(resultSet, fieldRef.parent, fieldRef.fieldDef.e, state);
         return `(${ret})`;
@@ -614,7 +616,7 @@ function generateParameterFragment(resultSet, context, expr, state) {
     if (argument === null || argument === void 0 ? void 0 : argument.value) {
         return exprToSQL(resultSet, context, argument.value, state);
     }
-    throw new Error(`Can't generate SQL, no value for ${expr.path}`);
+    throw new malloy_compile_error_1.MalloyCompileError(`Parameter '${expr.path.join('.')}' has no value supplied.`, 'compiler-parameter-no-value', expr.at);
 }
 /**
  * Resolve a given to the Expr that should stand in for it at SQL emit:
@@ -625,20 +627,20 @@ function generateParameterFragment(resultSet, context, expr, state) {
  * Shared by `generateGivenFragment` ($NAME directly in an expression)
  * and the `'inGiven'` SQL-emit case ($ARR in `expr in $ARR`).
  */
-function resolveGivenBoundExpr(context, id, refName) {
+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(id);
+    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[id];
+    const decl = context.getModel().givens[ref.id];
     if ((decl === null || decl === void 0 ? void 0 : decl.default) !== undefined)
         return decl.default;
-    throw new Error(unsatisfiedGivenMessage(refName));
+    throw new malloy_compile_error_1.MalloyCompileError(unsatisfiedGivenMessage(ref.refName), 'compiler-given-no-value', ref.at);
 }
 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);
+    const bound = resolveGivenBoundExpr(context, expr);
     return exprToSQL(resultSet, context, bound, state);
 }
 function unsatisfiedGivenMessage(refName) {
@@ -663,7 +665,7 @@ function generateDimFragment(resultSet, context, expr, state) {
 }
 function generateUngroupedFragment(resultSet, context, expr, state) {
     if (state.totalGroupSet !== -1) {
-        throw new Error('Already in ALL.  Cannot nest within an all calcuation.');
+        throw new malloy_compile_error_1.MalloyCompileError("Cannot nest 'all()' or 'exclude()' inside another 'all()' calculation.", 'compiler-nested-ungroup', undefined);
     }
     let totalGroupSet;
     let ungroupSet;