@malloydata/malloy 0.0.190 → 0.0.191-dev240925232958

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

@@ -1,4 +1,4 @@
-import { DocumentLocation } from '../model/malloy_types';
+import { DocumentLocation, FieldValueType } from '../model/malloy_types';
 export type LogSeverity = 'error' | 'warn' | 'debug';
 /**
  * Default severity is "error"
@@ -7,8 +7,10 @@ export interface LogMessage {
     message: string;
     at?: DocumentLocation;
     severity: LogSeverity;
-    errorTag?: string;
+    code: string;
     replacement?: string;
+    errorTag?: string;
+    data?: any;
 }
 export interface MessageLogger {
     log(logMsg: LogMessage): void;
@@ -18,14 +20,11 @@ export interface MessageLogger {
     noErrors(): boolean;
     empty(): boolean;
 }
-export declare class MessageLog implements MessageLogger {
+export declare class BaseMessageLogger implements MessageLogger {
     private rawLog;
     getLog(): LogMessage[];
     /**
      * Add a message to the log.
-     *
-     * If the messsage ends with '[tag]', the tag is removed and stored in the `errorTag` field.
-     * @param logMsg Message possibly containing an error tag
      */
     log(logMsg: LogMessage): void;
     reset(): void;
@@ -33,3 +32,321 @@ export declare class MessageLog implements MessageLogger {
     hasErrors(): boolean;
     empty(): boolean;
 }
