@malloydata/malloy 0.0.395 → 0.0.397

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

@@ -62,6 +62,7 @@ const AbstractParseTreeVisitor_1 = require("antlr4ts/tree/AbstractParseTreeVisit
 const ast = __importStar(require("./ast"));
 const parse_log_1 = require("./parse-log");
 const Interval_1 = require("antlr4ts/misc/Interval");
+const prefix_1 = require("../prefix");
 const ast_1 = require("./ast");
 const parse_utils_1 = require("./parse-utils");
 const malloy_types_1 = require("../model/malloy_types");
@@ -92,10 +93,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];
@@ -270,12 +272,26 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         return this.astAt(def, pcx);
     }
     getAnnotation(cx) {
-        const text = (0, parse_utils_1.getAnnotationText)(cx, (wcx, msg) => {
-            this.contextError(wcx, 'block-annotation-warning', msg, {
-                severity: 'warn',
-            });
-        });
-        return { text: text, at: this.getLocation(cx) };
+        const note = (0, parse_utils_1.noteFromAnnotation)(cx, this.parseInfo);
+        this.warnIfMalformedPrefix(note.text, cx);
+        return note;
+    }
+    /**
+     * Warn if the annotation prefix is not a well-formed route. The note is still
+     * stored either way — the malformation only drives the diagnostic, never the
+     * IR. Warnings fire at note construction; inherited annotations carry no
+     * malformation marker through the IR and are not re-warned by importers.
+     */
+    warnIfMalformedPrefix(text, cx) {
+        const parsed = (0, prefix_1.parsePrefix)(text);
+        if (parsed.malformation === undefined)
+            return;
+        // The slice up to contentIndex is "prefix + separator"; trim trailing
+        // whitespace to land on the prefix the user wrote. (A no-content single-
+        // line note like `#malformed\n` exposes this: contentIndex === text.length
+        // but the slice still ends at the `\n`.)
+        const prefix = text.slice(0, parsed.contentIndex).replace(/\s+$/, '');
+        this.contextError(cx, parsed.malformation, { prefix });
     }
     getNotes(cx) {
         return cx.annotation().map(a => this.getAnnotation(a));
@@ -1498,6 +1514,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;
@@ -1523,10 +1548,11 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
                 this.contextError(pcx, 'unclosed-block-annotation', 'Block annotation is not closed, add correctly indented "|##"');
             }
         }
-        const allNotes = pcx.docAnnotation().map(a => ({
-            text: (0, parse_utils_1.getAnnotationText)(a),
-            at: this.getLocation(pcx),
-        }));
+        const allNotes = pcx.docAnnotation().map(a => {
+            const note = (0, parse_utils_1.noteFromAnnotation)(a, this.parseInfo);
+            this.warnIfMalformedPrefix(note.text, a);
+            return note;
+        });
         const tags = new ast.ModelAnnotation(allNotes);
         this.updateCompilerFlags(tags);
         return tags;

package/dist/lang/malloy-to-stable-query.js

@@ -101,9 +101,9 @@ class MalloyToQuery extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor
      * @returns Array of texts for the annotations
      */
     getAnnotations(cx) {
-        const annotations = cx.annotation().map(a => {
-            return { value: (0, parse_utils_1.getAnnotationText)(a) };
-        });
+        const annotations = cx.annotation().map(a => ({
+            value: (0, parse_utils_1.getAnnotationText)(a),
+        }));
         return annotations.length > 0 ? annotations : undefined;
     }
     getIsAnnotations(cx) {

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

@@ -358,7 +358,12 @@ type MessageParameterTypes = {
     'failed-to-parse-function-name': string;
     'orphaned-object-annotation': string;
     'unclosed-block-annotation': string;
-    'block-annotation-warning': string;
+    'malformed-route': {
+        prefix: string;
+    };
+    'reserved-route': {
+        prefix: string;
+    };
     'misplaced-model-annotation': string;
     'unexpected-non-source-query-expression-node': string;
     'sql-not-like': string;
@@ -430,6 +435,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,18 @@ 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',
+    }),
+    'malformed-route': e => ({
+        message: `Annotation prefix \`${e.prefix}\` is not a well-formed route — write \`# ...\` for a tag (note the space) or \`#(name)\` for an app route`,
+        severity: 'warn',
+    }),
+    'reserved-route': e => ({
+        message: `Annotation prefix \`${e.prefix}\` uses an unclaimed sigil; punct-only prefixes are reserved for Malloy's own use`,
+        severity: 'warn',
+    }),
 };
 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(...new annotation_1.Annotations(extendingModel.annotation).texts('!'));
             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/parse-tree-walkers/model-annotation-walker.js

