@malloydata/malloy 0.0.190 → 0.0.191-dev240925232958

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

@@ -51,11 +51,11 @@ class SQReference extends source_query_element_1.SourceQueryElement {
                 return query;
             }
             else {
-                this.sqLog(`Illegal reference to '${entry.as || entry.name}', query expected`);
+                this.sqLog(`cannot-use-${entry.type}-as-query`, `Illegal reference to '${entry.as || entry.name}', query expected`);
             }
         }
         else {
-            this.ref.log(`Reference to undefined object '${this.ref.refString}'`);
+            this.ref.logError('source-or-query-not-found', `Reference to undefined object '${this.ref.refString}'`);
             this.errored = true;
         }
         return;
@@ -70,13 +70,13 @@ class SQReference extends source_query_element_1.SourceQueryElement {
         }
         const entry = this.ref.getNamed();
         if (!entry) {
-            this.ref.log(`Reference to undefined object '${this.ref.refString}'`);
+            this.ref.logError('source-not-found', `Reference to undefined object '${this.ref.refString}'`);
             this.errored = true;
             return;
         }
         if (entry.type === 'query') {
             if (this.args !== undefined) {
-                this.ref.log('Arguments cannot be passed to queries');
+                this.ref.logError('illegal-query-argument', 'Arguments cannot be passed to queries');
             }
             const existingQuery = new query_reference_1.QueryReference(this.ref);
             this.asSource = new query_source_1.QuerySource(existingQuery);
@@ -85,7 +85,7 @@ class SQReference extends source_query_element_1.SourceQueryElement {
             this.asSource = new named_source_1.NamedSource(this.ref, undefined, this.args);
         }
         else {
-            this.sqLog(`Expected '${this.ref.refString}' to be of type query or source, not '${entry.type}'`);
+            this.sqLog(`cannot-use-${entry.type}-as-source`, `Expected '${this.ref.refString}' to be of type query or source, not '${entry.type}'`);
             return;
         }
         this.has({ asSource: this.asSource });

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

@@ -43,10 +43,10 @@ class SQRefine extends source_query_element_1.SourceQueryElement {
     getQuery() {
         if (this.toRefine.isSource()) {
             if (this.toRefine instanceof sq_reference_1.SQReference) {
-                this.sqLog(`Cannot add view refinements to '${this.toRefine.ref.refString}' because it is a source`);
+                this.sqLog('illegal-refinement-of-source', `Cannot add view refinements to '${this.toRefine.ref.refString}' because it is a source`);
             }
             else {
-                this.sqLog('Cannot add view refinements to a source');
+                this.sqLog('illegal-refinement-of-source', 'Cannot add view refinements to a source');
             }
             return;
         }

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

@@ -51,7 +51,7 @@ class SQSource extends source_query_element_1.SourceQueryElement {
             return rawQuery;
         }
         else {
-            this.sqLog('This source cannot be used as a query');
+            this.sqLog('invalid-source-as-query', 'This source cannot be used as a query');
         }
     }
 }

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

@@ -49,7 +49,7 @@ class SQLString extends malloy_element_1.MalloyElement {
             el.parent = this;
         }
         else {
-            el.log('This element is not legal inside an SQL string');
+            el.logError('invalid-sql-source-interpolation', 'This element is not legal inside an SQL string');
         }
     }
     sqlPhrases() {
@@ -64,7 +64,7 @@ class SQLString extends malloy_element_1.MalloyElement {
                     ret.push(queryObject.query());
                 }
                 else {
-                    el.sqLog('Cannot expand into a query');
+                    el.sqLog('failed-to-expand-sql-source', 'Cannot expand into a query');
                 }
             }
         }

package/dist/lang/ast/statements/define-query.js