+type MessageParameterTypes = {
+    'pick-type-does-not-match': {
+        pickType: FieldValueType;
+        returnType: FieldValueType;
+    };
+    'pick-else-type-does-not-match': {
+        elseType: FieldValueType;
+        returnType: FieldValueType;
+    };
+    'pick-default-type-does-not-match': {
+        defaultType: FieldValueType;
+        returnType: FieldValueType;
+    };
+    'pick-missing-else': {};
+    'pick-missing-value': {};
+    'pick-illegal-partial': {};
+    'pick-when-must-be-boolean': {
+        whenType: string;
+    };
+    'experiment-not-enabled': {
+        experimentId: string;
+    };
+    'experimental-dialect-not-enabled': {
+        dialect: string;
+    };
+    'sql-native-not-allowed-in-expression': {
+        rawType: string | undefined;
+    };
+    'ambiguous-view-type': {};
+    'failed-to-compute-absolute-import-url': string;
+    'import-error': {
+        message: string;
+        url: string;
+    };
+    'parsed-non-malloy-document': {
+        url: string;
+    };
+    'parse-exception': {
+        message: string;
+    };
+    'syntax-error': {
+        message: string;
+    };
+    'internal-translator-error': {
+        message: string;
+    };
+    'invalid-timezone': {
+        timezone: string;
+    };
+    'aggregate-source-not-found': string;
+    'name-conflict-with-global': string;
+    'too-many-arguments-for-time-extraction': string;
+    'invalid-type-for-time-extraction': string;
+    'invalid-types-for-time-measurement': string;
+    'invalid-timeframe-for-time-measurement': string;
+    'invalid-time-extraction-unit': string;
+    'untranslated-parse-node': string;
+    'invalid-aggregate-source': string;
+    'missing-aggregate-expression': string;
+    'aggregate-of-aggregate': string;
+    'bad-join-usage': string;
+    'aggregate-traverses-join-cross': string;
+    'aggregate-traverses-join-many': string;
+    'aggregate-traverses-repeated-relationship': string;
+    'alternation-as-value': string;
+    'invalid-sql-native-type': string;
+    'mismatched-coalesce-types': string;
+    'function-not-found': string;
+    'case-insensitive-function': string;
+    'struct-not-callable': string;
+    'connection-not-callable': string;
+    'query-not-callable': string;
+    'no-matching-function-overload': string;
+    'invalid-function-argument-expression-type': string;
+    'invalid-function-argument-evaluation-space': string;
+    'literal-null-function-argument': string;
+    'non-aggregate-function-with-source': string;
+    'aggregate-order-by-experiment-not-enabled': string;
+    'function-does-not-support-order-by': string;
+    'function-does-not-support-limit': string;
+    'partition-by-not-found': string;
+    'non-scalar-or-aggregate-partition-by': string;
+    'sql-functions-experiment-not-enabled': string;
+    'invalid-sql-function-argument': string;
+    'unsupported-sql-function-interpolation': string;
+    'sql-function-interpolation-not-found': string;
+    'function-returns-any': string;
+    'unsupported-type-for-time-truncation': string;
+    'filter-of-non-aggregate': string;
+    'aggregate-filter-expression-not-scalar': string;
+    'partition-by-of-non-window-function': string;
+    'expression-limit-already-specified': string;
+    'limit-of-non-aggregate-function': string;
+    'order-by-of-non-aggregate-function': string;
+    'unsupported-type-for-time-extraction': string;
+    'ungroup-of-non-aggregate': string;
+    'ungroup-of-ungrouped-aggregate': string;
+    'ungroup-field-not-in-output': string;
+    'ungroup-with-non-scalar': string;
+    'invalid-duration-quantity': string;
+    'range-as-value': string;
+    'analytic-order-by-missing-field': string;
+    'analytic-order-by-not-output': string;
+    'analytic-order-by-not-aggregate-or-output': string;
+    'aggregate-order-by-not-scalar': string;
+    'aggregate-order-by-expression-not-allowed': string;
+    'aggregate-order-by-without-field-or-direction': string;
+    'partial-as-value': string;
+    'top-by-non-aggregate': string;
+    'definition-name-conflict': string;
+    'invalid-field-in-index-query': string;
+    'invalid-wildcard-source': string;
+    'wildcard-source-not-found': string;
+    'name-conflict-in-wildcard-expansion': string;
+    'invalid-parameter-reference': string;
+    'parameter-not-found': string;
+    'wildcard-source-not-defined': string;
+    'unexpected-index-segment': string;
+    'accept-parameter': string;
+    'except-parameter': string;
+    'field-list-edit-not-found': string;
+    'unexpected-element-type': string;
+    'field-not-found': string;
+    'invalid-property-access-in-field-reference': string;
+    'parameter-default-does-not-match-declared-type': string;
+    'parameter-null-default-without-declared-type': string;
+    'parameter-illegal-default-type': string;
+    'parameter-missing-default-or-type': string;
+    'index-limit-already-specified': string;
+    'index-by-already-specified': string;
+    'illegal-operation-for-index': string;
+    'refinement-of-index-segment': string;
+    'incompatible-segment-for-select-refinement': string;
+    'illegal-operation-in-select-segment': string;
+    'limit-already-specified': string;
+    'ordering-already-specified': string;
+    'incompatible-segment-for-reduce-refinement': string;
+    'query-reference-not-found': string;
+    'non-query-used-as-query': string;
+    'failed-field-definition': string;
+    'null-typed-field-definition': string;
+    'invalid-type-for-field-definition': string;
+    'circular-reference-in-field-definition': string;
+    'output-name-conflict': string;
+    'select-of-view': string;
+    'select-of-analytic': string;
+    'select-of-aggregate': string;
+    'aggregate-in-dimension': string;
+    'index-of-view': string;
+    'index-of-analytic': string;
+    'index-of-aggregate': string;
+    'analytic-in-dimension': string;
+    'scalar-in-measure': string;
+    'analytic-in-measure': string;
+    'view-in-declare': string;
+    'analytic-in-declare': string;
+    'calculate-of-view': string;
+    'calculate-of-aggregate': string;
+    'calculate-of-scalar': string;
+    'aggregate-of-view': string;
+    'aggregate-of-analytic': string;
+    'aggregate-of-scalar': string;
+    'group-by-view': string;
+    'group-by-analytic': string;
+    'group-by-aggregate': string;
+    'non-boolean-filter': string;
+    'analytic-in-having': string;
+    'analytic-in-where': string;
+    'aggregate-in-where': string;
+    'order-by-not-found-in-output': string;
+    'order-by-analytic': string;
+    'illegal-index-operation': string;
+    'illegal-project-operation': string;
+    'illegal-grouping-operation': string;
+    'top-by-not-found-in-output': string;
+    'top-by-analytic': string;
+    'top-by-aggregate': string;
+    'top-by-not-in-output': string;
+    'source-not-found': string;
+    'invalid-source-from-query': string;
+    'invalid-source-from-function': string;
+    'invalid-source-from-connection': string;
+    'invalid-source-from-sql-block': string;
+    'unnamed-source-argument': string;
+    'duplicate-source-argument': string;
+    'source-parameter-not-found': string;
+    'missing-source-argument': string;
+    'multiple-field-list-edits': string;
+    'multiple-primary-keys': string;
+    'unexpected-source-property': string;
+    'aggregate-in-source-filter': string;
+    'invalid-connection-for-sql-source': string;
+    'failed-to-fetch-sql-source-schema': string;
+    'invalid-sql-source': string;
+    'non-top-level-sql-source': string;
+    'failed-to-fetch-table-schema': string;
+    'invalid-connection-for-table-source': string;
+    'join-on-primary-key-type-mismatch': string;
+    'join-primary-key-not-found': string;
+    'join-with-without-primary-key': string;
+    'non-boolean-join-on': string;
+    'invalid-rename-with-same-name': string;
+    'failed-rename': string;
+    'rename-field-not-found': string;
+    'invalid-join-source': string;
+    'failed-to-compute-arrow-source': string;
+    'failed-to-compute-source-from-query': string;
+    'failed-to-compute-source-to-extend': string;
+    'cannot-use-function-as-query': string;
+    'cannot-use-struct-as-query': string;
+    'cannot-use-connection-as-query': string;
+    'source-or-query-not-found': string;
+    'illegal-query-argument': string;
+    'cannot-use-function-as-source': string;
+    'cannot-use-connection-as-source': string;
+    'illegal-refinement-of-source': string;
+    'invalid-source-as-query': string;
+    'invalid-sql-source-interpolation': string;
+    'failed-to-expand-sql-source': string;
+    'query-definition-name-conflict': string;
+    'query-definition-from-non-query': string;
+    'source-definition-name-conflict': string;
+    'parameter-name-conflict': string;
+    'parameter-shadowing-field': string;
+    'invalid-import-url': string;
+    'no-translator-for-import': string;
+    'name-conflict-on-selective-import': string;
+    'selective-import-not-found': string;
+    'name-conflict-on-indiscriminate-import': string;
+    'failed-import': string;
+    'failed-to-compute-output-schema': string;
+    'invalid-timeframe-for-time-offset': string;
+    'time-comparison-type-mismatch': string;
+    'arithmetic-operation-type-mismatch': string;
+    'time-offset-type-mismatch': string;
+    'unexpected-binary-operator': string;
+    'illegal-reference-in-parameter-default': string;
+    'aggregate-analytic-in-select': string;
+    'refinement-of-raw-query': string;
+    'illegal-multistage-refinement-operation': string;
+    'illegal-refinement-operation': string;
+    'view-not-found': string;
+    'refinement-with-joined-view': string;
+    'nest-of-joined-view': string;
+    'refinement-with-source': string;
+    'nest-of-source': string;
+    'mismatched-view-types-for-refinement': string;
+    'ordering-overridden-in-refinement': string;
+    'limit-overridden-in-refinement': string;
+    'name-conflict-in-refinement': string;
+    'refinement-with-multistage-view': string;
+    'foreign-key-in-join-cross': string;
+    'expression-type-error': string;
+    'unexpected-statement-in-translation': string;
+    'filter-shortcut': string;
+    'illegal-query-interpolation-outside-sql-block': string;
+    'percent-terminated-query-interpolation': string;
+    'failed-to-parse-time-literal': string;
+    'table-function': string;
+    'missing-on-in-join-many': string;
+    'foreign-key-in-join-many': string;
+    'join-statement-in-view': string;
+    'unknown-matrix-operation': string;
+    'declare': string;
+    'query-in-source': string;
+    'invalid-reference-only-aggregation': string;
+    'project': string;
+    'top-by': string;
+    'anonymous-query': string;
+    'anonymous-nest': string;
+    'count-expression-with-locality': string;
+    'invalid-symmetric-aggregate': string;
+    'invalid-asymmetric-aggregate': string;
+    'aggregate-parse-error': string;
+    'wildcard-in-aggregate': string;
+    'unexpected-malloy-type': string;
+    'failed-to-parse-function-name': string;
+    'orphaned-object-annotation': string;
+    'misplaced-model-annotation': string;
+    'unexpected-non-source-query-expression-node': string;
+    'sql-not-like': string;
+    'sql-like': string;
+    'sql-is-not-null': string;
+    'sql-is-null': string;
+};
+export declare const MESSAGE_FORMATTERS: PartialErrorCodeMessageMap;
+export type MessageCode = keyof MessageParameterTypes;
+export type MessageParameterType<T extends MessageCode> = MessageParameterTypes[T];
+type MessageFormatter<T extends MessageCode> = MessageInfo | ((parameters: MessageParameterType<T>) => MessageInfo);
+type ErrorCodeMessageMap = {
+    [key in keyof MessageParameterTypes]: MessageFormatter<key>;
+};
+type PartialErrorCodeMessageMap = Partial<ErrorCodeMessageMap>;
+type MessageInfo = string | {
+    message: string;
+    severity?: LogSeverity;
+    replacement?: string;
+    tag?: string;
+    data?: any;
+};
+export interface ALogMessage<T extends MessageCode> {
+    code: T;
+    message: string;
+    at?: DocumentLocation;
+    data: MessageParameterType<T>;
+    severity: LogSeverity;
+    errorTag?: string;
+    replacement?: string;
+}
+export type AnyLogMessage = ALogMessage<MessageCode>;
+export interface LogMessageOptions {
+    replacement?: string;
+    at?: DocumentLocation;
+    severity?: LogSeverity;
+    tag?: string;
+}
+export declare function makeLogMessage<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: LogMessageOptions): LogMessage;
+export {};

