@malloydata/malloy 0.0.190 → 0.0.191-dev240925232958

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

@@ -4,7 +4,7 @@ import { AbstractParseTreeVisitor } from 'antlr4ts/tree/AbstractParseTreeVisitor
 import { MalloyParserVisitor } from './lib/Malloy/MalloyParserVisitor';
 import * as parse from './lib/Malloy/MalloyParser';
 import * as ast from './ast';
-import { LogSeverity, MessageLogger } from './parse-log';
+import { LogMessageOptions, LogSeverity, MessageCode, MessageLogger, MessageParameterType } from './parse-log';
 import { MalloyParseInfo } from './malloy-parse-info';
 import { FieldDeclarationConstructor } from './ast';
 import { HasString, HasID } from './parse-utils';
@@ -39,20 +39,20 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
      * are not compatible.
      * @return an error object to throw.
      */
-    protected internalError(cx: ParserRuleContext, msg: string): Error;
+    protected internalError(cx: ParserRuleContext, message: string): Error;
     /**
      * Log an error message relative to an AST node
      */
-    protected astError(el: ast.MalloyElement, str: string, sev?: LogSeverity): void;
+    protected astError<T extends MessageCode>(el: ast.MalloyElement, code: T, data: MessageParameterType<T>, options?: LogMessageOptions): void;
     protected getLocation(cx: ParserRuleContext): DocumentLocation;
     /**
      * Log an error message relative to a parse node
      */
-    protected contextError(cx: ParserRuleContext, msg: string, sev?: LogSeverity): void;
-    protected warnWithReplacement(message: string, range: DocumentRange, replacement: string): void;
-    protected inExperiment(experimentID: string, cx: ParserRuleContext): boolean;
+    protected contextError<T extends MessageCode>(cx: ParserRuleContext, code: T, data: MessageParameterType<T>, options?: LogMessageOptions): void;
+    protected warnWithReplacement<T extends MessageCode>(code: T, data: MessageParameterType<T>, range: DocumentRange, replacement: string): void;
+    protected inExperiment(experimentId: string, cx: ParserRuleContext): boolean;
     protected m4Severity(): LogSeverity | false;
-    protected m4advisory(cx: ParserRuleContext, msg: string): void;
+    protected m4advisory<T extends MessageCode>(cx: ParserRuleContext, code: T, data: MessageParameterType<T>): void;
     protected only<T extends ast.MalloyElement>(els: ast.MalloyElement[], isGood: (el: ast.MalloyElement) => T | false, desc: string): T[];
     protected getNumber(term: ParseTree): number;
     protected getFieldName(cx: HasID): ast.FieldName;

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

@@ -50,6 +50,7 @@ exports.MalloyToAST = void 0;
 const antlr4ts_1 = require("antlr4ts");
 const AbstractParseTreeVisitor_1 = require("antlr4ts/tree/AbstractParseTreeVisitor");
 const ast = __importStar(require("./ast"));
+const parse_log_1 = require("./parse-log");
 const Interval_1 = require("antlr4ts/misc/Interval");
 const ast_1 = require("./ast");
 const parse_utils_1 = require("./parse-utils");
@@ -93,16 +94,15 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
      * are not compatible.
      * @return an error object to throw.
      */