@@ -37,12 +37,12 @@ class DefineQuery extends malloy_element_1.MalloyElement {
     execute(doc) {
         const existing = doc.getEntry(this.name);
         if (existing) {
-            this.log(`'${this.name}' is already defined, cannot redefine`);
+            this.logError('query-definition-name-conflict', `'${this.name}' is already defined, cannot redefine`);
             return;
         }
         const queryEl = this.queryExpr.getQuery();
         if (!queryEl) {
-            this.queryExpr.sqLog('Cannot define a query from this expression');
+            this.queryExpr.sqLog('query-definition-from-non-query', 'Cannot define a query from this expression');
             return;
         }
         const entry = {

package/dist/lang/ast/statements/define-source.js

@@ -46,7 +46,7 @@ class DefineSource extends malloy_element_1.MalloyElement {
     execute(doc) {
         var _a;
         if (doc.modelEntry(this.name)) {
-            this.log(`Cannot redefine '${this.name}'`);
+            this.logError('source-definition-name-conflict', `Cannot redefine '${this.name}'`);
         }
         else {
             const theSource = (_a = this.sourceExpr) === null || _a === void 0 ? void 0 : _a.getSource();
@@ -79,7 +79,7 @@ class DefineSource extends malloy_element_1.MalloyElement {
         const out = [];
         for (const parameter of this.parameters) {
             if (parameter.name in exists) {
-                parameter.log(`Cannot redefine parameter \`${parameter.name}\``);
+                parameter.logError('parameter-name-conflict', `Cannot redefine parameter \`${parameter.name}\``);
             }
             exists[parameter.name] = true;
             out.push(parameter);
@@ -89,7 +89,7 @@ class DefineSource extends malloy_element_1.MalloyElement {
     validateParameterShadowing(parameters, structDef) {
         for (const parameter of parameters) {
             if (structDef.fields.find(field => { var _a; return ((_a = field.as) !== null && _a !== void 0 ? _a : field.name) === parameter.name; })) {
-                parameter.log(`Illegal shadowing of field \`${parameter.name}\` by parameter with the same name`);
+                parameter.logError('parameter-shadowing-field', `Illegal shadowing of field \`${parameter.name}\` by parameter with the same name`);
             }
         }
     }

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

@@ -61,7 +61,7 @@ class ImportStatement extends malloy_element_1.ListOf {
             this.fullURL = decodeURI(new URL(url, baseURL).toString());
         }
         catch (e) {
-            this.log('Invalid URI in import statement');
+            this.logError('invalid-import-url', 'Invalid URL in import statement');
         }
     }
     needs() {
@@ -79,7 +79,7 @@ class ImportStatement extends malloy_element_1.ListOf {
     execute(doc) {
         const trans = this.translator();
         if (!trans) {
-            this.log('Cannot import without translation context');
+            this.logError('no-translator-for-import', 'Cannot import without translation context');
         }
         else if (this.fullURL) {
             const src = trans.root.importZone.getEntry(this.fullURL);
@@ -90,7 +90,7 @@ class ImportStatement extends malloy_element_1.ListOf {
                     for (const importOne of this.list) {
                         const fetchName = importOne.from || importOne;
                         if (doc.getEntry(importOne.text)) {
-                            importOne.log(`Cannot redefine '${importOne.text}'`);
+                            importOne.logError('name-conflict-on-selective-import', `Cannot redefine '${importOne.text}'`);
                         }
                         else if (importable[fetchName.text]) {
                             const importMe = { ...importable[fetchName.text] };
@@ -100,7 +100,7 @@ class ImportStatement extends malloy_element_1.ListOf {
                             doc.setEntry(importOne.text, { entry: importMe, exported: false });
                         }
                         else {
-                            fetchName.log(`Cannot find '${fetchName.text}', not imported`);
+                            fetchName.logError('selective-import-not-found', `Cannot find '${fetchName.text}', not imported`);
                         }
                     }
                 }
@@ -108,7 +108,7 @@ class ImportStatement extends malloy_element_1.ListOf {
                     // import everything
                     for (const [importing, entry] of Object.entries(trans.getChildExports(this.fullURL))) {
                         if (doc.getEntry(importing)) {
-                            this.log(`Cannot redefine '${importing}'`);
+                            this.logError('name-conflict-on-indiscriminate-import', `Cannot redefine '${importing}'`);
                         }
                         else {
                             doc.setEntry(importing, { entry, exported: false });
@@ -117,10 +117,10 @@ class ImportStatement extends malloy_element_1.ListOf {
                 }
             }
             else if (src.status === 'error') {
-                this.log(`import failed: '${src.message}'`);
+                this.logError('failed-import', `import failed: '${src.message}'`);
             }
             else {
-                this.log(`import failed with status: '${src.status}'`);
+                this.logError('failed-import', `import failed with status: '${src.status}'`);
             }
         }
     }

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

@@ -40,7 +40,7 @@ function opOutputStruct(logTo, inputStruct, opDesc) {
             return malloy_query_1.Segment.nextStructDef(inputStruct, opDesc);
         }
         catch (e) {
-            logTo.log(`INTERNAL ERROR model/Segment.nextStructDef: ${e.message}\n` +
+            logTo.logError('failed-to-compute-output-schema', `INTERNAL ERROR model/Segment.nextStructDef: ${e.message}\n` +
                 `QUERY: ${(0, util_1.inspect)(opDesc, { breakLength: 72, depth: Infinity })}`);
         }
     }

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

@@ -66,9 +66,14 @@ class ExpressionDef extends malloy_element_1.MalloyElement {
      */
     typeCheck(eNode, eVal) {
         if (eVal.dataType !== 'error' && !fragtype_utils_1.FT.in(eVal, this.legalChildTypes)) {
-            eNode.log(eVal.dataType === 'sql native'
-                ? `'${this.elementType}' Can't be used with unsupported SQL native type '${eVal.rawType}'[unsupported-sql-native-type-not-allowed-in-expression]`
-                : `'${this.elementType}' Can't use type ${fragtype_utils_1.FT.inspect(eVal)}`);
+            if (eVal.dataType === 'sql native') {
+                eNode.logError('sql-native-not-allowed-in-expression', {
+                    rawType: eVal.rawType,
+                });
+            }
+            else {
+                eNode.logError('expression-type-error', `'${this.elementType}' Can't use type ${fragtype_utils_1.FT.inspect(eVal)}`);
+            }
             return false;
         }
         return true;
@@ -114,7 +119,7 @@ class ExprDuration extends ExpressionDef {
         if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType) && (op === '+' || op === '-')) {
             const num = this.n.getExpression(fs);
             if (!fragtype_utils_1.FT.typeEq(num, fragtype_utils_1.FT.numberT)) {
-                this.log(`Duration units needs number not '${num.dataType}`);
+                this.logError('invalid-duration-quantity', `Duration quantity needs number not '${num.dataType}`);
                 return (0, ast_utils_1.errorFor)('illegal unit expression');
             }
             let resultGranularity;
@@ -142,8 +147,7 @@ class ExprDuration extends ExpressionDef {
                 }, resultGranularity);
             }
             else {
-                this.log(`Cannot offset date by ${this.timeframe}`);
-                return (0, ast_utils_1.errorFor)('ofsset date error');
+                return this.loggedErrorExpr('invalid-timeframe-for-time-offset', `Cannot offset date by ${this.timeframe}`);
             }
         }
         return super.apply(fs, op, left);
@@ -196,7 +200,7 @@ function timeCompare(left, lhs, op, rhs) {
     if ((leftIsTime || rightIsTime) &&
         lhs.dataType !== 'null' &&
         rhs.dataType !== 'null') {
-        left.log(`Cannot compare a ${lhs.dataType} to a ${rhs.dataType}`);
+        left.logError('time-comparison-type-mismatch', `Cannot compare a ${lhs.dataType} to a ${rhs.dataType}`);
         return { node: 'false' };
     }
     return undefined;
@@ -319,15 +323,14 @@ function numeric(fs, left, op, right) {
     if (err)
         return err;
     const noGo = unsupportError(left, lhs, right, rhs);
-    if (noGo) {
+    if (noGo)
         return noGo;
-    }
     const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
     if (lhs.dataType !== 'number') {
-        left.log(`The '${op}' operator requires a number, not a '${lhs.dataType}'`);
+        left.logError('arithmetic-operation-type-mismatch', `The '${op}' operator requires a number, not a '${lhs.dataType}'`);
     }
     else if (rhs.dataType !== 'number') {
-        right.log(`The '${op}' operator requires a number, not a '${rhs.dataType}'`);
+        right.logError('arithmetic-operation-type-mismatch', `The '${op}' operator requires a number, not a '${rhs.dataType}'`);
     }
     else {
         return {
@@ -360,8 +363,7 @@ function delta(fs, left, op, right) {
                 duration = new ExprDuration(right, 'day');
             }
             else {
-                left.log(`Can not offset time by '${rhs.dataType}'`);
-                return (0, ast_utils_1.errorFor)(`time plus ${rhs.dataType}`);
+                return left.loggedErrorExpr('time-offset-type-mismatch', `Can not offset time by '${rhs.dataType}'`);
             }
         }
         return duration.apply(fs, op, left);
@@ -396,18 +398,16 @@ function applyBinary(fs, left, op, right) {
         const num = left.getExpression(fs);
         const denom = right.getExpression(fs);
         const noGo = unsupportError(left, num, right, denom);
-        if (noGo) {
-            left.log(`Cannot use '${op}' with sql native type`);
+        if (noGo)
             return noGo;
-        }
         const err = errorCascade('number', num, denom);
         if (err)
             return err;
         if (num.dataType !== 'number') {
-            left.log('Numerator must be a number');
+            left.logError('arithmetic-operation-type-mismatch', 'Numerator must be a number');
         }
         else if (denom.dataType !== 'number') {
-            right.log('Denominator must be a number');
+            right.logError('arithmetic-operation-type-mismatch', 'Denominator must be a number');
         }
         else {
             const divmod = {
@@ -423,8 +423,7 @@ function applyBinary(fs, left, op, right) {
         }
         return (0, ast_utils_1.errorFor)('divide type mismatch');
     }
-    left.log(`Cannot use ${op} operator here`);
-    return (0, ast_utils_1.errorFor)('applybinary bad operator');
+    return left.loggedErrorExpr('unexpected-binary-operator', `Cannot use ${op} operator here`);
 }
 exports.applyBinary = applyBinary;
 function errorCascade(dataType, ...es) {
@@ -448,12 +447,12 @@ function unsupportError(l, lhs, r, rhs) {
         evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, rhs.evalSpace),
     };
     if (lhs.dataType === 'sql native') {
-        l.log(`Unsupported SQL native type '${lhs.rawType}' not allowed in expression[unsupported-sql-native-type-not-allowed-in-expression]`);
+        l.logError('sql-native-not-allowed-in-expression', { rawType: lhs.rawType });
         ret.dataType = rhs.dataType;
         return ret;
     }
     if (rhs.dataType === 'sql native') {
-        r.log(`Unsupported SQL native type '${rhs.rawType}' not allowed in expression[unsupported-sql-native-type-not-allowed-in-expression]`);
+        r.logError('sql-native-not-allowed-in-expression', { rawType: rhs.rawType });
         return ret;
     }
     return undefined;

package/dist/lang/ast/types/lookup-result.d.ts

@@ -1,4 +1,5 @@
 import { StructRelationship } from '../../../model';
+import { MessageCode } from '../../parse-log';
 import { SpaceEntry } from './space-entry';
 export interface LookupFound {
     found: SpaceEntry;
@@ -10,7 +11,10 @@ export interface LookupFound {
     isOutputField: boolean;
 }
 export interface LookupError {
-    error: string;
+    error: {
+        message: string;
+        code: MessageCode;
+    };
     found: undefined;
 }
 export type LookupResult = LookupFound | LookupError;

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

@@ -1,9 +1,10 @@
 import { Annotation, DocumentLocation, DocumentReference, ModelDef, ModelAnnotation, NamedModelObject, Query, SQLBlockStructDef, StructDef } from '../../../model/malloy_types';
 import { Tag } from '../../../tags';
-import { LogSeverity, MessageLogger } from '../../parse-log';
+import { LogMessageOptions, MessageLogger, MessageParameterType, MessageCode } from '../../parse-log';
 import { MalloyTranslation } from '../../parse-malloy';
 import { ModelDataRequest } from '../../translate-response';
 import { DocumentCompileResult } from './document-compile-result';
+import { ExprValue } from './expr-value';
 import { ModelEntry } from './model-entry';
 import { NameSpace } from './name-space';
 import { Noteable, extendNoteMethod } from './noteable';
@@ -38,10 +39,12 @@ export declare abstract class MalloyElement {
     setTranslator(x: MalloyTranslation): void;
     addReference(reference: DocumentReference): void;
     private get sourceURL();
-    errorsExist(): boolean;
     private readonly logged;
-    log(message: string, severity?: LogSeverity): void;
-    logger(): MessageLogger | undefined;
+    private log;
+    logError<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: Omit<LogMessageOptions, 'severity'>): T;
+    logWarning<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: Omit<LogMessageOptions, 'severity'>): T;
+    loggedErrorExpr<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: LogMessageOptions): ExprValue;
+    get logger(): MessageLogger;
     /**
      * Mostly for debugging / testing. A string-y version of this object which
      * is used to ask "are these two AST segments equal". Formatted so that
@@ -54,7 +57,7 @@ export declare abstract class MalloyElement {
     private varInfo;
     protected internalError(msg: string): Error;
     needs(doc: Document): ModelDataRequest | undefined;
-    inExperiment(experimentID: string, silent?: boolean): boolean;
+    inExperiment(experimentId: string, silent?: boolean): boolean;
 }
 export declare class Unimplemented extends MalloyElement {
     elementType: string;

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

@@ -26,6 +26,8 @@ exports.Document = exports.DocStatementList = exports.ListOf = exports.isDocStat
 const dialect_1 = require("../../../dialect");
 const malloy_types_1 = require("../../../model/malloy_types");
 const tags_1 = require("../../../tags");
+const parse_log_1 = require("../../parse-log");
+const ast_utils_1 = require("../ast-utils");
 const dialect_name_space_1 = require("./dialect-name-space");
 const global_name_space_1 = require("./global-name-space");
 const noteable_1 = require("./noteable");
@@ -166,35 +168,40 @@ class MalloyElement {
         const trans = this.translator();
         return (trans === null || trans === void 0 ? void 0 : trans.sourceURL) || '(missing)';
     }
-    errorsExist() {
-        const logger = this.logger();
-        if (logger) {
-            return logger.hasErrors();
-        }
-        return false;
-    }
-    log(message, severity = 'error') {
+    log(code, parameters, options) {
+        const log = (0, parse_log_1.makeLogMessage)(code, parameters, {
+            at: this.location,
+            ...options,
+        });
         if (this.codeLocation) {
             /*
              * If this element has a location, then don't report the same
              * error message at the same location more than once
              */
-            if (this.logged.has(message)) {
-                return;
+            if (this.logged.has(log.message)) {
+                return code;
             }
-            this.logged.add(message);
-        }
-        const msg = { at: this.location, message, severity };
-        const logTo = this.logger();
-        if (logTo) {
-            logTo.log(msg);
-            return;
+            this.logged.add(log.message);
         }
-        throw new Error(`Translation error (without error reporter):\n${JSON.stringify(msg, null, 2)}`);
+        this.logger.log(log);
+        return code;
     }
-    logger() {
+    logError(code, parameters, options) {
+        return this.log(code, parameters, { severity: 'error', ...options });
+    }
+    logWarning(code, parameters, options) {
+        return this.log(code, parameters, { severity: 'warn', ...options });
+    }
+    loggedErrorExpr(code, parameters, options) {
+        return (0, ast_utils_1.errorFor)(this.logError(code, parameters, options));
+    }
+    get logger() {
         var _a;
-        return (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.root.logger;
+        const logger = (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.root.logger;
+        if (logger === undefined) {
+            throw new Error('Attempted to access logger without a translator');
+        }
+        return logger;
     }
     /**
      * Mostly for debugging / testing. A string-y version of this object which
@@ -254,8 +261,7 @@ class MalloyElement {
         return extra;
     }
     internalError(msg) {
-        this.log(`INTERNAL ERROR IN TRANSLATION: ${msg}`);
-        return new Error(msg);
+        return new Error(`INTERNAL ERROR IN TRANSLATION: ${msg}`);
     }
     needs(doc) {
         for (const child of this.walk()) {
@@ -264,15 +270,15 @@ class MalloyElement {
                 return childNeeds;
         }
     }
-    inExperiment(experimentID, silent = false) {
+    inExperiment(experimentId, silent = false) {
         var _a;
         const experimental = (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.compilerFlags.tag('experimental');
-        const enabled = experimental && (experimental.bare() || experimental.has(experimentID));
+        const enabled = experimental && (experimental.bare() || experimental.has(experimentId));
         if (enabled) {
             return true;
         }
         if (!silent) {
-            this.log(`Experimental flag '${experimentID}' is not set, feature not available`);
+            this.logError('experiment-not-enabled', { experimentId });
         }
         return false;
     }
@@ -551,7 +557,7 @@ class Document extends MalloyElement {
     setEntry(str, ent) {
         // TODO this error message is going to be in the wrong place everywhere...
         if (this.globalNameSpace.getEntry(str) !== undefined) {
-            this.log(`Cannot redefine '${str}', which is in global namespace`);
+            this.logError('name-conflict-with-global', `Cannot redefine '${str}', which is in global namespace`);
         }
         if (ent.entry.type === 'struct') {
             this.checkExperimentalDialect(this, ent.entry.dialect);
@@ -570,7 +576,7 @@ class Document extends MalloyElement {
             t.firstReferenceToDialect(dialect) &&
             (0, dialect_1.getDialect)(dialect).experimental &&
             !t.experimentalDialectEnabled(dialect)) {
-            me.log(`Requires compiler flag '##! experimental.dialect.${dialect}'`, 'error');
+            me.logError('experimental-dialect-not-enabled', { dialect });
         }
     }
     getDialectNamespace(dialectName) {

package/dist/lang/ast/view-elements/qop-desc-view.js

@@ -49,7 +49,7 @@ class QOpDescView extends view_1.View {
     }
     getOp(inputFS, isNestIn, qOpDesc, refineThis) {
         if ((0, malloy_types_1.isRawSegment)(refineThis)) {
-            this.log('A raw query cannot be refined');
+            this.logError('refinement-of-raw-query', 'A raw query cannot be refined');
             return refineThis;
         }
         qOpDesc.refineFrom(refineThis);
@@ -72,13 +72,13 @@ class QOpDescView extends view_1.View {
                     headRefinements.push(qop);
                     break;
                 case query_property_interface_1.LegalRefinementStage.Single:
-                    qop.log('Illegal in refinement of a query with more than one stage');
+                    qop.logError('illegal-multistage-refinement-operation', 'Illegal in refinement of a query with more than one stage');
                     break;
                 case query_property_interface_1.LegalRefinementStage.Tail:
                     tailRefinements.push(qop);
                     break;
                 default:
-                    qop.log('Illegal query refinement');
+                    qop.logError('illegal-refinement-operation', 'Illegal query refinement');
             }
         }
         if (headRefinements.notEmpty()) {

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

@@ -60,7 +60,7 @@ class ReferenceView extends view_1.View {
             };
         };
         if (!lookup.found) {
-            this.log(`\`${this.reference.refString}\` is not defined`);
+            this.logError('view-not-found', `\`${this.reference.refString}\` is not defined`);
             return oops();
         }
         if (!(lookup.found instanceof space_field_1.SpaceField)) {
@@ -95,10 +95,10 @@ class ReferenceView extends view_1.View {
         else if ((0, malloy_types_1.isTurtleDef)(fieldDef)) {
             if (this.reference.list.length > 1) {
                 if (forRefinement) {
-                    this.log('Cannot use view from join as refinement');
+                    this.logError('refinement-with-joined-view', 'Cannot use view from join as refinement');
                 }
                 else {
-                    this.log('Cannot use view from join');
+                    this.logError('nest-of-joined-view', 'Cannot use view from join');
                 }
                 return oops();
             }
@@ -111,10 +111,10 @@ class ReferenceView extends view_1.View {
         }
         else {
             if (forRefinement) {
-                this.reference.log(`named refinement \`${this.reference.refString}\` must be a view, found a ${fieldDef.type}`);
+                this.reference.logError('refinement-with-source', `named refinement \`${this.reference.refString}\` must be a view, found a ${fieldDef.type}`);
             }
             else {
-                this.reference.log('This operation is not supported');
+                this.reference.logError('nest-of-source', 'This operation is not supported');
             }
             return oops();
         }
@@ -126,7 +126,7 @@ class ReferenceView extends view_1.View {
         if (error)
             return;
         if (pipeline.length !== 1) {
-            this.reference.log(`named refinement \`${this.reference.refString}\` must have exactly one stage`);
+            this.reference.logError('refinement-with-multistage-view', `named refinement \`${this.reference.refString}\` must have exactly one stage`);
             return;
         }
         return pipeline[0];

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

@@ -29,14 +29,14 @@ function refine(logTo, refineTo, refineFrom) {
     var _a, _b;
     // TODO we should probably support this
     if (refineTo.length !== 1) {
-        logTo.log('Named refinements of multi-stage views are not supported');
+        logTo.logError('refinement-with-multistage-view', 'Named refinements of multi-stage views are not supported');
         // TODO better error pipeline?
         return refineTo;
     }
     const to = { ...refineTo[0] };
     const from = refineFrom;
     if ((0, model_1.isRawSegment)(to)) {
-        logTo.log('Cannot refine raw query, must add an explicit query stage');
+        logTo.logError('refinement-of-raw-query', 'Cannot refine raw query, must add an explicit query stage');
     }
     else {
         // TODO need to disallow partial + index for now to make the types happy
@@ -44,7 +44,7 @@ function refine(logTo, refineTo, refineFrom) {
             to.type = from.type;
         }
         else if (from.type !== to.type) {
-            logTo.log(`cannot refine ${to.type} view with ${from.type} view`);
+            logTo.logError('mismatched-view-types-for-refinement', `cannot refine ${to.type} view with ${from.type} view`);
         }
         if (from.type !== 'index' && to.type !== 'index' && from.type !== 'raw') {
             if (from.orderBy !== undefined || from.by !== undefined) {
@@ -57,7 +57,7 @@ function refine(logTo, refineTo, refineFrom) {
                     }
                 }
                 else {
-                    logTo.log('refinement cannot override existing ordering');
+                    logTo.logError('ordering-overridden-in-refinement', 'refinement cannot override existing ordering');
                 }
             }
             if (from.limit !== undefined) {
@@ -65,7 +65,7 @@ function refine(logTo, refineTo, refineFrom) {
                     to.limit = from.limit;
                 }
                 else {
-                    logTo.log('refinement cannot override existing limit');
+                    logTo.logError('limit-overridden-in-refinement', 'refinement cannot override existing limit');
                 }
             }
         }
@@ -90,7 +90,7 @@ function refine(logTo, refineTo, refineFrom) {
             }
             to.queryFields = [...to.queryFields, ...nonOverlappingFields];
             if (overlappingFields.length > 0) {
-                logTo.log(`overlapping fields in refinement: ${overlappingFields.map(field_utils_1.nameFromDef)}`);
+                logTo.logError('name-conflict-in-refinement', `overlapping fields in refinement: ${overlappingFields.map(field_utils_1.nameFromDef)}`);
             }
         }
         else if (from.type === 'index' && to.type === 'index') {

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

@@ -48,7 +48,7 @@ class ViewArrow extends view_1.View {
         };
     }
     refine(_inputFS, _pipeline, _isNestIn) {
-        this.log('A multi-segment view cannot be used as a refinement');
+        this.logError('refinement-with-multistage-view', 'A multi-segment view cannot be used as a refinement');
         return [];
     }
     getImplicitName() {

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

@@ -54,7 +54,7 @@ class ViewRefine extends view_1.View {
     refine(inputFS, pipeline, isNestIn) {
         const refineFrom = this.pipeline(inputFS, isNestIn);
         if (refineFrom.length !== 1) {
-            this.refinement.log('refinement must have exactly one stage');
+            this.refinement.logError('refinement-with-multistage-view', 'refinement must have exactly one stage');
             // TODO better error pipeline?
             return pipeline;
         }