package/dist/lang/parse-log.js

@@ -22,8 +22,8 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageLog = void 0;
-class MessageLog {
+exports.makeLogMessage = exports.MESSAGE_FORMATTERS = exports.BaseMessageLogger = void 0;
+class BaseMessageLogger {
     constructor() {
         this.rawLog = [];
     }
@@ -32,21 +32,8 @@ class MessageLog {
     }
     /**
      * Add a message to the log.
-     *
-     * If the messsage ends with '[tag]', the tag is removed and stored in the `errorTag` field.
-     * @param logMsg Message possibly containing an error tag
      */
     log(logMsg) {
-        const msg = logMsg.message;
-        // github security is worried about msg.match(/^(.+)\[(.+)\]$/ because if someone
-        // could craft code with a long varibale name which would blow up that regular expression
-        if (msg.endsWith(']')) {
-            const tagStart = msg.lastIndexOf('[');
-            if (tagStart > 0) {
-                logMsg.message = msg.slice(0, tagStart);
-                logMsg.errorTag = msg.slice(tagStart + 1, -1);
-            }
-        }
         this.rawLog.push(logMsg);
     }
     reset() {
@@ -63,5 +50,64 @@ class MessageLog {
         return this.rawLog.length === 0;
     }
 }
-exports.MessageLog = MessageLog;
+exports.BaseMessageLogger = BaseMessageLogger;
+exports.MESSAGE_FORMATTERS = {
+    'pick-type-does-not-match': e => ({
+        message: `pick type \`${e.pickType}\` does not match return type \`${e.returnType}\``,
+        tag: 'pick-values-must-match',
+    }),
+    'pick-else-type-does-not-match': e => ({
+        message: `else type \`${e.elseType}\` does not match return type \`${e.returnType}\``,
+        tag: 'pick-values-must-match',
+    }),
+    'pick-default-type-does-not-match': e => ({
+        message: `default type \`${e.defaultType}\` does not match return type \`${e.returnType}\``,
+        tag: 'pick-values-must-match',
+    }),
+    'experimental-dialect-not-enabled': e => `Requires compiler flag '##! experimental.dialect.${e.dialect}'`,
+    'pick-missing-else': "pick incomplete, missing 'else'",
+    'pick-missing-value': 'pick with no value can only be used with apply',
+    'pick-illegal-partial': 'pick with partial when can only be used with apply',
+    'pick-when-must-be-boolean': e => `when expression must be boolean, not ${e.whenType}`,
+    'sql-native-not-allowed-in-expression': e => ({
+        message: `Unsupported SQL native type '${e.rawType}' not allowed in expression`,
+        tag: 'unsupported-sql-native-type-not-allowed-in-expression',
+    }),
+    'experiment-not-enabled': e => `Experimental flag \`${e.experimentId}\` is not set, feature not available`,
+    'ambiguous-view-type': "Can't determine view type (`group_by` / `aggregate` / `nest`, `project`, `index`)",
+    'import-error': e => e.message.includes(e.url)
+        ? `import error: ${e.message}`
+        : `import '${e.url}' error: ${e.message}`,
+    'parsed-non-malloy-document': e => `'${e.url}' did not parse to malloy document`,
+    'parse-exception': e => `Malloy internal parser exception [${e.message}]`,
+    'syntax-error': e => e.message,
+    'internal-translator-error': e => `Internal Translator Error: ${e.message}`,
+    'invalid-timezone': e => `Invalid timezone: ${e.timezone}`,
+};
+function makeLogMessage(code, parameters, options) {
+    var _a, _b, _c, _d, _e;
+    const format = exports.MESSAGE_FORMATTERS[code];
+    const info = format
+        ? format instanceof Function
+            ? format(parameters)
+            : format
+        : typeof parameters === 'string'
+            ? parameters
+            : undefined;
+    if (info === undefined) {
+        throw new Error(`No message formatter for error code \`${code}\`.`);
+    }
+    const template = typeof info === 'string' ? { message: info } : info;
+    const data = ((_a = template.data) !== null && _a !== void 0 ? _a : typeof parameters === 'string') ? null : parameters;
+    return {
+        code,
+        data,
+        message: template.message,
+        severity: (_c = (_b = options === null || options === void 0 ? void 0 : options.severity) !== null && _b !== void 0 ? _b : template.severity) !== null && _c !== void 0 ? _c : 'error',
+        errorTag: (_d = options === null || options === void 0 ? void 0 : options.tag) !== null && _d !== void 0 ? _d : template.tag,
+        replacement: (_e = options === null || options === void 0 ? void 0 : options.replacement) !== null && _e !== void 0 ? _e : template.replacement,
+        at: options === null || options === void 0 ? void 0 : options.at,
+    };
+}
+exports.makeLogMessage = makeLogMessage;
 //# sourceMappingURL=parse-log.js.map

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

@@ -1,6 +1,6 @@
 import { ANTLRErrorListener, ParserRuleContext, Token } from 'antlr4ts';
 import { DocumentLocation, DocumentPosition, DocumentRange, DocumentReference, ImportLocation, ModelDef, NamedModelObject, Query, SQLBlockStructDef, StructDef } from '../model/malloy_types';
-import { LogMessage, MessageLog, MessageLogger } from './parse-log';
+import { BaseMessageLogger, LogMessage, LogMessageOptions, MessageCode, MessageLogger, MessageParameterType } from './parse-log';
 import { Zone, ZoneData } from './zone';
 import { ReferenceList } from './reference-list';
 import { ASTResponse, CompletionsResponse, DataRequestResponse, ProblemResponse, FatalResponse, FinalResponse, HelpContextResponse, MetadataResponse, ModelDataRequest, NeedURLData, TranslateResponse, ModelAnnotationResponse, TablePathResponse } from './translate-response';
@@ -187,10 +187,11 @@ export declare class MalloyTranslator extends MalloyTranslation {
     schemaZone: Zone<StructDef>;
     importZone: Zone<string>;
     sqlQueryZone: Zone<SQLBlockStructDef>;
-    logger: MessageLog;
+    logger: BaseMessageLogger;
     readonly root: MalloyTranslator;
     constructor(rootURL: string, importURL?: string | null, preload?: ParseUpdate | null);
     update(dd: ParseUpdate): void;
+    logError<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: Omit<LogMessageOptions, 'severity'>): T;
 }
 interface ErrorData {
     tables: Record<string, string>;
@@ -214,6 +215,7 @@ export declare class MalloyParserErrorHandler implements ANTLRErrorListener<Toke
     readonly translator: MalloyTranslation;
     readonly messages: MessageLogger;
     constructor(translator: MalloyTranslation, messages: MessageLogger);
-    syntaxError(recognizer: unknown, offendingSymbol: Token | undefined, line: number, charPositionInLine: number, msg: string, _e: unknown): void;
+    logError<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: Omit<LogMessageOptions, 'severity'>): T;
+    syntaxError(recognizer: unknown, offendingSymbol: Token | undefined, line: number, charPositionInLine: number, message: string, _e: unknown): void;
 }
 export {};

