@malloydata/malloy 0.0.191-dev240925183459 → 0.0.191-dev240927163326

package/dist/lang/ast/expressions/constant-expression.js

@@ -36,7 +36,10 @@ class ConstantFieldSpace {
     }
     lookup(_name) {
         return {
-            error: 'Only constants allowed in parameter default values',
+            error: {
+                message: 'Only constants allowed in parameter default values',
+                code: 'illegal-reference-in-parameter-default',
+            },
             found: undefined,
         };
     }

package/dist/lang/ast/expressions/expr-aggregate-function.js

@@ -49,7 +49,7 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
         return 'number';
     }
     getExpression(fs) {
-        var _a, _b;
+        var _a, _b, _c;
         // It is never useful to use output fields in an aggregate expression
         // so we don't even allow them to be referenced at all
         const inputFS = fs.isQueryFieldSpace() ? fs.inputSpace() : fs;
@@ -88,23 +88,19 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                 }
                 else {
                     if (!(sourceFoot instanceof struct_space_field_base_1.StructSpaceFieldBase)) {
-                        this.log(`Aggregate source cannot be a ${footType.dataType}`);
-                        return (0, ast_utils_1.errorFor)(`Aggregate source cannot be a ${footType.dataType}`);
+                        return this.loggedErrorExpr('invalid-aggregate-source', `Aggregate source cannot be a ${footType.dataType}`);
                     }
                 }
             }
             else {
-                this.log(`Reference to undefined value ${this.source.refString}`);
-                return (0, ast_utils_1.errorFor)(`Reference to undefined value ${this.source.refString}`);
+                return this.loggedErrorExpr('aggregate-source-not-found', `Reference to undefined value ${this.source.refString}`);
             }
         }
         if (exprVal === undefined) {
-            this.log('Missing expression for aggregate function');
-            return (0, ast_utils_1.errorFor)('agggregate without expression');
+            return this.loggedErrorExpr('missing-aggregate-expression', 'Missing expression for aggregate function');
         }
         if ((0, malloy_types_1.expressionIsAggregate)(exprVal.expressionType)) {
-            this.log('Aggregate expression cannot be aggregate');
-            return (0, ast_utils_1.errorFor)('reagggregate');
+            return this.loggedErrorExpr('aggregate-of-aggregate', 'Aggregate expression cannot be aggregate');
         }
         const isAnError = exprVal.dataType === 'error';
         if (!isAnError) {
@@ -118,11 +114,17 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                     const usagePaths = getJoinUsagePaths(sourceRelationship, joinUsage);
                     const joinError = validateUsagePaths(this.elementType, usagePaths);
                     const message = sourceSpecified
-                        ? joinError
+                        ? joinError === null || joinError === void 0 ? void 0 : joinError.message
                         : 'Join path is required for this calculation';
                     if (message) {
                         const errorWithSuggestion = suggestNewVersion(message, joinUsage, expr, this.elementType);
-                        this.log(errorWithSuggestion, joinError ? 'error' : 'warn');
+                        const code = (_c = joinError === null || joinError === void 0 ? void 0 : joinError.code) !== null && _c !== void 0 ? _c : 'bad-join-usage';
+                        if (joinError) {
+                            this.logError(code, errorWithSuggestion);
+                        }
+                        else {
+                            this.logWarning(code, errorWithSuggestion);
+                        }
                     }
                 }
             }
