@malloydata/malloy 0.0.434 → 0.0.436

package/dist/lang/ast/source-elements/sql-source.js

@@ -78,9 +78,6 @@ class SQLSource extends source_1.Source {
                 compileSQL: sql,
             };
         }
-        else if (lookup.status === 'present') {
-            doc.checkExperimentalDialect(this, lookup.value.dialect);
-        }
     }
     getSourceDef() {
         var _a;

package/dist/lang/ast/source-elements/table-source.js

@@ -12,7 +12,7 @@ const error_factory_1 = require("../error-factory");
 const dialect_1 = require("../../../dialect");
 class TableSource extends source_1.Source {
     getSourceDef() {
-        var _a, _b, _c;
+        var _a, _b;
         const info = this.getTableInfo();
         if (info === undefined) {
             return error_factory_1.ErrorFactory.structDef;
@@ -36,7 +36,6 @@ class TableSource extends source_1.Source {
         let msg = `Schema read failure for table '${tablePath}' for connection '${connectionName}'`;
         if (tableDefEntry) {
             if (tableDefEntry.status === 'present') {
-                (_c = this.document()) === null || _c === void 0 ? void 0 : _c.checkExperimentalDialect(this, tableDefEntry.value.dialect);
                 tableDefEntry.value.location = this.location;
                 tableDefEntry.value.fields.forEach(field => {
                     field.location = this.location;

package/dist/lang/ast/statements/import-statement.js

@@ -152,14 +152,31 @@ class ImportStatement extends malloy_element_1.ListOf {
                             }
                             const importMe = { ...sourceEntry };
                             importMe.as = dstName;
+                            const dialect = (0, source_def_utils_1.dialectOfEntry)(importMe, importedModel);
+                            if (dialect !== undefined) {
+                                trans.checkExperimentalDialect(dialect, this.location);
+                            }
                             doc.setEntry(dstName, { entry: importMe, exported: false });
                             // Every source the walk touched, routes included — not just the
                             // persistent ones. A `#@ -persist` wrapper that adds a join is
                             // not a table, but it can be the only way to reach the tables
                             // under it, and this model has to be able to take the same route.
+                            //
+                            // The persistent ones are also what a builder will build from
+                            // this model, so the document checks at the end of compile that
+                            // this model can supply every given their SQL reads.
                             if ((0, malloy_types_1.isSourceDef)(importMe) && (0, malloy_types_1.isPersistableSourceDef)(importMe)) {
                                 for (const found of (0, persist_utils_1.walkPersistentDependencies)([importMe], importedModel)) {
                                     neededSourceIDs.add(found.sourceID);
+                                    if (!found.persistent)
+                                        continue;
+                                    const def = (0, source_def_utils_1.resolveSourceID)(importedModel, found.sourceID);
+                                    if (def && !doc.importedPersistSources.has(found.sourceID)) {
+                                        doc.importedPersistSources.set(found.sourceID, {
+                                            source: def,
+                                            at: this.location,
+                                        });
+                                    }
                                 }
                             }
                         }

package/dist/lang/ast/types/expression-def.js

@@ -49,6 +49,7 @@ const granular_result_1 = require("./granular-result");
 const malloy_element_1 = require("./malloy-element");
 const binary_operators_1 = require("./binary_operators");
 const malloy_filter_1 = require("@malloydata/malloy-filter");
+const boolean_value_1 = require("../expressions/boolean-value");
 class TypeMismatch extends Error {
 }
 /**
@@ -341,11 +342,21 @@ function regexEqual(left, right) {
     }
     return undefined;
 }
+/**
+ * A boolean can only be compared, with anything, on a dialect with boolean
+ * values. Every comparison operator, applied plainly, as a partial, or
+ * through an alternation, arrives here through equality() or compare().
+ */
+function booleanCompare(fs, left, lhs, op, right, rhs) {
+    const [side, val] = lhs.type === 'boolean' ? [left, lhs] : [right, rhs];
+    return (0, boolean_value_1.booleanValueError)(fs, val, `compared with ${op}`, side, boolean_value_1.COMPARE_HINT);
+}
 function equality(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
     const node = (0, binary_operators_1.getExprNode)(op);
-    const err = errorCascade('boolean', lhs, rhs);
+    const err = errorCascade('boolean', lhs, rhs) ||
+        booleanCompare(fs, left, lhs, op, right, rhs);
     if (err)
         return err;
     // Unsupported types can be compare with null
@@ -365,6 +376,9 @@ function equality(fs, left, op, right) {
         if (op !== '~' && op !== '!~') {
             return right.loggedErrorExpr('filter-expression-error', `Cannot use the '${op}' operator with a filter expression`);
         }
+        const noMatch = (0, boolean_value_1.booleanValueError)(fs, lhs, 'matched with a filter expression', left, 'test the condition itself');
+        if (noMatch)
+            return noMatch;
         if ((0, malloy_filter_1.isFilterable)(lhs.type)) {
             let actualFilter = rhs.value;
             while (actualFilter.node === '()') {
@@ -419,7 +433,8 @@ function equality(fs, left, op, right) {
 function compare(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
-    const err = errorCascade('boolean', lhs, rhs);
+    const err = errorCascade('boolean', lhs, rhs) ||
+        booleanCompare(fs, left, lhs, op, right, rhs);
     if (err)
         return err;
     const noCompare = unsupportError(left, lhs, right, rhs);

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

@@ -1,4 +1,4 @@
-import type { AnnotationsDef, DocumentLocation, DocumentReference, Given, ModelDef, ModelAnnotationEntry, ModelID, NamedModelObject, Query, SourceID, SourceRegistryValue } from '../../../model/malloy_types';
+import type { AnnotationsDef, DocumentLocation, DocumentReference, Given, ModelDef, ModelAnnotationEntry, ModelID, NamedModelObject, PersistableSourceDef, Query, SourceID, SourceRegistryValue } from '../../../model/malloy_types';
 import { Tag } from '@malloydata/malloy-tag';
 import type { LogMessageOptions, MessageLogger, MessageParameterType, MessageCode } from '../../parse-log';
 import type { MalloyTranslation } from '../../parse-malloy';
@@ -116,6 +116,13 @@ export declare class Document extends MalloyElement implements NameSpace {
     documentModel: Map<string, ModelEntry>;
     documentSrcRegistry: Record<SourceID, SourceRegistryValue>;
     documentGivens: Map<string, Given>;
+    /** Every persistent source an `import` brought within reach of this model's
+     *  builder, with the import that did so. Checked at end of compile: the
+     *  model has to be able to supply every given their SQL reads. */
+    importedPersistSources: Map<string, {
+        source: PersistableSourceDef;
+        at: DocumentLocation;
+    }>;
     /** {@link ModelAnnotationEntry} of every imported/extended model in the
      *  closure, keyed by ModelID, accumulated as imports/extends are processed;
      *  copied into the result `modelAnnotations` in {@link modelDef}, which then
@@ -146,19 +153,28 @@ export declare class Document extends MalloyElement implements NameSpace {
     initModelDef(extendingModelDef: ModelDef | undefined): void;
     compile(): DocumentCompileResult;
     private checkGivenAliasCollisions;
+    /**
+     * The givens in `usage` this model can neither supply nor default: not
+     * surfaced in the namespace and declared without a default. The set checked
+     * is each id plus its precomputed default-chain closure (`Given.givenUsage`),
+     * which is already transitive, so there is no recursion here.
+     */
+    private unsatisfiedGivens;
     private checkQueryGivenSatisfiability;
+    /**
+     * A persisted source is built from whatever model a builder is handed, so a
+     * model that imports one has to be able to supply every given its SQL reads;
+     * an import that cannot is a source no build or query here could ever use.
+     * Checked at end of compile rather than at the import, since the given may
+     * be imported by a later statement. A locally declared source cannot fail
+     * this: `$NAME` only resolves to a given in scope.
+     */
+    private checkPersistSourceGivenSatisfiability;
     hasAnnotation(): boolean;
     currentModelAnnotation(): AnnotationsDef | undefined;
     modelDef(): ModelDef;
     getEntry(str: string): ModelEntry | undefined;
     setEntry(str: string, ent: ModelEntry): void;
-    /**
-     * Return an error message if this dialect is the first reference to this particular
-     * dialect, and the dialect is marked as experimental, and we are not running tests.
-     * @param dialect The dialect name
-     * @returns The error message or undefined
-     */
-    checkExperimentalDialect(me: MalloyElement, dialect: string): void;
     private readonly dialectNameSpaces;
     getDialectNamespace(dialectName: string): NameSpace | undefined;
 }

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

@@ -9,6 +9,7 @@ exports.isDocStatement = isDocStatement;
 exports.isDocStatementOrDocStatementList = isDocStatementOrDocStatementList;
 const dialect_1 = require("../../../dialect");
 const malloy_types_1 = require("../../../model/malloy_types");
+const sql_compiled_1 = require("../../../model/sql_compiled");
 const utils_1 = require("../../../model/utils");
 const malloy_tag_1 = require("@malloydata/malloy-tag");
 const parse_log_1 = require("../../parse-log");
@@ -436,6 +437,10 @@ class Document extends MalloyElement {
         this.documentModel = new Map();
         this.documentSrcRegistry = {};
         this.documentGivens = new Map();
+        /** Every persistent source an `import` brought within reach of this model's
+         *  builder, with the import that did so. Checked at end of compile: the
+         *  model has to be able to supply every given their SQL reads. */
+        this.importedPersistSources = new Map();
         /** {@link ModelAnnotationEntry} of every imported/extended model in the
          *  closure, keyed by ModelID, accumulated as imports/extends are processed;
          *  copied into the result `modelAnnotations` in {@link modelDef}, which then
@@ -512,6 +517,7 @@ class Document extends MalloyElement {
         if (needs === undefined) {
             this.checkGivenAliasCollisions();
             this.checkQueryGivenSatisfiability();
+            this.checkPersistSourceGivenSatisfiability();
         }
         const ret = {
             modelDef: {
@@ -553,40 +559,46 @@ class Document extends MalloyElement {
                 `with a default-chain reference: \`given: NEW_NAME :: T is $${sourceName}\`.`);
         }
     }
+    /**
+     * The givens in `usage` this model can neither supply nor default: not
+     * surfaced in the namespace and declared without a default. The set checked
+     * is each id plus its precomputed default-chain closure (`Given.givenUsage`),
+     * which is already transitive, so there is no recursion here.
+     */
+    unsatisfiedGivens(usage) {
+        var _a, _b;
+        const namespaceGivens = new Set();
+        for (const m of this.documentModel.values()) {
+            if (m.entry.type === 'given')
+                namespaceGivens.add(m.entry.id);
+        }
+        const allIds = new Set();
+        for (const g of usage) {
+            allIds.add(g.id);
+            const decl = this.documentGivens.get(g.id);
+            for (const t of (_a = decl === null || decl === void 0 ? void 0 : decl.givenUsage) !== null && _a !== void 0 ? _a : [])
+                allIds.add(t.id);
+        }
+        const unsatisfied = [];
+        for (const id of allIds) {
+            if (namespaceGivens.has(id))
+                continue;
+            if (((_b = this.documentGivens.get(id)) === null || _b === void 0 ? void 0 : _b.default) !== undefined)
+                continue;
+            unsatisfied.push(id);
+        }
+        return unsatisfied;
+    }
     checkQueryGivenSatisfiability() {
         // Always runs at end-of-compile, not gated on imports — a notebook cell
         // that calls `extendModel` with a prior modelDef inherits that model's
         // queries and givens, and a query inherited from cell N can become
         // unsatisfiable in cell N+1 if the satisfying given is removed (or
         // never re-supplied). Cheap when there's nothing to check.
-        const namespaceGivens = new Set();
-        for (const m of this.documentModel.values()) {
-            if (m.entry.type === 'given')
-                namespaceGivens.add(m.entry.id);
-        }
         const checkOne = (q, label) => {
             var _a;
-            const usage = q.givenUsage;
-            if (!usage || usage.length === 0)
-                return;
-            // Build the full set of ids the query transitively needs: each id
-            // in Q.givenUsage, plus each id's precomputed default-chain closure
-            // (Given.givenUsage). Since the closure is already transitive, no
-            // recursion at check time.
-            const allIds = new Set();
-            for (const g of usage) {
-                allIds.add(g.id);
-                const decl = this.documentGivens.get(g.id);
-                for (const t of (_a = decl === null || decl === void 0 ? void 0 : decl.givenUsage) !== null && _a !== void 0 ? _a : [])
-                    allIds.add(t.id);
-            }
-            for (const id of allIds) {
-                if (namespaceGivens.has(id))
-                    continue;
-                const decl = this.documentGivens.get(id);
-                if ((decl === null || decl === void 0 ? void 0 : decl.default) !== undefined)
-                    continue;
-                this.logError('unsatisfied-given-in-query', unsatisfiedGivenMessage(label, decl, id), { at: q.location });
+            for (const id of this.unsatisfiedGivens((_a = q.givenUsage) !== null && _a !== void 0 ? _a : [])) {
+                this.logError('unsatisfied-given-in-query', unsatisfiedGivenMessage(label, this.documentGivens.get(id), id), { at: q.location });
             }
         };
         // Named queries in the namespace (locally defined OR imported).
@@ -599,6 +611,31 @@ class Document extends MalloyElement {
             checkOne(q, 'run: statement');
         }
     }
+    /**
+     * A persisted source is built from whatever model a builder is handed, so a
+     * model that imports one has to be able to supply every given its SQL reads;
+     * an import that cannot is a source no build or query here could ever use.
+     * Checked at end of compile rather than at the import, since the given may
+     * be imported by a later statement. A locally declared source cannot fail
+     * this: `$NAME` only resolves to a given in scope.
+     */
+    checkPersistSourceGivenSatisfiability() {
+        var _a;
+        // One import routinely reaches several sources that share a table — a
+        // persisted source and its extensions — so each given is reported once
+        // per import, against the first source that reads it.
+        const reported = new Map();
+        for (const { source, at } of this.importedPersistSources.values()) {
+            const seen = (_a = reported.get(at)) !== null && _a !== void 0 ? _a : new Set();
+            reported.set(at, seen);
+            for (const id of this.unsatisfiedGivens((0, sql_compiled_1.givenUsageOfRelation)(source))) {
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+                this.logError('unsatisfied-given-in-persist-source', unsatisfiedGivenMessage(`Imported persisted source \`${(0, malloy_types_1.activeName)(source)}\``, this.documentGivens.get(id), id), { at });
+            }
+        }
+    }
     hasAnnotation() {
         return ((this.annotations.notes && this.annotations.notes.length > 0) ||
             this.annotations.inherits !== undefined);
@@ -656,9 +693,6 @@ class Document extends MalloyElement {
         if (this.globalNameSpace.getEntry(str) !== undefined) {
             this.logError('name-conflict-with-global', `Cannot redefine '${str}', which is in global namespace`);
         }
-        if ((0, malloy_types_1.isSourceDef)(ent.entry)) {
-            this.checkExperimentalDialect(this, ent.entry.dialect);
-        }
         // Track if the model was modified after initialization
         if (this.didInitModel) {
             this.modelWasModified = true;
@@ -675,21 +709,6 @@ class Document extends MalloyElement {
             };
         }
     }
-    /**
-     * Return an error message if this dialect is the first reference to this particular
-     * dialect, and the dialect is marked as experimental, and we are not running tests.
-     * @param dialect The dialect name
-     * @returns The error message or undefined
-     */
-    checkExperimentalDialect(me, dialect) {
-        const t = this.translator();
-        if (t &&
-            t.firstReferenceToDialect(dialect) &&
-            (0, dialect_1.getDialect)(dialect).experimental &&
-            !t.experimentalDialectEnabled(dialect)) {
-            me.logError('experimental-dialect-not-enabled', { dialect });
-        }
-    }
     getDialectNamespace(dialectName) {
         if (this.dialectNameSpaces.has(dialectName)) {
             return this.dialectNameSpaces.get(dialectName);

package/dist/lang/ast/view-elements/reference-view.js

@@ -8,6 +8,7 @@ exports.ReferenceView = void 0;
 const composite_source_utils_1 = require("../../composite-source-utils");
 const malloy_types_1 = require("../../../model/malloy_types");
 const error_factory_1 = require("../error-factory");
+const boolean_value_1 = require("../expressions/boolean-value");
 const drill_1 = require("../query-properties/drill");
 const space_field_1 = require("../types/space-field");
 const refine_utils_1 = require("./refine-utils");
@@ -55,6 +56,9 @@ class ReferenceView extends view_1.View {
             throw new Error('Expected field to have definition');
         }
         if ((0, malloy_types_1.isAtomic)(fieldDef)) {
+            if ((0, boolean_value_1.booleanValueError)(fs, fieldDef, 'as a result column', this.reference, (0, boolean_value_1.resultColumnHint)(this.reference.refString))) {
+                return oops();
+            }
             const name = this.reference.nameString;
             const outputStruct = {
                 ...(0, malloy_types_1.sourceBase)(fs.structDef()),

package/dist/lang/ast/view-elements/refine-utils.js

@@ -33,6 +33,7 @@ function refine(logTo, refineTo, refineFrom) {
             if (from.orderBy !== undefined && !from.defaultOrderBy) {
                 if (to.orderBy === undefined || to.defaultOrderBy) {
                     to.orderBy = from.orderBy;
+                    delete to.defaultOrderBy;
                 }
                 else {
                     logTo.logError('ordering-overridden-in-refinement', 'refinement cannot override existing ordering');

package/dist/lang/composite-source-utils.js

@@ -28,6 +28,7 @@ exports.pathBegins = pathBegins;
 exports.hasCompositesAnywhere = hasCompositesAnywhere;
 exports.logCompositeError = logCompositeError;
 const malloy_filter_1 = require("@malloydata/malloy-filter");
+const sql_compiled_1 = require("../model/sql_compiled");
 const malloy_types_1 = require("../model/malloy_types");
 const utils_1 = require("./utils");
 const utils_2 = require("../model/utils");
@@ -1214,9 +1215,12 @@ function computeQueryGivenUsage(pipeline) {
     return result;
 }
 // Returns every given a SourceDef references — its own filterList plus any
-// givens hiding inside an embedded Query. The single point of knowledge for
-// "where can a Query embed in a SourceDef" — when a future SourceDef variant
-// grows an embedded Query, teach this helper.
+// givens hiding inside an embedded Query. For a persistable source the
+// embedded part is `givenUsageOfRelation` (model/sql_compiled.ts), which is
+// also what persistence keys a table on; the filterList is added here because
+// a query over the source applies it, but a table built from the source does
+// not. When a future SourceDef variant grows an embedded Query, teach that
+// helper or this one.
 //
 // Composite sources: composite-source support across the codebase is
 // partial; the givens work isn't chasing it. The `composite` arm here is
@@ -1226,23 +1230,12 @@ function computeQueryGivenUsage(pipeline) {
 // reaches here (e.g. composites in join positions if/when those work),
 // the conservative union over all branches is the safe fallback.
 function givenUsageOfSource(sd) {
-    var _a, _b, _c;
+    var _a;
     const fromFilters = ((_a = sd.filterList) !== null && _a !== void 0 ? _a : []).flatMap(f => (0, malloy_types_1.givenUsageFrom)(f.refSummary));
     switch (sd.type) {
         case 'query_source':
-            return [...fromFilters, ...((_b = sd.query.givenUsage) !== null && _b !== void 0 ? _b : [])];
-        case 'sql_select': {
-            const fromSegments = ((_c = sd.selectSegments) !== null && _c !== void 0 ? _c : []).flatMap(seg => {
-                var _a;
-                if ((0, malloy_types_1.isSegmentSQL)(seg))
-                    return [];
-                if ((0, malloy_types_1.isSegmentSource)(seg))
-                    return givenUsageOfSource(seg);
-                // Remaining variant of SQLPhraseSegment is `Query`
-                return (_a = seg.givenUsage) !== null && _a !== void 0 ? _a : [];
-            });
-            return [...fromFilters, ...fromSegments];
-        }
+        case 'sql_select':
+            return [...fromFilters, ...(0, sql_compiled_1.givenUsageOfRelation)(sd)];
         case 'composite':
             return [
                 ...fromFilters,

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

@@ -64,6 +64,17 @@ type MessageParameterTypes = {
     'nesting-unsupported': {
         dialect: string;
     };
+    'boolean-value-unsupported': {
+        dialect: string;
+        where: string;
+        hint: string;
+    };
+    'wildcard-omits-boolean': {
+        dialect: string;
+        wildcard: string;
+        name: string;
+        hint: string;
+    };
     'nested-multi-stage-unsupported': {
         dialect: string;
     };
@@ -297,6 +308,7 @@ type MessageParameterTypes = {
     'export-name-not-exportable': string;
     'duplicate-export-name': string;
     'unsatisfied-given-in-query': string;
+    'unsatisfied-given-in-persist-source': string;
     'given-alias-collision': string;
     'failed-to-compute-output-schema': string;
     'invalid-timeframe-for-time-offset': string;

package/dist/lang/parse-log.js

@@ -56,6 +56,8 @@ exports.MESSAGE_FORMATTERS = {
     }),
     'experimental-dialect-not-enabled': e => `Requires compiler flag '##! experimental.dialect.${e.dialect}'`,
     'nesting-unsupported': e => `'${e.dialect}' does not support nested queries`,
+    'boolean-value-unsupported': e => `'${e.dialect}' does not support a boolean ${e.where}; ${e.hint}`,
+    'wildcard-omits-boolean': e => `'${e.name}' is left out of '${e.wildcard}': '${e.dialect}' does not support a boolean as a result column; ${e.hint}`,
     'nested-multi-stage-unsupported': e => `'${e.dialect}' does not support a multi-stage pipeline ('->') in a nested query`,
     'nested-projection-limit-unsupported': e => `'${e.dialect}' does not support 'limit:' on a nested 'select:'`,
     'pick-missing-else': "pick incomplete, missing 'else'",

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

@@ -1,6 +1,7 @@
 import type { DocumentLocation, DocumentPosition, DocumentReference, ImportLocation, ModelDef, SourceDef, SQLSourceDef, DependencyTree, DocumentRange, VirtualMap } from '../model/malloy_types';
 import type { LogMessage, LogMessageOptions, MessageCode, MessageParameterType } from './parse-log';
 import { BaseMessageLogger } from './parse-log';
+import type { FindReferencesData } from './parse-tree-walkers/find-external-references';
 import type { ZoneData } from './zone';
 import { Zone } from './zone';
 import { ReferenceList } from './reference-list';
@@ -52,7 +53,7 @@ declare class ParseStep implements TranslationStep {
 }
 declare class ImportsAndTablesStep implements TranslationStep {
     readonly parseStep: ParseStep;
-    private parseReferences;
+    parseReferences: FindReferencesData | undefined;
     constructor(parseStep: ParseStep);
     step(that: MalloyTranslation): DataRequestResponse | ParseResponse;
 }
@@ -61,6 +62,16 @@ declare class ASTStep implements TranslationStep {
     response?: ASTResponse;
     private walked;
     constructor(importStep: ImportsAndTablesStep);
+    /**
+     * A file acknowledges an experimental dialect with
+     * `##! experimental.dialect.NAME` wherever it names a connection on that
+     * dialect. Every connection name in this file is already resolved to a
+     * dialect by the time the AST exists, and the file's compiler flags are
+     * known only now, so this is the first moment the check can run. The
+     * other place a file takes on a dialect is `import`, checked by
+     * `ImportStatement`.
+     */
+    private checkExperimentalDialects;
     step(that: MalloyTranslation): ASTResponse;
 }
 declare class MetadataStep implements TranslationStep {
@@ -166,8 +177,12 @@ export declare abstract class MalloyTranslation {
     rangeFromContext(pcx: ParserRuleContext): DocumentRange;
     private dialectAlreadyChecked;
     firstReferenceToDialect(dialect: string): boolean;
-    allDialectsEnabled: boolean;
     experimentalDialectEnabled(dialect: string): boolean;
+    /**
+     * Log, once per dialect per file, that this file uses an experimental
+     * dialect without acknowledging it.
+     */
+    checkExperimentalDialect(dialect: string, at: DocumentLocation): void;
 }
 export declare class MalloyChildTranslator extends MalloyTranslation {
     readonly root: MalloyTranslator;

package/dist/lang/parse-malloy.js

@@ -38,6 +38,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MalloyTranslator = exports.MalloyChildTranslator = exports.MalloyTranslation = void 0;
+const malloy_types_1 = require("../model/malloy_types");
 const utils_1 = require("../model/utils");
 const annotation_utils_1 = require("../model/annotation_utils");
 const ast = __importStar(require("./ast"));
@@ -132,14 +133,13 @@ class ImportsAndTablesStep {
             // 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) {
+            for (const [connName, need] of this.parseReferences.connectionDialects) {
                 that.root.connectionDialectZone.reference(connName, {
                     url: that.sourceURL,
-                    range: this.parseReferences.connectionDialects[connName].firstReference,
+                    range: need.firstReference,
                 });
             }
-            for (const relativeRef in this.parseReferences.urls) {
-                const firstRef = this.parseReferences.urls[relativeRef];
+            for (const [relativeRef, firstRef] of this.parseReferences.urls) {
                 try {
                     const ref = decodeURI(new URL(relativeRef, that.importBaseURL || that.sourceURL).toString());
                     that.addChild(ref);
@@ -171,8 +171,7 @@ class ImportsAndTablesStep {
         // Invalid paths are dropped here and re-reported by the AST step.
         // tableRequests feeds the missing-table loop below.
         const tableRequests = {};
-        for (const rawKey in this.parseReferences.tables) {
-            const info = this.parseReferences.tables[rawKey];
+        for (const info of this.parseReferences.tables.values()) {
             const dialectName = that.root.connectionDialectZone.get(info.connectionName);
             if (dialectName === undefined)
                 continue;
@@ -204,7 +203,9 @@ class ImportsAndTablesStep {
         }
         const missingDialects = that.root.connectionDialectZone.getUndefined();
         if (missingDialects) {
-            const connectionDialects = {};
+            // Keyed by connection name, user text: a plain `{}` would turn a
+            // connection named `__proto__` into a prototype and drop the request.
+            const connectionDialects = (0, malloy_types_1.mkSafeRecord)();
             for (const connName of missingDialects) {
                 connectionDialects[connName] = { connectionName: connName };
             }
@@ -237,6 +238,31 @@ class ASTStep {
         this.importStep = importStep;
         this.walked = false;
     }
+    /**
+     * A file acknowledges an experimental dialect with
+     * `##! experimental.dialect.NAME` wherever it names a connection on that
+     * dialect. Every connection name in this file is already resolved to a
+     * dialect by the time the AST exists, and the file's compiler flags are
+     * known only now, so this is the first moment the check can run. The
+     * other place a file takes on a dialect is `import`, checked by
+     * `ImportStatement`.
+     */
+    checkExperimentalDialects(that) {
+        var _a;
+        const connections = (_a = this.importStep.parseReferences) === null || _a === void 0 ? void 0 : _a.connectionDialects;
+        if (!connections) {
+            return;
+        }
+        for (const [connName, need] of connections) {
+            const dialect = that.root.connectionDialectZone.get(connName);
+            if (dialect !== undefined) {
+                that.checkExperimentalDialect(dialect, {
+                    url: that.sourceURL,
+                    range: need.firstReference,
+                });
+            }
+        }
+    }
     step(that) {
         const stepTimer = new timing_1.Timer('ast_step');
         if (this.response) {
@@ -262,6 +288,7 @@ class ASTStep {
         const { ast: newAST, compilerFlagSrc, timingInfo } = secondPass.run();
         stepTimer.contribute([timingInfo]);
         that.compilerFlagSrc = compilerFlagSrc;
+        this.checkExperimentalDialects(that);
         if (newAST.elementType === 'unimplemented') {
             newAST.logError('untranslated-parse-node', 'INTERNAL COMPILER ERROR: Untranslated parse node');
         }
@@ -429,9 +456,9 @@ class TranslateStep {
         // seeding (e.g. TestTranslator's compilerFlags option) survive.
         if (extendingModel && !this.importedAnnotations) {
             const parseCompilerFlagsTimer = new timing_1.Timer('parse_compiler_flags');
-            // Compiler flags from the extending base's `##` annotations. NOTE: `##!`
-            // flag semantics are still to be settled; this keeps the existing
-            // behavior (flags from the base model) green and is not the final design.
+            // `##!` is a pragma: it governs the file it sits in and does not cross
+            // `import`. An extension is a continuation of the base's text, so the
+            // base's flags are in force here.
             that.compilerFlagSrc.push(...new annotation_1.Annotations((0, annotation_utils_1.getModelAnnotations)(extendingModel)).texts('!'));
             stepTimer.contribute([parseCompilerFlagsTimer.stop()]);
             this.importedAnnotations = true;
@@ -515,7 +542,6 @@ class MalloyTranslation {
          Not sure where the logic for this needs to go, this is just my first guess
          */
         this.dialectAlreadyChecked = {};
-        this.allDialectsEnabled = false;
         this.childTranslators = new Map();
         this.modelDef = (0, utils_1.mkModelDef)(sourceURL, (0, utils_1.mkModelID)(sourceURL));
         /**
@@ -753,13 +779,21 @@ class MalloyTranslation {
         return true;
     }
     experimentalDialectEnabled(dialect) {
-        if (this.allDialectsEnabled) {
-            return true;
-        }
         const experimental = this.getCompilerFlags().tag('experimental');
         return (experimental !== undefined &&
             (experimental.bare() || experimental.has('dialect', dialect)));
     }
+    /**
+     * Log, once per dialect per file, that this file uses an experimental
+     * dialect without acknowledging it.
+     */
+    checkExperimentalDialect(dialect, at) {
+        if (this.firstReferenceToDialect(dialect) &&
+            (0, dialect_1.getDialect)(dialect).isExperimental() &&
+            !this.experimentalDialectEnabled(dialect)) {
+            this.root.logError('experimental-dialect-not-enabled', { dialect }, { at });
+        }
+    }
 }
 exports.MalloyTranslation = MalloyTranslation;
 class MalloyChildTranslator extends MalloyTranslation {

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

@@ -2,13 +2,13 @@ import type { CommonTokenStream } from 'antlr4ts';
 import type { ParseTree } from 'antlr4ts/tree';
 import type { DocumentRange } from '../../model/malloy_types';
 import type { MalloyTranslation } from '../parse-malloy';
-type NeedImports = Record<string, DocumentRange>;
-type NeedTables = Record<string, {
+type NeedImports = Map<string, DocumentRange>;
+type NeedTables = Map<string, {
     connectionName: string;
     tablePath: string;
     firstReference: DocumentRange;
 }>;
-type NeedConnectionDialects = Record<string, {
+type NeedConnectionDialects = Map<string, {
     firstReference: DocumentRange;
 }>;
 export declare function constructTableKey(connectionName: string, tablePath: string): string;