@@ -32,18 +32,10 @@ class ModelAnnotationWalker {
         this.parseInfo = parseInfo;
         this.notes = [];
     }
-    getLocation(cx) {
-        return {
-            url: this.parseInfo.sourceURL,
-            range: this.translator.rangeFromContext(cx),
-        };
-    }
     enterDocAnnotations(pcx) {
-        const allNotes = pcx.docAnnotation().map(a => ({
-            text: (0, parse_utils_1.getAnnotationText)(a),
-            at: this.getLocation(pcx),
-        }));
-        this.notes.push(...allNotes);
+        for (const a of pcx.docAnnotation()) {
+            this.notes.push((0, parse_utils_1.noteFromAnnotation)(a, this.parseInfo));
+        }
     }
     get annotation() {
         return { notes: this.notes };

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

@@ -1,6 +1,8 @@
 import type { ParserRuleContext } from 'antlr4ts';
 import type { DocAnnotationContext } from './lib/Malloy/MalloyParser';
 import { type StringContext, type ShortStringContext, type SqlStringContext, type IdContext, AnnotationContext } from './lib/Malloy/MalloyParser';
+import type { Note } from '../model/malloy_types';
+import type { MalloyParseInfo } from './malloy-parse-info';
 /**
  * Take the text of a matched string, including the matching quote
  * characters, and return the actual contents of the string after
@@ -35,6 +37,12 @@ export declare function unIndent(parts: (string | unknown)[]): void;
  * @returns string part and an error list.
  */
 export declare function getPlainString(cx: HasString, strictCheck?: boolean): [string | undefined, ParserRuleContext[]];
-type AnnotationWarn = (cx: ParserRuleContext, msg: string) => void;
-export declare function getAnnotationText(cx: AnnotationContext | DocAnnotationContext, warn?: AnnotationWarn): string;
+/**
+ * Build the IR `Note` for an annotation: reads the text, dedents the body if
+ * it's a block, and computes the source `at` from the parse context. The
+ * single entry point for going from a parse-tree annotation to an IR note.
+ */
+export declare function noteFromAnnotation(cx: AnnotationContext | DocAnnotationContext, parseInfo: MalloyParseInfo): Note;
+/** Text-only reader, for callers that don't need an IR `Note`. */
+export declare function getAnnotationText(cx: AnnotationContext | DocAnnotationContext): string;
 export {};

package/dist/lang/parse-utils.js

@@ -30,9 +30,11 @@ exports.idToStr = idToStr;
 exports.getOptionalId = getOptionalId;
 exports.unIndent = unIndent;
 exports.getPlainString = getPlainString;
+exports.noteFromAnnotation = noteFromAnnotation;
 exports.getAnnotationText = getAnnotationText;
 const MalloyParser_1 = require("./lib/Malloy/MalloyParser");
 const malloy_tag_1 = require("@malloydata/malloy-tag");
+const utils_1 = require("./utils");
 /**
  * Take the text of a matched string, including the matching quote
  * characters, and return the actual contents of the string after
@@ -182,51 +184,109 @@ function getPlainString(cx, strictCheck = false) {
     // string: shortString | sqlString; So this will never happen
     return ['', errorList];
 }
-function stripBlockIndent(lines, column, cx, warn) {
-    if (column === 0) {
-        return lines.join('');
-    }
-    const prefix = ' '.repeat(column);
-    let warnedLeft = false;
-    let warnedTab = false;
-    return lines
-        .map(line => {
-        if (warn && !warnedTab && line.slice(0, column).includes('\t')) {
-            warn(cx, 'Block annotation indentation contains tabs, use spaces');
-            warnedTab = true;
-        }
-        if (line.startsWith(prefix)) {
-            return line.slice(column);
+/**
+ * Python `textwrap.dedent`-style: find the longest leading-whitespace prefix
+ * common to every non-blank body line and strip it from each line that starts
+ * with it. Blank (whitespace-only) lines don't constrain the prefix. Returns
+ * the stripped text and the number of characters removed per line — the
+ * latter is stored on the `Note` so payload-parser error columns can be
+ * mapped back to source (`source_col = indentStripped + parser_col`).
+ *
+ * Replaces an older "strip exactly opener_column spaces" rule that fired
+ * warnings for less-indented lines and had no clean column mapping when
+ * stripping was inconsistent. Common prefix is uniform per block, so column
+ * mapping is one number per block.
+ */
+function dedentBlockLines(lines) {
+    let common;
+    for (const line of lines) {
+        const content = line.replace(/\r?\n$/, '');
+        if (!/\S/.test(content))
+            continue;
+        const indent = content.match(/^[ \t]*/)[0];
+        if (common === undefined) {
+            common = indent;
+            continue;
         }
-        if (warn && !warnedLeft && !warnedTab && line.match(/\S/)) {
-            warn(cx, 'Block annotation content is left of the opening #|');
-            warnedLeft = true;
+        let n = 0;
+        while (n < common.length && n < indent.length && common[n] === indent[n]) {
+            n++;
         }
-        return line;
-    })
-        .join('');
+        common = common.slice(0, n);
+        if (common === '')
+            break;
+    }
+    const prefix = common !== null && common !== void 0 ? common : '';
+    if (prefix === '')
+        return { text: lines.join(''), indentStripped: 0 };
+    return {
+        text: lines
+            .map(line => (line.startsWith(prefix) ? line.slice(prefix.length) : line))
+            .join(''),
+        indentStripped: prefix.length,
+    };
 }
 function stripTrailingNewline(s) {
-    return s.endsWith('\n') ? s.slice(0, -1) : s;
+    // A trailing line ending may be CRLF or LF — strip either.
+    return s.replace(/\r?\n$/, '');
 }