@@ -269,13 +271,22 @@ function validateUsagePaths(functionName, usagePaths) {
     for (const path of usagePaths) {
         for (const step of path) {
             if (step.structRelationship.type === 'cross') {
-                return `Cannot compute \`${functionName}\` across \`join_cross\` relationship \`${step.name}\``;
+                return {
+                    code: 'aggregate-traverses-join-cross',
+                    message: `Cannot compute \`${functionName}\` across \`join_cross\` relationship \`${step.name}\``,
+                };
             }
             else if (step.structRelationship.type === 'many' && !step.reverse) {
-                return `Cannot compute \`${functionName}\` across \`join_many\` relationship \`${step.name}\``;
+                return {
+                    code: 'aggregate-traverses-join-many',
+                    message: `Cannot compute \`${functionName}\` across \`join_many\` relationship \`${step.name}\``,
+                };
             }
             else if (step.structRelationship.type === 'nested' && !step.reverse) {
-                return `Cannot compute \`${functionName}\` across repeated relationship \`${step.name}\``;
+                return {
+                    code: 'aggregate-traverses-repeated-relationship',
+                    message: `Cannot compute \`${functionName}\` across repeated relationship \`${step.name}\``,
+                };
             }
         }
     }

package/dist/lang/ast/expressions/expr-alternation-tree.js

@@ -24,7 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprAlternationTree = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
-const ast_utils_1 = require("../ast-utils");
 const expression_def_1 = require("../types/expression-def");
 class ExprAlternationTree extends expression_def_1.ExpressionDef {
     constructor(left, op, right) {
@@ -52,8 +51,7 @@ class ExprAlternationTree extends expression_def_1.ExpressionDef {
         return undefined;
     }
     getExpression(_fs) {
-        this.log('Alternation tree has no value');
-        return (0, ast_utils_1.errorFor)('no value from alternation tree');
+        return this.loggedErrorExpr('alternation-as-value', 'Alternation tree has no value');
     }
 }
 exports.ExprAlternationTree = ExprAlternationTree;

package/dist/lang/ast/expressions/expr-cast.js

@@ -50,7 +50,7 @@ class ExprCast extends expression_def_1.ExpressionDef {
                         (_c = (_b = (_a = fs.dialectObj()) === null || _a === void 0 ? void 0 : _a.sqlTypeToMalloyType(this.castType.raw)) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : 'sql native';
                 }
                 else {
-                    this.log(`Cast type \`${this.castType.raw}\` is invalid for ${dialect.name} dialect`);
+                    this.logError('invalid-sql-native-type', `Cast type \`${this.castType.raw}\` is invalid for ${dialect.name} dialect`);
                 }
             }
         }

package/dist/lang/ast/expressions/expr-coalesce.js

@@ -49,7 +49,7 @@ class ExprCoalesce extends expression_def_1.ExpressionDef {
          * trees" rewrite happens.
          */
         if (!fragtype_utils_1.FT.typeEq(maybeNull, whenNull)) {
-            this.log(`Mismatched types for coalesce (${maybeNull.dataType}, ${whenNull.dataType})`);
+            this.logError('mismatched-coalesce-types', `Mismatched types for coalesce (${maybeNull.dataType}, ${whenNull.dataType})`);
         }
         return {
             ...whenNull,

package/dist/lang/ast/expressions/expr-func.js

@@ -62,15 +62,15 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             : undefined;
         const func = dialectFunc !== null && dialectFunc !== void 0 ? dialectFunc : (_c = this.modelEntry(normalizedName)) === null || _c === void 0 ? void 0 : _c.entry;
         if (func === undefined) {
-            this.log(`Unknown function '${this.name}'. Use '${this.name}!(...)' to call a SQL function directly.`);
+            this.logError('function-not-found', `Unknown function '${this.name}'. Use '${this.name}!(...)' to call a SQL function directly.`);
             return { found: undefined, error: 'unknown function' };
         }
         else if (func.type !== 'function') {
-            this.log(`Cannot call '${this.name}', which is of type ${func.type}`);
+            this.logError(`${func.type}-not-callable`, `Cannot call '${this.name}', which is of type ${func.type}`);
             return { found: undefined, error: 'called non function' };
         }
         if (func.name !== this.name) {
-            this.log(`Case insensitivity for function names is deprecated, use '${func.name}' instead`, 'warn');
+            this.logWarning('case-insensitive-function', `Case insensitivity for function names is deprecated, use '${func.name}' instead`);
         }
         return { found: func, error: undefined };
     }
@@ -124,16 +124,12 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                 }
                 else {
                     if (!(sourceFoot instanceof struct_space_field_base_1.StructSpaceFieldBase)) {
-                        const message = `Aggregate source cannot be a ${footType.dataType}`;
-                        this.log(message);
-                        return (0, ast_utils_1.errorFor)(message);
+                        return this.loggedErrorExpr('invalid-aggregate-source', `Aggregate source cannot be a ${footType.dataType}`);
                     }
                 }
             }
             else {
-                const message = `Reference to undefined value ${this.source.refString}`;
-                this.log(message);
-                return (0, ast_utils_1.errorFor)(message);
+                this.loggedErrorExpr('aggregate-source-not-found', `Reference to undefined value ${this.source.refString}`);
             }
         }
         // Construct the full args list including the implicit arg.
