@malloydata/malloy 0.0.395 → 0.0.396

package/dist/lang/ast/types/annotation-elements.js

@@ -41,12 +41,19 @@ class ModelAnnotation extends ObjectAnnotation {
         super(...arguments);
         this.elementType = 'modelAnnotation';
     }
+    getCompilerFlagNotes() {
+        return this.notes.filter(note => note.text.match(COMPILER_FLAG_PREFIX));
+    }
     getCompilerFlagLines() {
-        return this.notes
-            .filter(note => note.text.match(COMPILER_FLAG_PREFIX))
-            .map(note => note.text);
+        return this.getCompilerFlagNotes().map(note => note.text);
     }
     execute(doc) {
+        if (this.isRestricted()) {
+            for (const note of this.getCompilerFlagNotes()) {
+                const line = note.text.replace(/\n$/, '');
+                this.logError('restricted-construct-forbidden', `\`${line}\` cannot be used in a restricted query — compiler-flag annotations are not permitted.`, { at: note.at });
+            }
+        }
         if (doc.annotation.notes === undefined) {
             doc.annotation.notes = [];
         }

package/dist/lang/ast/types/malloy-element.d.ts

@@ -37,6 +37,7 @@ export declare abstract class MalloyElement {
      */
     kupuna(): MalloyElement;
     translator(): MalloyTranslation | undefined;
+    isRestricted(): boolean;
     setTranslator(x: MalloyTranslation): void;
     addReference(reference: DocumentReference): void;
     private get sourceURL();

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

@@ -158,6 +158,10 @@ class MalloyElement {
         }
         return undefined;
     }
+    isRestricted() {
+        var _a, _b;
+        return (_b = (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.root.restrictedMode) !== null && _b !== void 0 ? _b : false;
+    }
     setTranslator(x) {
         this.xlate = x;
     }

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

@@ -35,10 +35,11 @@ type HasAnnotations = ParserRuleContext & {
 export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElement> implements MalloyParserVisitor<ast.MalloyElement> {
     readonly parseInfo: MalloyParseInfo;
     readonly msgLog: MessageLogger;
+    readonly restrictedMode: boolean;
     readonly timer: Timer;
     private compilerFlagSrc;
     private compilerFlagTag?;
-    constructor(parseInfo: MalloyParseInfo, msgLog: MessageLogger, compilerFlagSrc: string[]);
+    constructor(parseInfo: MalloyParseInfo, msgLog: MessageLogger, compilerFlagSrc: string[], restrictedMode?: boolean);
     getCompilerFlags(): Tag;
     run(): {
         ast: ast.MalloyElement;

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

@@ -430,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

@@ -139,6 +139,12 @@ 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);
             // Register connection dialects and imports immediately. Table
@@ -278,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;
@@ -466,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;
         }
@@ -821,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();
@@ -845,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/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/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;

package/dist/model/field_instance.js

@@ -6,6 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FieldInstanceResultRoot = exports.FieldInstanceResult = exports.FieldInstanceField = void 0;
 exports.sqlFullChildReference = sqlFullChildReference;
+const malloy_compile_error_1 = require("./malloy_compile_error");
 const malloy_types_1 = require("./malloy_types");
 const utils_1 = require("./utils");
 const join_instance_1 = require("./join_instance");
@@ -139,7 +140,8 @@ class FieldInstanceResult {
         const fi = this.allFields.get(as);
         if (fi) {
             if (fi.type === 'query') {
-                throw new Error(`Redefinition of field ${field.fieldDef.name} as struct`);
+                throw new malloy_compile_error_1.MalloyCompileError(`Field '${field.fieldDef.name}' is already defined as a nested view; ` +
+                    'cannot also use it as a scalar field in this output.', 'compiler-field-redefined-as-struct', field.fieldDef.location);
             }
             const fif = fi;
             if (fif.fieldUsage.type === 'result') {
@@ -148,7 +150,8 @@ class FieldInstanceResult {
                     return;
                 }
                 else {
-                    throw new Error(`Ambiguous output field name '${field.fieldDef.name}'.`);
+                    throw new malloy_compile_error_1.MalloyCompileError(`Output field name '${field.fieldDef.name}' is ambiguous — ` +
+                        'defined more than once at the query output level.', 'compiler-ambiguous-output-name', field.fieldDef.location);
                 }
             }
         }
@@ -373,7 +376,8 @@ class FieldInstanceResult {
         // verify that all names specified are available in the current scope.
         for (const fieldName of (ungroupSet === null || ungroupSet === void 0 ? void 0 : ungroupSet.fields) || []) {
             if (inScopeFieldNames.indexOf(fieldName) === -1) {
-                throw new Error(`${ungroupSet === null || ungroupSet === void 0 ? void 0 : ungroupSet.type}(): unknown field name "${fieldName}" or name not in scope.`);
+                throw new malloy_compile_error_1.MalloyCompileError(`'${ungroupSet === null || ungroupSet === void 0 ? void 0 : ungroupSet.type}()' references field '${fieldName}', ` +
+                    'which is not defined or not in scope at this nesting level.', 'compiler-ungroup-field-unknown', undefined);
             }
         }
         return ret;