@malloydata/malloy 0.0.190 → 0.0.191-dev240925232958

package/dist/lang/ast/query-items/typecheck_utils.js

@@ -28,51 +28,59 @@ function typecheckProject(type, logTo) {
     if (type.dataType === 'turtle' || !(0, model_1.expressionIsScalar)(type.expressionType)) {
         let useInstead;
         let kind;
+        let code;
         if (type.dataType === 'turtle') {
             useInstead = 'a nest';
             kind = 'a view';
+            code = 'select-of-view';
         }
         else if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
             useInstead = 'a calculate';
             kind = 'an analytic';
+            code = 'select-of-analytic';
         }
         else if ((0, model_1.expressionIsAggregate)(type.expressionType)) {
             useInstead = 'an aggregate';
             kind = 'an aggregate';
+            code = 'select-of-aggregate';
         }
         else {
             throw new Error(`Unexpected expression type ${type.expressionType} not handled here`);
         }
-        logTo.log(`Cannot use ${kind} field in a select operation, did you mean to use ${useInstead} operation instead?`);
+        logTo.logError(code, `Cannot use ${kind} field in a select operation, did you mean to use ${useInstead} operation instead?`);
     }
 }
 exports.typecheckProject = typecheckProject;
 function typecheckIndex(type, logTo) {
     if (type.dataType === 'turtle' || !(0, model_1.expressionIsScalar)(type.expressionType)) {
         let kind;
+        let code;
         if (type.dataType === 'turtle') {
             kind = 'a view';
+            code = 'index-of-view';
         }
         else if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
             kind = 'an analytic';
+            code = 'index-of-analytic';
         }
         else if ((0, model_1.expressionIsAggregate)(type.expressionType)) {
             kind = 'an aggregate';
+            code = 'index-of-aggregate';
         }
         else {
             throw new Error(`Unexpected expression type ${type.expressionType} not handled here`);
         }
-        logTo.log(`Cannot use ${kind} field in an index operation`);
+        logTo.logError(code, `Cannot use ${kind} field in an index operation`);
     }
 }
 exports.typecheckIndex = typecheckIndex;
 function typecheckDimension(type, logTo) {
     if (!(0, model_1.expressionIsScalar)(type.expressionType)) {
         if ((0, model_1.expressionIsAggregate)(type.expressionType)) {
-            logTo.log('Cannot use an aggregate field in a dimension declaration, did you mean to use a measure declaration instead?');
+            logTo.logError('aggregate-in-dimension', 'Cannot use an aggregate field in a dimension declaration, did you mean to use a measure declaration instead?');
         }
         else if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
-            logTo.log('Cannot use an analytic field in a dimension declaration');
+            logTo.logError('analytic-in-dimension', 'Cannot use an analytic field in a dimension declaration');
         }
         else {
             throw new Error(`Unexpected expression type ${type.expressionType} not handled here`);
@@ -83,10 +91,10 @@ exports.typecheckDimension = typecheckDimension;
 function typecheckMeasure(type, logTo) {
     if (!(0, model_1.expressionIsAggregate)(type.expressionType)) {
         if ((0, model_1.expressionIsScalar)(type.expressionType)) {
-            logTo.log('Cannot use a scalar field in a measure declaration, did you mean to use a dimension declaration instead?');
+            logTo.logError('scalar-in-measure', 'Cannot use a scalar field in a measure declaration, did you mean to use a dimension declaration instead?');
         }
         else if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
-            logTo.log('Cannot use an analytic field in a measure declaration');
+            logTo.logError('analytic-in-measure', 'Cannot use an analytic field in a measure declaration');
         }
         else {
             throw new Error(`Unexpected expression type ${type.expressionType} not handled here`);
@@ -96,10 +104,10 @@ function typecheckMeasure(type, logTo) {
 exports.typecheckMeasure = typecheckMeasure;
 function typecheckDeclare(type, logTo) {
     if (type.dataType === 'turtle') {
-        logTo.log('Query fields cannot be used in a declare block');
+        logTo.logError('view-in-declare', 'Views cannot be used in a declare block');
     }
     else if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
-        logTo.log('Analytic expressions can not be used in a declare block');
+        logTo.logError('analytic-in-declare', 'Analytic expressions can not be used in a declare block');
     }
 }
 exports.typecheckDeclare = typecheckDeclare;
@@ -108,22 +116,26 @@ function typecheckCalculate(type, logTo) {
         !(0, model_1.expressionIsAnalytic)(type.expressionType)) {
         let useInstead;
         let kind;
+        let code;
         if (type.dataType === 'turtle') {
             useInstead = 'a nest';
             kind = 'a view';
+            code = 'calculate-of-view';
         }
         else if ((0, model_1.expressionIsAggregate)(type.expressionType)) {
             useInstead = 'an aggregate';
             kind = 'an aggregate';
+            code = 'calculate-of-aggregate';
         }
         else if ((0, model_1.expressionIsScalar)(type.expressionType)) {
             useInstead = 'a group_by or select';
             kind = 'a scalar';
+            code = 'calculate-of-scalar';
         }
         else {
             throw new Error(`Unexpected expression type ${type.expressionType} not handled here`);
         }
-        logTo.log(`Cannot use ${kind} field in a calculate operation, did you mean to use ${useInstead} operation instead?`);
+        logTo.logError(code, `Cannot use ${kind} field in a calculate operation, did you mean to use ${useInstead} operation instead?`);
     }
 }
 exports.typecheckCalculate = typecheckCalculate;
@@ -132,22 +144,26 @@ function typecheckAggregate(type, logTo) {
         !(0, model_1.expressionIsAggregate)(type.expressionType)) {
         let useInstead;
         let kind;
+        let code;
         if (type.dataType === 'turtle') {
             useInstead = 'a nest';
             kind = 'a view';
+            code = 'aggregate-of-view';
         }
         else if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
             useInstead = 'a calculate';
             kind = 'an analytic';
+            code = 'aggregate-of-analytic';
         }
         else if ((0, model_1.expressionIsScalar)(type.expressionType)) {
             useInstead = 'a group_by or select';
             kind = 'a scalar';
+            code = 'aggregate-of-scalar';
         }
         else {
             throw new Error(`Unexpected expression type ${type} not handled here`);
         }
-        logTo.log(`Cannot use ${kind} field in an aggregate operation, did you mean to use ${useInstead} operation instead?`);
+        logTo.logError(code, `Cannot use ${kind} field in an aggregate operation, did you mean to use ${useInstead} operation instead?`);
     }
 }
 exports.typecheckAggregate = typecheckAggregate;
@@ -155,22 +171,26 @@ function typecheckGroupBy(type, logTo) {
     if (type.dataType === 'turtle' || !(0, model_1.expressionIsScalar)(type.expressionType)) {
         let useInstead;
         let kind;
+        let code;
         if (type.dataType === 'turtle') {
             useInstead = 'a nest';
             kind = 'a view';
+            code = 'group-by-view';
         }
         else if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
             useInstead = 'a calculate';
             kind = 'an analytic';
+            code = 'group-by-analytic';
         }
         else if ((0, model_1.expressionIsAggregate)(type.expressionType)) {
             useInstead = 'an aggregate';
             kind = 'an aggregate';
+            code = 'group-by-aggregate';
         }
         else {
             throw new Error(`Unexpected expression type ${type.expressionType} not handled here`);
         }
-        logTo.log(`Cannot use ${kind} field in a group_by operation, did you mean to use ${useInstead} operation instead?`);
+        logTo.logError(code, `Cannot use ${kind} field in a group_by operation, did you mean to use ${useInstead} operation instead?`);
     }
 }
 exports.typecheckGroupBy = typecheckGroupBy;