-    internalError(cx, msg) {
-        const tmsg = `Internal Translator Error: ${msg}`;
-        this.contextError(cx, tmsg);
-        return new Error(tmsg);
+    internalError(cx, message) {
+        this.contextError(cx, 'internal-translator-error', { message });
+        return new Error(`Internal Translator Error: ${message}`);
     }
     /**
      * Log an error message relative to an AST node
      */
-    astError(el, str, sev = 'error') {
-        this.msgLog.log({ message: str, at: el.location, severity: sev });
+    astError(el, code, data, options) {
+        this.msgLog.log((0, parse_log_1.makeLogMessage)(code, data, { at: el.location, ...options }));
     }
     getLocation(cx) {
         return {
@@ -113,28 +113,26 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     /**
      * Log an error message relative to a parse node
      */
-    contextError(cx, msg, sev = 'error') {
-        this.msgLog.log({
-            message: msg,
+    contextError(cx, code, data, options) {
+        this.msgLog.log((0, parse_log_1.makeLogMessage)(code, data, {
             at: this.getLocation(cx),
-            severity: sev,
-        });
+            ...options,
+        }));
     }
-    warnWithReplacement(message, range, replacement) {
-        this.msgLog.log({
-            message,
+    warnWithReplacement(code, data, range, replacement) {
+        this.msgLog.log((0, parse_log_1.makeLogMessage)(code, data, {
             at: { url: this.parseInfo.sourceURL, range },
             severity: 'warn',
             replacement,
-        });
+        }));
     }
-    inExperiment(experimentID, cx) {
+    inExperiment(experimentId, cx) {
         const experimental = this.compilerFlags.tag('experimental');
         if (experimental &&
-            (experimental.bare() || experimental.has(experimentID))) {
+            (experimental.bare() || experimental.has(experimentId))) {
             return true;
         }
-        this.contextError(cx, `Experimental flag '${experimentID}' required to enable this feature`);
+        this.contextError(cx, 'experiment-not-enabled', { experimentId });
         return false;
     }
     m4Severity() {
@@ -144,10 +142,10 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         }
         return false;
     }
-    m4advisory(cx, msg) {
+    m4advisory(cx, code, data) {
         const m4 = this.m4Severity();
         if (m4) {
-            this.contextError(cx, msg, m4);
+            this.contextError(cx, code, data, { severity: m4 });
         }
     }
     only(els, isGood, desc) {
@@ -158,7 +156,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
                 acceptable.push(checked);
             }
             else if (!(el instanceof IgnoredElement)) {
-                this.astError(el, `Parser enountered unexpected statement type '${el.elementType}' when it needed '${desc}'`);
+                this.astError(el, 'unexpected-statement-in-translation', `Parser enountered unexpected statement type '${el.elementType}' when it needed '${desc}'`);
             }
         }
         return acceptable;
@@ -205,14 +203,14 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     }
     getFilterShortcut(cx) {
         const el = this.getFilterElement(cx.fieldExpr());
-        this.m4advisory(cx, 'Filter shortcut `{? condition }` is deprecated; use `{ where: condition } instead');
+        this.m4advisory(cx, 'filter-shortcut', 'Filter shortcut `{? condition }` is deprecated; use `{ where: condition } instead');
         return new ast.Filter([el]);
     }
     getPlainStringFrom(cx) {
         const [result, errors] = (0, parse_utils_1.getPlainString)(cx);
         for (const error of errors) {
             if (error instanceof antlr4ts_1.ParserRuleContext) {
-                this.contextError(error, '%{ query } illegal in this string');
+                this.contextError(error, 'illegal-query-interpolation-outside-sql-block', '%{ query } illegal in this string');
             }
         }
         return result || '';
@@ -220,7 +218,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     makeSqlString(pcx, sqlStr) {
         for (const part of pcx.sqlInterpolation()) {
             if (part.CLOSE_CODE()) {
-                this.m4advisory(part, 'Use %{ ... } instead of %{ ... }%');
+                this.m4advisory(part, 'percent-terminated-query-interpolation', 'Use %{ ... } instead of %{ ... }%');
             }
         }
         for (const part of (0, parse_utils_1.getStringParts)(pcx)) {
@@ -244,7 +242,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     parseTime(pcx, parse) {
         let def = parse(pcx.text);
         if (!def) {
-            this.contextError(pcx, 'Time data parse error');
+            this.contextError(pcx, 'failed-to-parse-time-literal', 'Time data parse error');
             // return a value node so the parse can continue
             def = new ast.LiteralTimestamp({ text: pcx.text });
         }
@@ -321,7 +319,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     visitTableFunction(pcx) {
         const tableURI = this.getPlainStringFrom(pcx.tableURI());
         const el = this.astAt(new ast.TableFunctionSource(tableURI), pcx);
-        this.m4advisory(pcx, "`table('connection_name:table_path')` is deprecated; use `connection_name.table('table_path')`");
+        this.m4advisory(pcx, 'table-function', "`table('connection_name:table_path')` is deprecated; use `connection_name.table('table_path')`");
         return el;
     }
     visitTableMethod(pcx) {
@@ -354,11 +352,11 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
                 if (join instanceof ast.ExpressionJoin) {
                     join.joinType = 'many';
                     if (join.joinOn === undefined) {
-                        this.contextError(pcx, 'join_many: requires ON expression');
+                        this.contextError(pcx, 'missing-on-in-join-many', 'join_many: requires ON expression');
                     }
                 }
                 else if (join instanceof ast.KeyJoin) {
-                    this.contextError(pcx, 'Foreign key join not legal in join_many:');
+                    this.contextError(pcx, 'foreign-key-in-join-many', 'Foreign key join not legal in join_many:');
                 }
             }
         }
@@ -391,7 +389,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
                     join.joinType = 'cross';
                 }
                 else {
-                    join.log('Foreign key join not legal in join_cross:');
+                    join.logError('foreign-key-in-join-cross', 'Foreign key join not legal in join_cross:');
                 }
             }
         }
@@ -419,7 +417,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     }
     visitQueryJoinStatement(pcx) {
         const result = this.astAt(this.visit(pcx.joinStatement()), pcx);
-        this.m4advisory(pcx, 'Joins in queries are deprecated, move into an `extend:` block.');
+        this.m4advisory(pcx, 'join-statement-in-view', 'Joins in queries are deprecated, move into an `extend:` block.');
         return result;
     }
     visitJoinOn(pcx) {
@@ -432,7 +430,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
             join.matrixOperation = mop;
         }
         else {
-            this.contextError(pcx, 'Internal Error: Unknown matrixOperation');
+            this.contextError(pcx, 'unknown-matrix-operation', 'Internal Error: Unknown matrixOperation');
         }
         if (onCx) {
             join.joinOn = this.getFieldExpr(onCx);
@@ -489,7 +487,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const defs = this.getFieldDefs(pcx.defList().fieldDef(), ast.DeclareFieldDeclaration);
         const stmt = new ast.DeclareFields(defs);
         const result = this.astAt(stmt, pcx);
-        this.m4advisory(pcx, '`declare:` is deprecated; use `dimension:` or `measure:` inside a source or `extend:` block');
+        this.m4advisory(pcx, 'declare', '`declare:` is deprecated; use `dimension:` or `measure:` inside a source or `extend:` block');
         return result;
     }
     visitExploreRenameDef(pcx) {
@@ -528,7 +526,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const blockNotes = this.getNotes(pcx.tags());
         queryDefs.extendNote({ blockNotes });
         if (pcx.QUERY()) {
-            this.m4advisory(pcx, 'Use view: inside of a source instead of query:');
+            this.m4advisory(pcx, 'query-in-source', 'Use view: inside of a source instead of query:');
         }
         return queryDefs;
     }
@@ -553,7 +551,9 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const timezone = this.getPlainStringFrom(cx);
         const timezoneStatement = this.astAt(new ast.TimezoneStatement(timezone), cx.string());
         if (!timezoneStatement.isValid) {
-            this.astError(timezoneStatement, `Invalid timezone: ${timezoneStatement.tz}`);
+            this.astError(timezoneStatement, 'invalid-timezone', {
+                timezone: timezoneStatement.tz,
+            });
         }
         return this.astAt(timezoneStatement, cx);
     }
@@ -623,7 +623,8 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
                     expr = new ast.ExprSum(undefined, ref);
                 }
                 else {
-                    this.contextError(agg, `\`${aggFunc}\` is not legal in a reference-only aggregation`);
+                    // TODO this error doesn't have any tests
+                    this.contextError(agg, 'invalid-reference-only-aggregation', `\`${aggFunc}\` is not legal in a reference-only aggregation`);
                     return ref;
                 }
             }
@@ -659,7 +660,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     }
     visitProjectStatement(pcx) {
         if (pcx.PROJECT()) {
-            this.m4advisory(pcx, 'project: keyword is deprecated, use select:');
+            this.m4advisory(pcx, 'project', 'project: keyword is deprecated, use select:');
         }
         const stmt = this.visitFieldCollection(pcx.fieldCollection());
         stmt.extendNote({ blockNotes: this.getNotes(pcx.tags()) });
@@ -746,7 +747,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const topN = this.getNumber(pcx.INTEGER_LITERAL());
         let top;
         if (byCx) {
-            this.m4advisory(byCx, 'by clause of top statement unupported. Use order_by instead');
+            this.m4advisory(byCx, 'top-by', 'by clause of top statement unupported. Use order_by instead');
             const nameCx = byCx.fieldName();
             if (nameCx) {
                 const name = this.getFieldName(nameCx);
@@ -789,7 +790,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const notes = this.getNotes(pcx.topLevelAnonQueryDef().tags());
         const blockNotes = this.getNotes(pcx.tags());
         theQuery.extendNote({ notes, blockNotes });
-        this.m4advisory(defCx, 'Anonymous `query:` statements are deprecated, use `run:` instead');
+        this.m4advisory(defCx, 'anonymous-query', 'Anonymous `query:` statements are deprecated, use `run:` instead');
         return this.astAt(theQuery, pcx);
     }
     visitRunStatement(pcx) {
@@ -819,7 +820,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         else {
             const implicitName = vExpr.getImplicitName();
             if (implicitName === undefined) {
-                this.contextError(pcx, '`nest:` view requires a name (add `nest_name is ...`)');
+                this.contextError(pcx, 'anonymous-nest', '`nest:` view requires a name (add `nest_name is ...`)');
             }
             name = implicitName !== null && implicitName !== void 0 ? implicitName : '__unnamed__';
         }
@@ -946,14 +947,14 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const exprDef = pcx.fieldExpr();
         if (pcx.aggregate().COUNT()) {
             if (exprDef) {
-                this.contextError(exprDef, 'Expression illegal inside path.count()');
+                this.contextError(exprDef, 'count-expression-with-locality', 'Expression illegal inside path.count()');
             }
             return new ast.ExprCount(source);
         }
         const expr = exprDef ? this.getFieldExpr(exprDef) : undefined;
         if (aggFunc === 'min' || aggFunc === 'max') {
             if (expr) {
-                this.contextError(pcx, this.symmetricAggregateUsageError(aggFunc));
+                this.contextError(pcx, 'invalid-symmetric-aggregate', this.symmetricAggregateUsageError(aggFunc));
             }
             else {
                 const idRef = this.astAt(new ast.ExprIdReference(path), pathCx);
@@ -969,7 +970,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
             return new ast.ExprSum(expr, source);
         }
         else {
-            this.contextError(pcx, `Cannot parse aggregate function ${aggFunc}`);
+            this.contextError(pcx, 'aggregate-parse-error', `Cannot parse aggregate function ${aggFunc}`);
         }
         return new ast.ExprNULL();
     }
@@ -992,7 +993,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const source = undefined;
         const aggFunc = pcx.aggregate().text.toLowerCase();
         if (pcx.STAR()) {
-            this.m4advisory(pcx, `* illegal inside ${aggFunc}()`);
+            this.m4advisory(pcx, 'wildcard-in-aggregate', `* illegal inside ${aggFunc}()`);
         }
         if (aggFunc === 'count') {
             return this.astAt(expr ? new ast.ExprCountDistinct(expr) : new ast.ExprCount(), pcx);
@@ -1002,7 +1003,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
                 return new ast.ExprMin(expr);
             }
             else {
-                this.contextError(pcx, this.symmetricAggregateUsageError(aggFunc));
+                this.contextError(pcx, 'invalid-symmetric-aggregate', this.symmetricAggregateUsageError(aggFunc));
             }
         }
         else if (aggFunc === 'max') {
@@ -1010,12 +1011,12 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
                 return new ast.ExprMax(expr);
             }
             else {
-                this.contextError(pcx, this.symmetricAggregateUsageError(aggFunc));
+                this.contextError(pcx, 'invalid-symmetric-aggregate', this.symmetricAggregateUsageError(aggFunc));
             }
         }
         else {
             if (expr === undefined) {
-                this.contextError(pcx, this.asymmetricAggregateUsageError(aggFunc));
+                this.contextError(pcx, 'invalid-asymmetric-aggregate', this.asymmetricAggregateUsageError(aggFunc));
                 return new ast.ExprNULL();
             }
             const explicitSource = pcx.SOURCE_KW() !== undefined;
@@ -1098,13 +1099,13 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
                 rawType = rawRawType;
             }
             else {
-                this.contextError(pcx, `'#' assertion for unknown type '${rawRawType}'`);
+                this.contextError(pcx, 'unexpected-malloy-type', `'#' assertion for unknown type '${rawRawType}'`);
                 rawType = undefined;
             }
         }
         let fn = (0, parse_utils_1.getOptionalId)(pcx) || ((_b = pcx.timeframe()) === null || _b === void 0 ? void 0 : _b.text);
         if (fn === undefined) {
-            this.contextError(pcx, 'Function name error');
+            this.contextError(pcx, 'failed-to-parse-function-name', 'Function name error');
             fn = 'FUNCTION_NAME_ERROR';
         }
         if (ast.ExprTimeExtract.extractor(fn)) {
@@ -1205,11 +1206,11 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         return tags;
     }
     visitIgnoredObjectAnnotations(pcx) {
-        this.contextError(pcx, 'Object annotation not connected to any object');
+        this.contextError(pcx, 'orphaned-object-annotation', 'Object annotation not connected to any object');
         return new IgnoredElement(pcx.text);
     }
     visitIgnoredModelAnnotations(pcx) {
-        this.contextError(pcx, 'Model annotations not allowed at this scope');
+        this.contextError(pcx, 'misplaced-model-annotation', 'Model annotations not allowed at this scope');
         return new IgnoredElement(pcx.text);
     }
     visitDefExploreAnnotation(pcx) {
@@ -1244,7 +1245,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         if (result instanceof ast.SourceQueryElement) {
             return result;
         }
-        this.contextError(cx, `Expected a source/query expression, not '${result.elementType}'`);
+        this.contextError(cx, 'unexpected-non-source-query-expression-node', `Expected a source/query expression, not '${result.elementType}'`);
         return new ErrorNode();
     }
     visitSQExtendedSource(pcx) {
@@ -1318,10 +1319,10 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const wholeRange = this.parseInfo.rangeFromContext(pcx);
         if (pcx.NOT()) {
             op = '!~';
-            this.warnWithReplacement("Use Malloy operator '!~' instead of 'NOT LIKE'", wholeRange, `${left.text} !~ ${right.text}`);
+            this.warnWithReplacement('sql-not-like', "Use Malloy operator '!~' instead of 'NOT LIKE'", wholeRange, `${left.text} !~ ${right.text}`);
         }
         else {
-            this.warnWithReplacement("Use Malloy operator '~' instead of 'LIKE'", wholeRange, `${left.text} ~ ${right.text}`);
+            this.warnWithReplacement('sql-like', "Use Malloy operator '~' instead of 'LIKE'", wholeRange, `${left.text} ~ ${right.text}`);
         }
         return this.astAt(new ast.ExprCompare(this.getFieldExpr(left), op, this.getFieldExpr(right)), pcx);
     }
@@ -1331,10 +1332,10 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const wholeRange = this.parseInfo.rangeFromContext(pcx);
         if (pcx.NOT()) {
             op = '!=';
-            this.warnWithReplacement("Use '!= NULL' to check for NULL instead of 'IS NOT NULL'", wholeRange, `${expr.text} != null`);
+            this.warnWithReplacement('sql-is-not-null', "Use '!= NULL' to check for NULL instead of 'IS NOT NULL'", wholeRange, `${expr.text} != null`);
         }
         else {
-            this.warnWithReplacement("Use '= NULL' to check for NULL instead of 'IS NULL'", wholeRange, `${expr.text} = null`);
+            this.warnWithReplacement('sql-is-null', "Use '= NULL' to check for NULL instead of 'IS NULL'", wholeRange, `${expr.text} = null`);
         }
         const nullExpr = new ast.ExprNULL();
         return this.astAt(new ast.ExprCompare(this.getFieldExpr(expr), op, nullExpr), pcx);