-function getAnnotationText(cx, warn) {
+/**
+ * Annotation note text is normalized to LF line endings, so a block's stored
+ * text and content are identical regardless of the source's CRLF/LF style.
+ * The lexer keeps the source `\r` in token text (it sits at line ends, after a
+ * line's content); this is where it is dropped.
+ */
+function normalizeEol(s) {
+    return s.replace(/\r\n/g, '\n');
+}
+/**
+ * Read the text and dedent amount of an annotation from its parse tree.
+ * Internal — public callers want `noteFromAnnotation` or `getAnnotationText`.
+ */
+function readAnnotation(cx) {
     if (cx instanceof MalloyParser_1.AnnotationContext) {
         const annot = cx.ANNOTATION();
         if (annot)
-            return annot.text;
+            return { text: normalizeEol(annot.text), indentStripped: 0 };
         const block = cx.blockAnnotation();
         const beginToken = block.BLOCK_ANNOTATION_BEGIN();
         const textLines = block.BLOCK_ANNOTATION_TEXT().map(t => t.text);
-        return stripTrailingNewline(beginToken.text +
-            stripBlockIndent(textLines, beginToken.symbol.charPositionInLine, cx, warn));
+        const dedented = dedentBlockLines(textLines);
+        return {
+            text: normalizeEol(stripTrailingNewline(beginToken.text + dedented.text)),
+            indentStripped: dedented.indentStripped,
+        };
     }
     const doc = cx.DOC_ANNOTATION();
     if (doc)
-        return doc.text;
+        return { text: normalizeEol(doc.text), indentStripped: 0 };
     const block = cx.docBlockAnnotation();
     const beginToken = block.DOC_BLOCK_ANNOTATION_BEGIN();
     const textLines = block.BLOCK_ANNOTATION_TEXT().map(t => t.text);
-    return stripTrailingNewline(beginToken.text +
-        stripBlockIndent(textLines, beginToken.symbol.charPositionInLine, cx, warn));
+    const dedented = dedentBlockLines(textLines);
+    return {
+        text: normalizeEol(stripTrailingNewline(beginToken.text + dedented.text)),
+        indentStripped: dedented.indentStripped,
+    };
+}
+/**
+ * Build the IR `Note` for an annotation: reads the text, dedents the body if
+ * it's a block, and computes the source `at` from the parse context. The
+ * single entry point for going from a parse-tree annotation to an IR note.
+ */
+function noteFromAnnotation(cx, parseInfo) {
+    const { text, indentStripped } = readAnnotation(cx);
+    const at = {
+        url: parseInfo.sourceURL,
+        range: (0, utils_1.rangeFromContext)(parseInfo.sourceInfo, cx),
+    };
+    const note = { text, at };
+    if (indentStripped > 0)
+        note.indentStripped = indentStripped;
+    return note;
+}
+/** Text-only reader, for callers that don't need an IR `Note`. */
+function getAnnotationText(cx) {
+    return readAnnotation(cx).text;
 }
 //# sourceMappingURL=parse-utils.js.map

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');