package/dist/lang/ast/query-properties/filters.js

@@ -36,7 +36,7 @@ class FilterElement extends malloy_element_1.MalloyElement {
     filterCondition(fs) {
         const exprVal = this.expr.getExpression(fs);
         if (exprVal.dataType !== 'boolean') {
-            this.expr.log('Filter expression must have boolean value');
+            this.expr.logError('non-boolean-filter', 'Filter expression must have boolean value');
             return {
                 node: 'filterCondition',
                 code: this.exprSrc,
@@ -81,17 +81,17 @@ class Filter extends malloy_element_1.ListOf {
                 const isAnalytic = (0, malloy_types_1.expressionIsAnalytic)(fExpr.expressionType);
                 if (this.havingClause) {
                     if (isAnalytic) {
-                        oneElement.log('Analytic expressions are not allowed in `having:`');
+                        oneElement.logError('analytic-in-having', 'Analytic expressions are not allowed in `having:`');
                         continue;
                     }
                 }
                 else {
                     if (isAnalytic) {
-                        oneElement.log('Analytic expressions are not allowed in `where:`');
+                        oneElement.logError('analytic-in-where', 'Analytic expressions are not allowed in `where:`');
                         continue;
                     }
                     else if (isAggregate) {
-                        oneElement.log('Aggregate expressions are not allowed in `where:`; use `having:`');
+                        oneElement.logError('aggregate-in-where', 'Aggregate expressions are not allowed in `where:`; use `having:`');
                     }
                 }
             }

package/dist/lang/ast/query-properties/ordering.js

@@ -48,13 +48,13 @@ class OrderBy extends malloy_element_1.MalloyElement {
             const output = fs.outputSpace();
             const entry = this.field.getField(output);
             if (entry.error) {
-                this.field.log(entry.error);
+                this.field.logError(entry.error.code, entry.error.message);
             }
             if (!entry.found || !entry.isOutputField) {
-                this.log(`Unknown field ${this.field.refString} in output space`);
+                this.logError('order-by-not-found-in-output', `Unknown field ${this.field.refString} in output space`);
             }
             if ((0, malloy_types_1.expressionIsAnalytic)((_a = entry.found) === null || _a === void 0 ? void 0 : _a.typeDesc().expressionType)) {
-                this.log(`Illegal order by of analytic field ${this.field.refString}`);
+                this.logError('order-by-analytic', `Illegal order by of analytic field ${this.field.refString}`);
             }
         }
         const orderElement = { field: this.modelField };

package/dist/lang/ast/query-properties/qop-desc.js

@@ -55,7 +55,7 @@ class QOpDesc extends malloy_element_1.ListOf {
             if (el.forceQueryClass) {
                 if (guessType) {
                     if (guessType !== el.forceQueryClass) {
-                        el.log(`Not legal in ${guessType} query`);
+                        el.logError(`illegal-${guessType}-operation`, `Not legal in ${guessType} query`);
                     }
                 }
                 else {
@@ -65,7 +65,7 @@ class QOpDesc extends malloy_element_1.ListOf {
             needsExplicitQueryClass || (needsExplicitQueryClass = (_a = el.needsExplicitQueryClass) !== null && _a !== void 0 ? _a : false);
         }
         if (guessType === undefined && needsExplicitQueryClass) {
-            this.log("Can't determine view type (`group_by` / `aggregate` / `nest`, `project`, `index`)");
+            this.logError('ambiguous-view-type', {});
             guessType = query_property_interface_1.QueryClass.Project;
         }
         this.opClass = guessType;

package/dist/lang/ast/query-properties/top.js

@@ -47,13 +47,13 @@ class Top extends malloy_element_1.MalloyElement {
                     const output = fs.outputSpace();
                     const entry = this.by.getField(output);
                     if (entry.error) {
-                        this.by.log(entry.error);
+                        this.by.logError(entry.error.code, entry.error.message);
                     }
                     if (!entry.found || !entry.isOutputField) {
-                        this.by.log(`Unknown field ${this.by.refString} in output space`);
+                        this.by.logError('top-by-not-found-in-output', `Unknown field ${this.by.refString} in output space`);
                     }
                     if ((0, malloy_types_1.expressionIsAnalytic)((_a = entry.found) === null || _a === void 0 ? void 0 : _a.typeDesc().expressionType)) {
-                        this.by.log(`Illegal order by of analytic field ${this.by.refString}`);
+                        this.by.logError('top-by-analytic', `Illegal order by of analytic field ${this.by.refString}`);
                     }
                 }
                 return { by: 'name', name: this.by.refString };
@@ -61,10 +61,10 @@ class Top extends malloy_element_1.MalloyElement {
             else {
                 const byExpr = this.by.getExpression(fs);
                 if ((0, malloy_types_1.expressionIsAggregate)(byExpr.expressionType)) {
-                    this.by.log('top by expression must be an aggregate');
+                    this.by.logError('top-by-aggregate', 'top by expression must not be an aggregate');
                 }
                 if (byExpr.evalSpace === 'output') {
-                    this.by.log('top by expression must be an output expression');
+                    this.by.logError('top-by-not-in-output', 'top by expression must be an output expression');
                 }
                 return { by: 'expression', e: byExpr.value };
             }

package/dist/lang/ast/query-utils.js

@@ -39,7 +39,7 @@ function detectAndRemovePartialStages(pipeline, logTo) {
         }
     }
     if (hasPartials) {
-        logTo.log("Can't determine view type (`group_by` / `aggregate` / `nest`, `project`, `index`)");
+        logTo.logError('ambiguous-view-type', {});
     }
     return cleaned;
 }

package/dist/lang/ast/source-elements/named-source.d.ts

@@ -2,7 +2,7 @@ import { Argument, InvokedStructRef, StructDef } from '../../../model/malloy_typ
 import { Source } from './source';
 import { ModelEntryReference } from '../types/malloy-element';
 import { Argument as HasArgument } from '../parameters/argument';
-import { LogSeverity } from '../../parse-log';
+import { LogMessageOptions, MessageCode, MessageParameterType } from '../../parse-log';
 import { ParameterSpace } from '../field-space/parameter-space';
 import { HasParameter } from '../parameters/has-parameter';
 export declare class NamedSource extends Source {
@@ -13,7 +13,7 @@ export declare class NamedSource extends Source {
     constructor(ref: ModelEntryReference | string, sourceArguments: Record<string, Argument> | undefined, args: HasArgument[] | undefined);
     get refName(): string;
     structRef(parameterSpace: ParameterSpace | undefined): InvokedStructRef;
-    refLog(message: string, severity?: LogSeverity): void;
+    refLogError<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: Omit<LogMessageOptions, 'severity'>): void;
     modelStruct(): StructDef | undefined;
     private evaluateArgumentsForRef;
     private evaluateArguments;

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

@@ -61,12 +61,12 @@ class NamedSource extends source_1.Source {
             sourceArguments: this.evaluateArgumentsForRef(parameterSpace),
         };
     }
-    refLog(message, severity) {
+    refLogError(code, parameters, options) {
         if (typeof this.ref === 'string') {
-            this.log(message, severity);
+            this.logError(code, parameters, options);
         }
         else {
-            this.ref.log(message, severity);
+            this.ref.logError(code, parameters, options);
         }
     }
     modelStruct() {
@@ -74,24 +74,23 @@ class NamedSource extends source_1.Source {
         const modelEnt = this.modelEntry(this.ref);
         const entry = modelEnt === null || modelEnt === void 0 ? void 0 : modelEnt.entry;
         if (!entry) {
-            const undefMsg = `Undefined source '${this.refName}'`;
-            (this.ref instanceof malloy_element_1.ModelEntryReference ? this.ref : this).log(undefMsg);
+            this.refLogError('source-not-found', `Undefined source '${this.refName}'`);
             return;
         }
         if (entry.type === 'query') {
-            this.log(`Cannot construct a source from a query '${this.refName}'`);
+            this.logError('invalid-source-from-query', `Cannot construct a source from a query '${this.refName}'`);
             return;
         }
         else if (entry.type === 'function') {
-            this.log(`Cannot construct a source from a function '${this.refName}'`);
+            this.logError('invalid-source-from-function', `Cannot construct a source from a function '${this.refName}'`);
             return;
         }
         else if (entry.type === 'connection') {
-            this.log(`Cannot construct a source from a connection '${this.refName}'`);
+            this.logError('invalid-source-from-connection', `Cannot construct a source from a connection '${this.refName}'`);
             return;
         }
         else if ((0, malloy_types_1.isSQLBlockStruct)(entry) && entry.declaredSQLBlock) {
-            this.log(`Must use 'from_sql()' for sql source '${this.refName}'`);
+            this.logError('invalid-source-from-sql-block', `Must use 'from_sql()' for sql source '${this.refName}'`);
             return;
         }
         else {
@@ -115,18 +114,18 @@ class NamedSource extends source_1.Source {
                 ? argument.value.fieldReference
                 : undefined);
             if (id === undefined) {
-                argument.value.log('Parameterized source arguments must be named with `parameter_name is`');
+                argument.value.logError('unnamed-source-argument', 'Parameterized source arguments must be named with `parameter_name is`');
                 continue;
             }
             const name = id.outputName;
             if (passedNames.has(name)) {
-                argument.log(`Cannot pass argument for \`${name}\` more than once`);
+                argument.logError('duplicate-source-argument', `Cannot pass argument for \`${name}\` more than once`);
                 continue;
             }
             passedNames.add(name);
             const parameter = (parametersIn !== null && parametersIn !== void 0 ? parametersIn : {})[name];
             if (!parameter) {
-                id.log(`\`${this.refName}\` has no declared parameter named \`${id.refString}\``);
+                id.logError('source-parameter-not-found', `\`${this.refName}\` has no declared parameter named \`${id.refString}\``);
             }
             else {
                 const paramSpace = parameterSpace !== null && parameterSpace !== void 0 ? parameterSpace : new parameter_space_1.ParameterSpace(parametersOut !== null && parametersOut !== void 0 ? parametersOut : []);
@@ -147,7 +146,7 @@ class NamedSource extends source_1.Source {
                     outArguments[paramName] = { ...parametersIn[paramName] };
                 }
                 else {
-                    this.refLog(`Argument not provided for required parameter \`${paramName}\``);
+                    this.refLogError('missing-source-argument', `Argument not provided for required parameter \`${paramName}\``);
                 }
             }
         }

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

@@ -64,15 +64,17 @@ class RefinedSource extends source_1.Source {
             const errTo = el;
             if (el instanceof primary_key_1.PrimaryKey) {
                 if (primaryKey) {
-                    primaryKey.log('Primary key already defined');
-                    el.log('Primary key redefined');
+                    const code = 'multiple-primary-keys';
+                    primaryKey.logError(code, 'Primary key already defined');
+                    el.logError(code, 'Primary key redefined');
                 }
                 primaryKey = el;
             }
             else if (el instanceof field_list_edit_1.FieldListEdit) {
                 if (fieldListEdit) {
-                    fieldListEdit.log('Too many accept/except statements');
-                    el.log('Too many accept/except statements');
+                    const code = 'multiple-field-list-edits';
+                    fieldListEdit.logError(code, 'Too many accept/except statements');
+                    el.logError(code, 'Too many accept/except statements');
                 }
                 fieldListEdit = el;
             }
@@ -89,7 +91,7 @@ class RefinedSource extends source_1.Source {
                 newTimezone = el.tz;
             }
             else {
-                errTo.log(`Unexpected source property: '${errTo.elementType}'`);
+                errTo.logError('unexpected-source-property', `Unexpected source property: '${errTo.elementType}'`);
             }
         }
         const paramSpace = pList ? new parameter_space_1.ParameterSpace(pList) : undefined;
@@ -111,7 +113,7 @@ class RefinedSource extends source_1.Source {
         if (primaryKey) {
             const keyDef = primaryKey.field.getField(fs);
             if (keyDef.error) {
-                primaryKey.log(keyDef.error);
+                primaryKey.logError(keyDef.error.code, keyDef.error.message);
             }
         }
         const retStruct = fs.structDef();
@@ -121,7 +123,7 @@ class RefinedSource extends source_1.Source {
             for (const el of filter.list) {
                 const fc = el.filterCondition(fs);
                 if ((0, malloy_types_1.expressionIsCalculation)(fc.expressionType)) {
-                    el.log("Can't use aggregate computations in top level filters");
+                    el.logError('aggregate-in-source-filter', "Can't use aggregate computations in top level filters");
                 }
                 else {
                     filterList.push(fc);

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

@@ -55,7 +55,7 @@ class SQLSource extends source_1.Source {
             (_a = this.namespace()) === null || _a === void 0 ? void 0 : _a.setEntry(name, { entry: { type: 'connection', name }, exported: true }, true);
         }
         else if (connection.entry.type !== 'connection') {
-            this.connectionName.log(`${this.connectionName.refString} is not a connection`);
+            this.connectionName.logError('invalid-connection-for-sql-source', `${this.connectionName.refString} is not a connection`);
             this.connectionNameInvalid = true;
             return false;
         }
@@ -72,7 +72,7 @@ class SQLSource extends source_1.Source {
         const sql = this.sqlBlock();
         const sqlDefEntry = (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.root.sqlQueryZone;
         if (!sqlDefEntry) {
-            this.log("Cant't look up schema for sql block");
+            this.logError('failed-to-fetch-sql-source-schema', "Cant't look up schema for sql block");
             return;
         }
         sqlDefEntry.reference(sql.name, this.location);
@@ -94,7 +94,7 @@ class SQLSource extends source_1.Source {
         }
         const sqlDefEntry = (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.root.sqlQueryZone;
         if (!sqlDefEntry) {
-            this.log("Cant't look up schema for sql block");
+            this.logError('failed-to-fetch-sql-source-schema', "Cant't look up schema for sql block");
             return error_factory_1.ErrorFactory.structDef;
         }
         const sql = this.sqlBlock();
@@ -102,7 +102,7 @@ class SQLSource extends source_1.Source {
         const lookup = sqlDefEntry.getEntry(sql.name);
         if (lookup.status === 'error') {
             const msgLines = lookup.message.split(/\r?\n/);
-            this.select.log('Invalid SQL, ' + msgLines.join('\n    '));
+            this.select.logError('invalid-sql-source', 'Invalid SQL, ' + msgLines.join('\n    '));
             return error_factory_1.ErrorFactory.structDef;
         }
         else if (lookup.status === 'present') {
@@ -120,7 +120,7 @@ class SQLSource extends source_1.Source {
             return locStruct;
         }
         else {
-            this.log('`connection_name.sql(...)` can currently only be used in top level source/query definitions');
+            this.logError('non-top-level-sql-source', '`connection_name.sql(...)` can currently only be used in top level source/query definitions');
             return error_factory_1.ErrorFactory.structDef;
         }
     }

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

@@ -59,7 +59,7 @@ class TableSource extends source_1.Source {
                 msg = tableDefEntry.message;
             }
         }
-        this.log(msg);
+        this.logError('failed-to-fetch-table-schema', msg);
         return error_factory_1.ErrorFactory.structDef;
     }
 }
@@ -80,7 +80,7 @@ class TableMethodSource extends TableSource {
             (_a = this.namespace()) === null || _a === void 0 ? void 0 : _a.setEntry(name, { entry: { type: 'connection', name }, exported: true }, true);
         }
         else if (connection.entry.type !== 'connection') {
-            this.connectionName.log(`${this.connectionName.refString} is not a connection`);
+            this.connectionName.logError('invalid-connection-for-table-source', `${this.connectionName.refString} is not a connection`);
             return undefined;
         }
         return {

package/dist/lang/ast/source-properties/joins.js

@@ -42,7 +42,7 @@ class Join extends malloy_element_1.MalloyElement {
     getStructDefFromExpr(parameterSpace) {
         const source = this.sourceExpr.getSource();
         if (!source) {
-            this.sourceExpr.sqLog('Cannot great a source to join from');
+            this.sourceExpr.sqLog('invalid-join-source', 'Cannot create a source to join from');
             return error_factory_1.ErrorFactory.structDef;
         }
         return source.structDef(parameterSpace);
@@ -105,15 +105,15 @@ class KeyJoin extends Join {
                     return;
                 }
                 else {
-                    this.log(`join_one: with type mismatch with primary key: ${exprX.dataType}/${pkey.type}`);
+                    this.logError('join-on-primary-key-type-mismatch', `join_one: with type mismatch with primary key: ${exprX.dataType}/${pkey.type}`);
                 }
             }
             else {
-                this.log(`join_one: Primary key '${pkey}' not found in source`);
+                this.logError('join-primary-key-not-found', `join_one: Primary key '${pkey}' not found in source`);
             }
         }
         else {
-            this.log('join_one: Cannot use with unless source has a primary key');
+            this.logError('join-with-without-primary-key', 'join_one: Cannot use with unless source has a primary key');
         }
     }
 }
@@ -140,7 +140,7 @@ class ExpressionJoin extends Join {
         }
         const exprX = this.expr.getExpression(outer);
         if (exprX.dataType !== 'boolean') {
-            this.log('join conditions must be boolean expressions');
+            this.logError('non-boolean-join-on', 'join conditions must be boolean expressions');
             return;
         }
         const joinRel = inStruct.structRelationship;
@@ -152,7 +152,7 @@ class ExpressionJoin extends Join {
         var _a;
         const source = this.sourceExpr.getSource();
         if (!source) {
-            this.sourceExpr.sqLog('Cannot create a source to join from');
+            this.sourceExpr.sqLog('invalid-join-source', 'Cannot create a source to join from');
             return error_factory_1.ErrorFactory.structDef;
         }
         const sourceDef = source.structDef(parameterSpace);

package/dist/lang/ast/source-properties/renames.js

@@ -36,7 +36,7 @@ class RenameField extends malloy_element_1.MalloyElement {
     }
     makeEntry(fs) {
         if (this.oldName.refString === this.newName) {
-            this.log("Can't rename field to itself");
+            this.logError('invalid-rename-with-same-name', "Can't rename field to itself");
             return;
         }
         const oldValue = this.oldName.getField(fs);
@@ -45,11 +45,11 @@ class RenameField extends malloy_element_1.MalloyElement {
                 fs.renameEntry(this.oldName.refString, this.newName, new rename_space_field_1.RenameSpaceField(oldValue.found, this.newName, this.location));
             }
             else {
-                this.log(`'${this.oldName}' cannot be renamed`);
+                this.logError('failed-rename', `'${this.oldName}' cannot be renamed`);
             }
         }
         else {
-            this.log(`Can't rename '${this.oldName}', no such field`);
+            this.logError('rename-field-not-found', `Can't rename '${this.oldName}', no such field`);
         }
     }
 }

package/dist/lang/ast/source-query-elements/source-query-element.d.ts

@@ -1,6 +1,7 @@
 import { QueryElement } from '../types/query-element';
 import { MalloyElement } from '../types/malloy-element';
 import { Source } from '../source-elements/source';
+import { LogMessageOptions, MessageCode, MessageParameterType } from '../../parse-log';
 /**
  * An AST element which can be treated as either a source or a query
  * depending on context. For instance, an `SQReference` represents
@@ -12,6 +13,6 @@ export declare abstract class SourceQueryElement extends MalloyElement {
     getSource(): Source | undefined;
     getQuery(): QueryElement | undefined;
     isSource(): boolean;
-    sqLog(message: string): void;
+    sqLog<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: LogMessageOptions): T;
     isErrorFree(): boolean;
 }

package/dist/lang/ast/source-query-elements/source-query-element.js

@@ -44,11 +44,12 @@ class SourceQueryElement extends malloy_element_1.MalloyElement {
     isSource() {
         return false;
     }
-    sqLog(message) {
+    sqLog(code, parameters, options) {
         if (this.isErrorFree()) {
-            this.log(message);
+            this.logError(code, parameters, options);
         }
         this.errored = true;
+        return code;
     }
     isErrorFree() {
         if (this.errored) {

package/dist/lang/ast/source-query-elements/sq-arrow.js

@@ -48,7 +48,7 @@ class SQArrow extends source_query_element_1.SourceQueryElement {
             ? this.applyTo.getSource()
             : this.applyTo.getQuery();
         if (lhs === undefined) {
-            this.sqLog('Could not get LHS of arrow operation');
+            this.sqLog('failed-to-compute-arrow-source', 'Could not get LHS of arrow operation');
             return;
         }
         const arr = new query_arrow_1.QueryArrow(lhs, this.operation);
@@ -58,7 +58,7 @@ class SQArrow extends source_query_element_1.SourceQueryElement {
     getSource() {
         const query = this.getQuery();
         if (!query) {
-            this.sqLog("Couldn't comprehend query well enough to make a source");
+            this.sqLog('failed-to-compute-source-from-query', "Couldn't comprehend query well enough to make a source");
             return;
         }
         const asSource = new query_source_1.QuerySource(query);

package/dist/lang/ast/source-query-elements/sq-extend.js

@@ -49,7 +49,7 @@ class SQExtend extends source_query_element_1.SourceQueryElement {
             this.has({ asSource: this.asSource });
             return this.asSource;
         }
-        this.sqLog('Could not compute source to extend');
+        this.sqLog('failed-to-compute-source-to-extend', 'Could not compute source to extend');
     }
     isSource() {
         return true;