package/dist/lang/parse-malloy.js

@@ -88,10 +88,7 @@ class ParseStep {
             catch (e) {
                 const msg = e instanceof Error ? e.message : '';
                 that.urlIsFullPath = false;
-                that.root.logger.log({
-                    message: `Could not compute full path URL: ${msg}`,
-                    severity: 'error',
-                });
+                that.root.logError('failed-to-compute-absolute-import-url', `Could not compute full path URL: ${msg}`);
             }
         }
         if (!that.urlIsFullPath) {
@@ -100,11 +97,11 @@ class ParseStep {
         const srcEnt = that.root.importZone.getEntry(that.sourceURL);
         if (srcEnt.status !== 'present') {
             if (srcEnt.status === 'error') {
-                const message = srcEnt.message.includes(that.sourceURL)
-                    ? `import error: ${srcEnt.message}`
-                    : `import '${that.sourceURL}' error: ${srcEnt.message}`;
                 const at = srcEnt.firstReference || that.defaultLocation();
-                that.root.logger.log({ message, at, severity: 'error' });
+                that.root.logError('import-error', {
+                    message: srcEnt.message,
+                    url: that.sourceURL,
+                }, { at });
                 this.response = that.fatalResponse();
                 return this.response;
             }
@@ -117,10 +114,7 @@ class ParseStep {
             parse = this.runParser(source, that);
         }
         catch (parseException) {
-            that.root.logger.log({
-                message: `Malloy internal parser exception [${parseException.message}]`,
-                severity: 'error',
-            });
+            that.root.logError('parse-exception', { message: parseException.message });
             parse = undefined;
         }
         if (that.root.logger.hasErrors()) {
@@ -231,11 +225,7 @@ class ImportsAndTablesStep {
                     // This import spec is so bad the URL library threw up, this
                     // may be impossible, because it will append any garbage
                     // to the known good rootURL assuming it is relative
-                    that.root.logger.log({
-                        message: `Malformed URL '${relativeRef}'"`,
-                        at: { url: that.sourceURL, range: firstRef },
-                        severity: 'error',
-                    });
+                    that.root.logError('invalid-import-url', `Malformed URL '${relativeRef}'"`, { at: { url: that.sourceURL, range: firstRef } });
                 }
             }
         }
@@ -300,7 +290,7 @@ class ASTStep {
         const newAst = secondPass.visit(parse.root);
         that.compilerFlags = secondPass.compilerFlags;
         if (newAst.elementType === 'unimplemented') {
-            newAst.log('INTERNAL COMPILER ERROR: Untranslated parse node');
+            newAst.logError('untranslated-parse-node', 'INTERNAL COMPILER ERROR: Untranslated parse node');
         }
         if (!this.walked) {
             // The DocumentStatement.needs method has largely replaced the need to walk
@@ -308,7 +298,7 @@ class ASTStep {
             // it should probably never be hit
             for (const walkedTo of newAst.walk()) {
                 if (walkedTo instanceof ast.Unimplemented) {
-                    walkedTo.log('INTERNAL COMPILER ERROR: Untranslated parse node');
+                    walkedTo.logError('untranslated-parse-node', 'INTERNAL COMPILER ERROR: Untranslated parse node');
                 }
             }
             this.walked = true;
@@ -503,11 +493,7 @@ class TranslateStep {
                 }
             }
             else {
-                that.root.logger.log({
-                    message: `'${that.sourceURL}' did not parse to malloy document`,
-                    at: that.defaultLocation(),
-                    severity: 'error',
-                });
+                that.root.logError('parsed-non-malloy-document', { url: that.sourceURL }, { at: that.defaultLocation() });
             }
         }
         if (that.root.logger.hasErrors()) {
@@ -825,7 +811,7 @@ class MalloyTranslator extends MalloyTranslation {
         this.schemaZone = new zone_1.Zone();
         this.importZone = new zone_1.Zone();
         this.sqlQueryZone = new zone_1.Zone();
-        this.logger = new parse_log_1.MessageLog();
+        this.logger = new parse_log_1.BaseMessageLogger();
         this.root = this;
         if (preload) {
             this.update(preload);
@@ -837,6 +823,10 @@ class MalloyTranslator extends MalloyTranslation {
         this.importZone.updateFrom(dd.urls, (_b = dd.errors) === null || _b === void 0 ? void 0 : _b.urls);
         this.sqlQueryZone.updateFrom(dd.compileSQL, (_c = dd.errors) === null || _c === void 0 ? void 0 : _c.compileSQL);
     }
+    logError(code, parameters, options) {
+        this.logger.log((0, parse_log_1.makeLogMessage)(code, parameters, { severity: 'error', ...options }));
+        return code;
+    }
 }
 exports.MalloyTranslator = MalloyTranslator;
 class MalloyParserErrorHandler {
@@ -844,17 +834,18 @@ class MalloyParserErrorHandler {
         this.translator = translator;
         this.messages = messages;
     }
-    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, _e) {
+    logError(code, parameters, options) {
+        this.messages.log((0, parse_log_1.makeLogMessage)(code, parameters, { severity: 'error', ...options }));
+        return code;
+    }
+    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, message, _e) {
         const errAt = { line: line - 1, character: charPositionInLine };
         const range = offendingSymbol
             ? this.translator.rangeFromToken(offendingSymbol)
             : { start: errAt, end: errAt };
-        const error = {
-            message: msg,
+        this.logError('syntax-error', { message }, {
             at: { url: this.translator.sourceURL, range },
-            severity: 'error',
-        };
-        this.messages.log(error);
+        });
     }
 }
 exports.MalloyParserErrorHandler = MalloyParserErrorHandler;

package/dist/lang/test/annotation.spec.js

@@ -232,12 +232,12 @@ describe('document annotation', () => {
       # note1
       ## model1
     `);
-        expect(m).translationToFailWith('Object annotation not connected to any object');
+        expect(m).toLog((0, test_translator_1.errorMessage)('Object annotation not connected to any object'));
     });
     test('errors reported from compiler flags', () => {
         expect(`
       ##! missingCloseQuote="...
-    `).translationToFailWith(/no viable alternative at input/);
+    `).toLog((0, test_translator_1.errorMessage)(/no viable alternative at input/));
     });
     test('checking compiler flags', () => {
         const m = (0, test_translator_1.model) `
@@ -379,7 +379,7 @@ describe('source definition annotations', () => {
         ## model1
       }
     `);
-        expect(m).translationToFailWith('Model annotations not allowed at this scope');
+        expect(m).toLog((0, test_translator_1.errorMessage)('Model annotations not allowed at this scope'));
     });
 });
 describe('query operation annotations', () => {
@@ -389,7 +389,7 @@ describe('query operation annotations', () => {
         ## model1
         select: *
       }
-    `).translationToFailWith('Model annotations not allowed at this scope');
+    `).toLog((0, test_translator_1.errorMessage)('Model annotations not allowed at this scope'));
     });
     test('project new definition annotation', () => {
         const m = new test_translator_1.TestTranslator(`