@@ -143,10 +139,9 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         ];
         const result = findOverload(func, argExprs);
         if (result === undefined) {
-            this.log(`No matching overload for function ${this.name}(${argExprs
+            return this.loggedErrorExpr('no-matching-function-overload', `No matching overload for function ${this.name}(${argExprs
                 .map(e => e.dataType)
                 .join(', ')})`);
-            return (0, ast_utils_1.errorFor)('no matching overload');
         }
         const { overload, expressionTypeErrors, evalSpaceErrors, nullabilityErrors } = result;
         // Report errors for expression type mismatch
@@ -156,7 +151,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                 ? 'scalar'
                 : 'scalar or aggregate';
             const arg = this.args[adjustedIndex];
-            arg.log(`Parameter ${error.argIndex + 1} ('${error.param.name}') of ${this.name} must be ${allowed}, but received ${error.actualExpressionType}`);
+            arg.logError('invalid-function-argument-expression-type', `Parameter ${error.argIndex + 1} ('${error.param.name}') of ${this.name} must be ${allowed}, but received ${error.actualExpressionType}`);
         }
         // Report errors for eval space mismatch
         for (const error of evalSpaceErrors) {
@@ -167,13 +162,13 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                     ? 'literal or constant'
                     : 'literal, constant or output';
             const arg = this.args[adjustedIndex];
-            arg.log(`Parameter ${error.argIndex + 1} ('${error.param.name}') of ${this.name} must be ${allowed}, but received ${error.actualEvalSpace}`);
+            arg.logError('invalid-function-argument-evaluation-space', `Parameter ${error.argIndex + 1} ('${error.param.name}') of ${this.name} must be ${allowed}, but received ${error.actualEvalSpace}`);
         }
         // Report nullability errors
         for (const error of nullabilityErrors) {
             const adjustedIndex = error.argIndex - (implicitExpr ? 1 : 0);
             const arg = this.args[adjustedIndex];
-            arg.log(`Parameter ${error.argIndex + 1} ('${error.param.name}') of ${this.name} must not be a literal null`);
+            arg.logError('literal-null-function-argument', `Parameter ${error.argIndex + 1} ('${error.param.name}') of ${this.name} must not be a literal null`);
         }
         const type = overload.returnType;
         const expressionType = (0, malloy_types_1.maxOfExpressionTypes)([
@@ -182,10 +177,9 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         ]);
         if (!(0, malloy_types_1.expressionIsAggregate)(overload.returnType.expressionType) &&
             this.source !== undefined) {
-            this.log(`Cannot call function ${this.name}(${argExprs
+            return this.loggedErrorExpr('non-aggregate-function-with-source', `Cannot call function ${this.name}(${argExprs
                 .map(e => e.dataType)
                 .join(', ')}) with source`);
-            return (0, ast_utils_1.errorFor)('cannot call with source');
         }
         const frag = {
             node: 'function_call',
@@ -203,7 +197,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             const isAnalytic = (0, malloy_types_1.expressionIsAnalytic)(overload.returnType.expressionType);
             if (!isAnalytic) {
                 if (!this.inExperiment('aggregate_order_by', true)) {
-                    props.orderBys[0].log('Enable experiment `aggregate_order_by` to use `order_by` with an aggregate function');
+                    props.orderBys[0].logError('aggregate-order-by-experiment-not-enabled', 'Enable experiment `aggregate_order_by` to use `order_by` with an aggregate function');
                 }
             }
             if (overload.supportsOrderBy || isAnalytic) {
@@ -214,7 +208,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                 frag.kids.orderBy = allObs;
             }
             else {
-                props.orderBys[0].log(`Function \`${this.name}\` does not support \`order_by\``);
+                props.orderBys[0].logError('function-does-not-support-order-by', `Function \`${this.name}\` does not support \`order_by\``);
             }
         }
         if ((props === null || props === void 0 ? void 0 : props.limit) !== undefined) {
@@ -222,7 +216,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                 frag.limit = props.limit.limit;
             }
             else {
-                this.log(`Function ${this.name} does not support limit`);
+                this.logError('function-does-not-support-limit', `Function ${this.name} does not support limit`);
             }
         }
         if ((props === null || props === void 0 ? void 0 : props.partitionBys) && props.partitionBys.length > 0) {
@@ -231,11 +225,11 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                 for (const partitionField of partitionBy.partitionFields) {
                     const e = partitionField.getField(fs);
                     if (e.found === undefined) {
-                        partitionField.log(`${partitionField.refString} is not defined`);
+                        partitionField.logError('partition-by-not-found', `${partitionField.refString} is not defined`);
                     }
                     else if ((0, malloy_types_1.expressionIsAnalytic)(e.found.typeDesc().expressionType) ||
                         (0, malloy_types_1.expressionIsUngroupedAggregate)(e.found.typeDesc().expressionType)) {
-                        partitionField.log('Partition expression must be scalar or aggregate');
+                        partitionField.logError('non-scalar-or-aggregate-partition-by', 'Partition expression must be scalar or aggregate');
                     }
                     else {
                         partitionByFields.push(partitionField.nameString);
@@ -252,13 +246,11 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             'sql_boolean',
         ].includes(func.name)) {
             if (!this.inExperiment('sql_functions', true)) {
-                const message = `Cannot use sql_function \`${func.name}\`; use \`sql_functions\` experiment to enable this behavior`;
-                this.log(message);
-                return (0, ast_utils_1.errorFor)('sql_function used without enabling');
+                return this.loggedErrorExpr('sql-functions-experiment-not-enabled', `Cannot use sql_function \`${func.name}\`; use \`sql_functions\` experiment to enable this behavior`);
             }
             const str = argExprs[0].value;
             if (str.node !== 'stringLiteral') {
-                this.log(`Invalid string literal for \`${func.name}\``);
+                this.logError('invalid-sql-function-argument', `Invalid string literal for \`${func.name}\``);
             }
             else {
                 const literal = str.literal;
@@ -272,8 +264,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                     const unsupportedInterpolationMsg = unsupportedInterpolations.length === 1
                         ? `'.' paths are not yet supported in sql interpolations, found ${unsupportedInterpolations.at(0)}`
                         : `'.' paths are not yet supported in sql interpolations, found (${unsupportedInterpolations.join(', ')})`;
-                    this.log(unsupportedInterpolationMsg);
-                    return (0, ast_utils_1.errorFor)(`${unsupportedInterpolationMsg}. See LookML \${...} documentation at https://cloud.google.com/looker/docs/reference/param-field-sql#sql_for_dimensions`);
+                    return this.loggedErrorExpr('unsupported-sql-function-interpolation', unsupportedInterpolationMsg);
                 }
                 const expr = [];
                 for (const part of parts) {
@@ -288,8 +279,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                         this.has({ name });
                         const result = fs.lookup([name]);
                         if (result.found === undefined) {
-                            this.log(`Invalid interpolation: ${result.error}`);
-                            return (0, ast_utils_1.errorFor)('invalid interpolated field');
+                            return this.loggedErrorExpr('sql-function-interpolation-not-found', `Invalid interpolation: ${result.error.message}`);
                         }
                         if (result.found.refType === 'parameter') {
                             expr.push({ node: 'parameter', path: [part.name] });
@@ -303,8 +293,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             }
         }
         if (type.dataType === 'any') {
-            this.log(`Invalid return type ${type.dataType} for function '${this.name}'`);
-            return (0, ast_utils_1.errorFor)('invalid return type');
+            return this.loggedErrorExpr('function-returns-any', `Invalid return type ${type.dataType} for function '${this.name}'`);
         }
         const maxEvalSpace = (0, malloy_types_1.mergeEvalSpaces)(...argExprs.map(e => e.evalSpace));
         // If the merged eval space of all args is constant, the result is constant.

package/dist/lang/ast/expressions/expr-granular-time.js

@@ -68,7 +68,7 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
             return tsVal;
         }
         if (exprVal.dataType !== 'error') {
-            this.log(`Cannot do time truncation on type '${exprVal.dataType}'`);
+            this.logError('unsupported-type-for-time-truncation', `Cannot do time truncation on type '${exprVal.dataType}'`);
         }
         const returnType = exprVal.dataType === 'error'
             ? (0, malloy_types_1.isDateUnit)(timeframe)

package/dist/lang/ast/expressions/expr-id-reference.js

@@ -24,7 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprIdReference = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
-const ast_utils_1 = require("../ast-utils");
 const expression_def_1 = require("../types/expression-def");
 class ExprIdReference extends expression_def_1.ExpressionDef {
     constructor(fieldReference) {
@@ -54,8 +53,7 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
                 : td.evalSpace;
             return { ...td, value, evalSpace };
         }
-        this.log(def.error);
-        return (0, ast_utils_1.errorFor)(def.error);
+        return this.loggedErrorExpr(def.error.code, def.error.message);
     }
 }
 exports.ExprIdReference = ExprIdReference;

package/dist/lang/ast/expressions/expr-props.js

@@ -42,14 +42,14 @@ class ExprProps extends expression_def_1.ExpressionDef {
     getFilteredExpression(fs, expr, wheres) {
         if (wheres.length > 0) {
             if (!this.expr.supportsWhere(expr)) {
-                this.expr.log('Filtered expression requires an aggregate computation');
+                this.expr.logError('filter-of-non-aggregate', 'Filtered expression requires an aggregate computation');
                 return expr;
             }
             const filterList = [];
             for (const where of wheres) {
                 const testList = where.getFilterList(fs);
                 if (testList.find(cond => (0, malloy_types_1.expressionIsCalculation)(cond.expressionType))) {
-                    where.log('Cannot filter an expresion with an aggregate or analytical computation');
+                    where.logError('aggregate-filter-expression-not-scalar', 'Cannot filter an expresion with an aggregate or analytical computation');
                     return expr;
                 }
                 filterList.push(...testList);
@@ -63,7 +63,7 @@ class ExprProps extends expression_def_1.ExpressionDef {
                     },
                 };
             }
-            this.expr.log(`Cannot filter '${expr.dataType}' data`);
+            this.expr.logError('filter-of-non-aggregate', `Cannot filter '${expr.expressionType}' data`);
             return (0, ast_utils_1.errorFor)('cannot filter type');
         }
         return expr;
@@ -76,7 +76,7 @@ class ExprProps extends expression_def_1.ExpressionDef {
         for (const statement of this.statements) {
             if (statement instanceof partition_by_1.PartitionBy) {
                 if (!this.expr.canSupportPartitionBy()) {
-                    statement.log('`partition_by` is not supported for this kind of expression');
+                    statement.logError('partition-by-of-non-window-function', '`partition_by` is not supported for this kind of expression');
                 }
                 else {
                     partitionBys.push(statement);
@@ -84,18 +84,18 @@ class ExprProps extends expression_def_1.ExpressionDef {
             }
             else if (statement instanceof limit_1.Limit) {
                 if (limit) {
-                    statement.log('limit already specified');
+                    statement.logError('expression-limit-already-specified', 'limit already specified');
                 }
                 else if (!this.expr.canSupportLimit()) {
-                    statement.log('`limit` is not supported for this kind of expression');
+                    statement.logError('limit-of-non-aggregate-function', '`limit` is not supported for this kind of expression');
                 }
                 else {
                     limit = statement;
                 }
             }
             else if (statement instanceof function_ordering_1.FunctionOrdering) {
-                if (!this.expr.canSupportPartitionBy()) {
-                    statement.log('`order_by` is not supported for this kind of expression');
+                if (!this.expr.canSupportOrderBy()) {
+                    statement.logError('order-by-of-non-aggregate-function', '`order_by` is not supported for this kind of expression');
                 }
                 else {
                     orderBys.push(statement);

package/dist/lang/ast/expressions/expr-time-extract.js

@@ -47,8 +47,7 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
         const extractTo = ExprTimeExtract.extractor(this.extractText);
         if (extractTo) {
             if (this.args.length !== 1) {
-                this.log(`Extraction function ${extractTo} requires one argument`);
-                return (0, ast_utils_1.errorFor)('{this.name} arg count');
+                return this.loggedErrorExpr('too-many-arguments-for-time-extraction', `Extraction function ${extractTo} requires one argument`);
             }
             const from = this.args[0];
             if (from instanceof range_1.Range) {
@@ -65,12 +64,10 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                     };
                 }
                 if (!(0, malloy_types_1.isTimeFieldType)(first.dataType)) {
-                    from.first.log(`Can't extract ${extractTo} from '${first.dataType}'`);
-                    return (0, ast_utils_1.errorFor)(`${extractTo} bad type ${first.dataType}`);
+                    return from.first.loggedErrorExpr('invalid-type-for-time-extraction', `Can't extract ${extractTo} from '${first.dataType}'`);
                 }
                 if (!(0, malloy_types_1.isTimeFieldType)(last.dataType)) {
-                    from.last.log(`Cannot extract ${extractTo} from '${last.dataType}'`);
-                    return (0, ast_utils_1.errorFor)(`${extractTo} bad type ${last.dataType}`);
+                    return from.last.loggedErrorExpr('invalid-type-for-time-extraction', `Cannot extract ${extractTo} from '${last.dataType}'`);
                 }
                 let valueType = first.dataType;
                 if (first.dataType !== last.dataType) {
@@ -91,17 +88,14 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                         }
                     }
                     if (cannotMeasure) {
-                        from.first.log(`Cannot measure from ${first.dataType} to ${last.dataType}`);
-                        return (0, ast_utils_1.errorFor)(`${extractTo} range mismatch`);
+                        return from.first.loggedErrorExpr('invalid-types-for-time-measurement', `Cannot measure from ${first.dataType} to ${last.dataType}`);
                     }
                 }
                 if (['week', 'month', 'quarter', 'year'].includes(extractTo)) {
-                    this.log(`Cannot measure interval using '${extractTo}'`);
-                    return (0, ast_utils_1.errorFor)(`${extractTo} civil extraction`);
+                    return this.loggedErrorExpr('invalid-timeframe-for-time-measurement', `Cannot measure interval using '${extractTo}'`);
                 }
                 if (!(0, malloy_types_1.isTimestampUnit)(extractTo)) {
-                    this.log(`Cannot extract ${extractTo} from a range`);
-                    return (0, ast_utils_1.errorFor)(`${extractTo} bad extraction`);
+                    return this.loggedErrorExpr('invalid-time-extraction-unit', `Cannot extract ${extractTo} from a range`);
                 }
                 return {
                     dataType: 'number',
@@ -132,7 +126,7 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                     };
                 }
                 if (argV.dataType !== 'error') {
-                    this.log(`${this.extractText}() requires time type, not '${argV.dataType}'`);
+                    this.logError('unsupported-type-for-time-extraction', `${this.extractText}() requires time type, not '${argV.dataType}'`);
                 }
                 return {
                     dataType: 'number',

package/dist/lang/ast/expressions/expr-ungroup.js

@@ -24,7 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprUngroup = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
-const ast_utils_1 = require("../ast-utils");
 const query_spaces_1 = require("../field-space/query-spaces");
 const fragtype_utils_1 = require("../fragtype-utils");
 const expression_def_1 = require("../types/expression-def");
@@ -43,12 +42,10 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
     getExpression(fs) {
         const exprVal = this.expr.getExpression(fs);
         if (!(0, malloy_types_1.expressionIsAggregate)(exprVal.expressionType)) {
-            this.expr.log(`${this.control}() expression must be an aggregate`);
-            return (0, ast_utils_1.errorFor)('ungrouped scalar');
+            return this.expr.loggedErrorExpr('ungroup-of-non-aggregate', `${this.control}() expression must be an aggregate`);
         }
         if ((0, malloy_types_1.expressionIsUngroupedAggregate)(exprVal.expressionType)) {
-            this.expr.log(`${this.control}() expression must not already be ungrouped`);
-            return (0, ast_utils_1.errorFor)('doubly-ungrouped aggregate');
+            return this.expr.loggedErrorExpr('ungroup-of-ungrouped-aggregate', `${this.control}() expression must not already be ungrouped`);
         }
         const ungroup = {
             node: this.control,
@@ -79,7 +76,7 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
                     }
                     if (notFound) {
                         const uName = isExclude ? 'exclude()' : 'all()';
-                        mentionedField.log(`${uName} '${mentionedField.refString}' is missing from query output`);
+                        mentionedField.logError('ungroup-field-not-in-output', `${uName} '${mentionedField.refString}' is missing from query output`);
                     }
                 }
                 ungroup.fields = dstFields;
@@ -91,8 +88,7 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
                 evalSpace: 'output',
             };
         }
-        this.log(`${this.control}() incompatible type`);
-        return (0, ast_utils_1.errorFor)('ungrouped type check');
+        return this.loggedErrorExpr('ungroup-with-non-scalar', `${this.control}() incompatible type`);
     }
 }
 exports.ExprUngroup = ExprUngroup;

package/dist/lang/ast/expressions/for-range.js

@@ -48,7 +48,7 @@ class ForRange extends expression_def_1.ExpressionDef {
         const nV = this.duration.getExpression(fs);
         if (nV.dataType !== 'number') {
             if (nV.dataType !== 'error') {
-                this.log(`FOR duration count must be a number, not '${nV.dataType}'`);
+                this.logError('invalid-duration-quantity', `FOR duration count must be a number, not '${nV.dataType}'`);
             }
             return {
                 dataType: 'boolean',
@@ -96,8 +96,7 @@ class ForRange extends expression_def_1.ExpressionDef {
         return undefined;
     }
     getExpression(_fs) {
-        this.log('A Range is not a value');
-        return (0, ast_utils_1.errorFor)('range has no value');
+        return this.loggedErrorExpr('range-as-value', 'A Range is not a value');
     }
 }
 exports.ForRange = ForRange;

package/dist/lang/ast/expressions/function-ordering.js

@@ -37,7 +37,7 @@ class FunctionOrderBy extends malloy_element_1.MalloyElement {
     }
     getAnalyticOrderBy(fs) {
         if (!this.field) {
-            this.log('analytic `order_by` must specify an aggregate expression or output field reference');
+            this.logError('analytic-order-by-missing-field', 'analytic `order_by` must specify an aggregate expression or output field reference');
             return { node: 'functionOrderBy', e: { node: 'error' }, dir: this.dir };
         }
         const expr = this.field.getExpression(fs);
@@ -47,11 +47,11 @@ class FunctionOrderBy extends malloy_element_1.MalloyElement {
         else if ((0, malloy_types_1.expressionIsScalar)(expr.expressionType)) {
             if (!(this.field instanceof expr_id_reference_1.ExprIdReference) ||
                 expr.evalSpace === 'input') {
-                this.field.log('analytic `order_by` must be an aggregate or an output field reference');
+                this.field.logError('analytic-order-by-not-output', 'analytic `order_by` must be an aggregate or an output field reference');
             }
         }
         else {
-            this.field.log('analytic `order_by` must be scalar or aggregate');
+            this.field.logError('analytic-order-by-not-aggregate-or-output', 'analytic `order_by` must be scalar or aggregate');
         }
         return { node: 'functionOrderBy', e: expr.value, dir: this.dir };
     }
@@ -59,17 +59,17 @@ class FunctionOrderBy extends malloy_element_1.MalloyElement {
         if (this.field) {
             const expr = this.field.getExpression(fs);
             if (!(0, malloy_types_1.expressionIsScalar)(expr.expressionType)) {
-                this.field.log('aggregate `order_by` must be scalar');
+                this.field.logError('aggregate-order-by-not-scalar', 'aggregate `order_by` must be scalar');
             }
             if (!allowExpression) {
-                this.field.log('`order_by` must be only `asc` or `desc` with no expression');
+                this.field.logError('aggregate-order-by-expression-not-allowed', '`order_by` must be only `asc` or `desc` with no expression');
             }
             return { node: 'functionOrderBy', e: expr.value, dir: this.dir };
         }
         else {
             if (this.dir === undefined) {
                 // This error should technically never happen because it can't parse this way
-                this.log('field or order direction must be specified');
+                this.logError('aggregate-order-by-without-field-or-direction', 'field or order direction must be specified');
                 return { node: 'functionDefaultOrderBy', dir: 'asc' };
             }
             return { node: 'functionDefaultOrderBy', dir: this.dir };

package/dist/lang/ast/expressions/partial-compare.js

@@ -23,7 +23,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PartialCompare = void 0;
-const ast_utils_1 = require("../ast-utils");
 const expression_def_1 = require("../types/expression-def");
 class PartialCompare extends expression_def_1.ExpressionDef {
     constructor(op, right) {
@@ -42,8 +41,7 @@ class PartialCompare extends expression_def_1.ExpressionDef {
         return undefined;
     }
     getExpression(_fs) {
-        this.log('Partial comparison does not have a value');
-        return (0, ast_utils_1.errorFor)('no value for partial compare');
+        return this.loggedErrorExpr('partial-as-value', 'Partial comparison does not have a value');
     }
 }
 exports.PartialCompare = PartialCompare;