@malloydata/malloy 0.0.43-dev230621191254 → 0.0.43-dev230622144455

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

@@ -33,7 +33,7 @@ exports.errorFor = void 0;
  */
 function errorFor(reason) {
     return {
-        dataType: 'unknown',
+        dataType: 'error',
         expressionType: 'scalar',
         value: [`_ERROR_${reason.replace(/ /g, '_')}`],
         evalSpace: 'constant',

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

@@ -48,8 +48,12 @@ class ExprCoalesce extends expression_def_1.ExpressionDef {
          * SQL, but I decided that is will happen when the "expressions are true
          * trees" rewrite happens.
          */
+        if (!fragtype_utils_1.FT.typeEq(maybeNull, whenNull)) {
+            this.log(`Mismatched types for coalesce (${maybeNull.dataType}, ${whenNull.dataType})`);
+        }
         return {
             ...whenNull,
+            dataType: maybeNull.dataType === 'error' ? whenNull.dataType : maybeNull.dataType,
             expressionType: (0, model_1.maxExpressionType)(maybeNull.expressionType, whenNull.expressionType),
             value: (0, model_1.mkExpr) `COALESCE(${maybeNull.value},${whenNull.value})`,
             evalSpace: (0, model_1.mergeEvalSpaces)(maybeNull.evalSpace, whenNull.evalSpace),

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

@@ -70,21 +70,11 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         const func = (_c = this.modelEntry(this.name.toLowerCase())) === 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.`);
-            return {
-                dataType: 'unknown',
-                expressionType: 'scalar',
-                value: [],
-                evalSpace: 'constant',
-            };
+            return (0, ast_utils_1.errorFor)('unknown function');
         }
         else if (func.type !== 'function') {
             this.log(`Cannot call '${this.name}', which is of type ${func.type}`);
-            return {
-                dataType: 'unknown',
-                expressionType: 'scalar',
-                value: [],
-                evalSpace: 'constant',
-            };
+            return (0, ast_utils_1.errorFor)('called non function');
         }
         // Find the 'implicit argument' for aggregate functions called like `some_join.some_field.agg(...args)`
         // where the full arg list is `(some_field, ...args)`.
@@ -127,12 +117,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             this.log(`No matching overload for function ${this.name}(${argExprs
                 .map(e => e.dataType)
                 .join(', ')})`);
-            return {
-                dataType: 'unknown',
-                expressionType: 'scalar',
-                value: [],
-                evalSpace: 'constant',
-            };
+            return (0, ast_utils_1.errorFor)('no matching overload');
         }
         const { overload, expressionTypeErrors, evalSpaceErrors, nullabilityErrors } = result;
         // Report errors for expression type mismatch
@@ -171,12 +156,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             this.log(`Cannot call function ${this.name}(${argExprs
                 .map(e => e.dataType)
                 .join(', ')}) with source`);
-            return {
-                dataType: 'unknown',
-                expressionType,
-                value: [],
-                evalSpace: 'constant',
-            };
+            return (0, ast_utils_1.errorFor)('cannot call with source');
         }
         const funcCall = [
             {
@@ -189,12 +169,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         ];
         if (type.dataType === 'any') {
             this.log(`Invalid return type ${type.dataType} for function '${this.name}'`);
-            return {
-                dataType: 'unknown',
-                expressionType,
-                value: [],
-                evalSpace: 'constant',
-            };
+            return (0, ast_utils_1.errorFor)('invalid return type');
         }
         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.
@@ -240,10 +215,7 @@ function findOverload(func, args) {
                     // does not make sense to limit function calls to not allow nulls, since have
                     // so little control over nullability.
                     arg.dataType === 'null' ||
-                    // TODO I've included this because it means that errors cascade a bit less...
-                    // I think we may want to add an `error` type for nodes generated from errors,
-                    // then make `error` propagate without generating more errors.
-                    arg.dataType === 'unknown';
+                    arg.dataType === 'error';
                 // Check expression type errors
                 if (paramT.expressionType) {
                     const expressionTypeMatch = (0, malloy_types_1.isExpressionTypeLEQ)(arg.expressionType, paramT.expressionType);

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

@@ -70,8 +70,20 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
             }
             return tsVal;
         }
-        this.log(`Cannot do time truncation on type '${exprVal.dataType}'`);
-        return (0, ast_utils_1.errorFor)('granularity typecheck');
+        if (exprVal.dataType !== 'error') {
+            this.log(`Cannot do time truncation on type '${exprVal.dataType}'`);
+        }
+        const returnType = exprVal.dataType === 'error'
+            ? (0, malloy_types_1.isDateUnit)(timeframe)
+                ? 'date'
+                : 'timestamp'
+            : exprVal.dataType;
+        return {
+            ...exprVal,
+            dataType: returnType,
+            value: (0, ast_utils_1.errorFor)('granularity typecheck').value,
+            evalSpace: 'constant',
+        };
     }
     apply(fs, op, left) {
         return this.getRange(fs).apply(fs, op, left);

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

@@ -37,9 +37,9 @@ class ExprMinus extends expression_def_1.ExpressionDef {
         const expr = this.expr.getExpression(fs);
         if (this.typeCheck(this.expr, expr)) {
             if (expr.value.length > 1) {
-                return { ...expr, value: ['-(', ...expr.value, ')'] };
+                return { ...expr, dataType: 'number', value: ['-(', ...expr.value, ')'] };
             }
-            return { ...expr, value: ['-', ...expr.value] };
+            return { ...expr, dataType: 'number', value: ['-', ...expr.value] };
         }
         return (0, ast_utils_1.errorFor)('negate requires number');
     }

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

@@ -54,6 +54,16 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
             if (from instanceof range_1.Range) {
                 let first = from.first.getExpression(fs);
                 let last = from.last.getExpression(fs);
+                const expressionType = (0, malloy_types_1.maxExpressionType)(first.expressionType, last.expressionType);
+                const evalSpace = (0, malloy_types_1.mergeEvalSpaces)(first.evalSpace, last.evalSpace);
+                if (first.dataType === 'error' || last.dataType === 'error') {
+                    return {
+                        dataType: 'number',
+                        expressionType,
+                        evalSpace,
+                        value: (0, ast_utils_1.errorFor)('extract from error').value,
+                    };
+                }
                 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}`);
@@ -95,8 +105,8 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                 }
                 return {
                     dataType: 'number',
-                    expressionType: (0, malloy_types_1.maxExpressionType)(first.expressionType, last.expressionType),
-                    evalSpace: (0, malloy_types_1.mergeEvalSpaces)(first.evalSpace, last.evalSpace),
+                    expressionType,
+                    evalSpace,
                     value: [
                         {
                             type: 'dialect',
@@ -125,8 +135,16 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                         ],
                     };
                 }
-                this.log(`${this.extractText}() requires time type, not '${argV.dataType}'`);
-                return (0, ast_utils_1.errorFor)(`${this.extractText} bad type ${argV.dataType}`);
+                if (argV.dataType !== 'error') {
+                    this.log(`${this.extractText}() requires time type, not '${argV.dataType}'`);
+                }
+                return {
+                    dataType: 'number',
+                    expressionType: argV.expressionType,
+                    evalSpace: argV.evalSpace,
+                    value: (0, ast_utils_1.errorFor)(`${this.extractText} bad type ${argV.dataType}`)
+                        .value,
+                };
             }
         }
         throw this.internalError(`Illegal extraction unit '${this.extractText}'`);

package/dist/lang/ast/expressions/for-range.d.ts

@@ -7,7 +7,7 @@ export declare class ForRange extends ExpressionDef {
     readonly duration: ExpressionDef;
     readonly timeframe: Timeframe;
     elementType: string;
-    legalChildTypes: import("../../..").TypeDesc[];
+    legalChildTypes: import("../../../model").TypeDesc[];
     constructor(from: ExpressionDef, duration: ExpressionDef, timeframe: Timeframe);
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): undefined;

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

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForRange = void 0;
+const model_1 = require("../../../model");
 const ast_utils_1 = require("../ast-utils");
 const fragtype_utils_1 = require("../fragtype-utils");
 const time_utils_1 = require("../time-utils");
@@ -46,8 +47,15 @@ class ForRange extends expression_def_1.ExpressionDef {
         }
         const nV = this.duration.getExpression(fs);
         if (nV.dataType !== 'number') {
-            this.log(`FOR duration count must be a number, not '${nV.dataType}'`);
-            return (0, ast_utils_1.errorFor)('FOR not number');
+            if (nV.dataType !== 'error') {
+                this.log(`FOR duration count must be a number, not '${nV.dataType}'`);
+            }
+            return {
+                dataType: 'boolean',
+                evalSpace: (0, model_1.mergeEvalSpaces)(startV.evalSpace, checkV.evalSpace),
+                expressionType: (0, model_1.maxExpressionType)(startV.expressionType, checkV.expressionType),
+                value: (0, ast_utils_1.errorFor)('for not number').value,
+            };
         }
         const units = this.timeframe.text;
         // If the duration resolution is smaller than date, we have

package/dist/lang/ast/expressions/pick-when.js

@@ -30,7 +30,11 @@ const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
 const utils_1 = require("./utils");
 function typeCoalesce(ev1, ev2) {
-    return ev1 === undefined || ev1.dataType === 'null' ? ev2 : ev1;
+    return ev1 === undefined ||
+        ev1.dataType === 'null' ||
+        ev1.dataType === 'error'
+        ? ev2
+        : ev1;
 }
 class Pick extends expression_def_1.ExpressionDef {
     constructor(choices, elsePick) {

package/dist/lang/ast/field-space/query-spaces.js

@@ -292,14 +292,11 @@ class QuerySpace extends refined_space_1.RefinedSpace {
                     }
                     else {
                         const typeDesc = field.typeDesc();
-                        // Filter out fields whose type is unknown, which means that a totally bad field
-                        // isn't sent to the compiler, where it will wig out. The downside is that in
-                        // subsequent stages of a query, the field is not in the input struct. But since
-                        // the error message says "Cannot define x which has unknown type", it makes sense
-                        // that it wouldn't be "defined" in later stages.
+                        // Filter out fields whose type is 'error', which means that a totally bad field
+                        // isn't sent to the compiler, where it will wig out.
                         // TODO Figure out how to make errors generated by `canContain` go in the right place,
                         // maybe by adding a logable element to SpaceFields.
-                        if (typeDesc.dataType !== 'unknown' && this.canContain(typeDesc)) {
+                        if (typeDesc.dataType !== 'error' && this.canContain(typeDesc)) {
                             fields.push(fieldQueryDef);
                         }
                     }

package/dist/lang/ast/field-space/reference-field.js

@@ -45,7 +45,7 @@ class ReferenceField extends space_field_1.SpaceField {
         if (this.res !== undefined && this.res.found) {
             return this.res.found.typeDesc();
         }
-        return { dataType: 'unknown', expressionType: 'scalar', evalSpace: 'input' };
+        return { dataType: 'error', expressionType: 'scalar', evalSpace: 'input' };
     }
 }
 exports.ReferenceField = ReferenceField;

package/dist/lang/ast/fragtype-utils.d.ts

@@ -21,7 +21,7 @@ export declare class FT {
      * @param right Right type
      * @param nullOk True if a NULL is an acceptable match
      */
-    static typeEq(left: TypeDesc, right: TypeDesc, nullOk?: boolean): boolean;
+    static typeEq(left: TypeDesc, right: TypeDesc, nullOk?: boolean, errorOk?: boolean): boolean;
     /**
      *
      * For error messages, returns a comma seperated list of readable names

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

@@ -59,10 +59,11 @@ class FT {
      * @param right Right type
      * @param nullOk True if a NULL is an acceptable match
      */
-    static typeEq(left, right, nullOk = false) {
+    static typeEq(left, right, nullOk = false, errorOk = true) {
         const maybeEq = left.dataType === right.dataType;
         const nullEq = nullOk && (left.dataType === 'null' || right.dataType === 'null');
-        return maybeEq || nullEq;
+        const errorEq = errorOk && (left.dataType === 'error' || right.dataType === 'error');
+        return maybeEq || nullEq || errorEq;
     }
     /**
      *

package/dist/lang/ast/parameters/constant-parameter.js

@@ -37,7 +37,7 @@ class ConstantParameter extends has_parameter_1.HasParameter {
             this.log(`Unexpected expression type '${cVal.dataType}'`);
             return {
                 value: ['XXX-type-mismatch-error-XXX'],
-                type: 'string',
+                type: 'error',
                 name: this.name,
                 constant: true,
             };

package/dist/lang/ast/query-items/field-declaration.js

@@ -66,8 +66,8 @@ class FieldDeclaration extends malloy_element_1.MalloyElement {
         catch (error) {
             this.log(`Cannot define '${exprName}', ${error.message}`);
             return {
-                name: `error_defining_${exprName}`,
-                type: 'string',
+                name: exprName,
+                type: 'error',
             };
         }
         const compressValue = (0, utils_1.compressExpr)(exprValue.value);
@@ -96,17 +96,14 @@ class FieldDeclaration extends malloy_element_1.MalloyElement {
         }
         const circularDef = exprFS instanceof DefSpace && exprFS.foundCircle;
         if (!circularDef) {
-            if (exprValue.dataType === 'unknown') {
-                this.log(`Cannot define '${exprName}', value has unknown type`);
-            }
-            else {
+            if (exprValue.dataType !== 'error') {
                 const badType = fragtype_utils_1.FT.inspect(exprValue);
                 this.log(`Cannot define '${exprName}', unexpected type: ${badType}`);
             }
         }
         return {
-            name: `error_defining_${exprName}`,
-            type: 'string',
+            name: exprName,
+            type: 'error',
         };
     }
 }

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

@@ -67,7 +67,7 @@ class ExpressionDef extends malloy_element_1.MalloyElement {
      * @param eVal ...list of expressions that must match legalChildTypes
      */
     typeCheck(eNode, eVal) {
-        if (!fragtype_utils_1.FT.in(eVal, this.legalChildTypes)) {
+        if (eVal.dataType !== 'error' && !fragtype_utils_1.FT.in(eVal, this.legalChildTypes)) {
             eNode.log(`'${this.elementType}' Can't use type ${fragtype_utils_1.FT.inspect(eVal)}`);
             return false;
         }
@@ -232,6 +232,9 @@ function nullCompare(left, op, right) {
 function equality(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
+    const err = errorCascade('boolean', lhs, rhs);
+    if (err)
+        return err;
     // Unsupported types can be compare with null
     const checkUnsupport = lhs.dataType === 'unsupported' || rhs.dataType === 'unsupported';
     if (checkUnsupport) {
@@ -245,7 +248,7 @@ function equality(fs, left, op, right) {
         }
     }
     let value = timeCompare(left, lhs, op, rhs) || (0, utils_1.compose)(lhs.value, op, rhs.value);
-    if (lhs.dataType !== 'unknown' && rhs.dataType !== 'unknown') {
+    if (lhs.dataType !== 'error' && rhs.dataType !== 'error') {
         switch (op) {
             case '~':
             case '!~': {
@@ -285,6 +288,9 @@ function equality(fs, left, op, right) {
 function compare(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
+    const err = errorCascade('boolean', lhs, rhs);
+    if (err)
+        return err;
     const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
     const noCompare = unsupportError(left, lhs, right, rhs);
     if (noCompare) {
@@ -312,6 +318,9 @@ function allAre(oneType, ...values) {
 function numeric(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
+    const err = errorCascade('number', lhs, rhs);
+    if (err)
+        return err;
     const noGo = unsupportError(left, lhs, right, rhs);
     if (noGo) {
         return noGo;
@@ -335,7 +344,11 @@ function delta(fs, left, op, right) {
     if (noGo) {
         return noGo;
     }
-    if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType)) {
+    const timeLHS = (0, malloy_types_1.isTimeFieldType)(lhs.dataType);
+    const err = errorCascade(timeLHS ? 'error' : 'number', lhs, rhs);
+    if (err)
+        return err;
+    if (timeLHS) {
         let duration = right;
         if (rhs.dataType !== 'duration') {
             if ((0, granular_result_1.isGranularResult)(lhs)) {
@@ -385,6 +398,9 @@ function applyBinary(fs, left, op, right) {
             left.log('Cannot operate with unsupported type');
             return noGo;
         }
+        const err = errorCascade('number', num, denom);
+        if (err)
+            return err;
         if (num.dataType !== 'number') {
             left.log('Numerator for division must be a number');
         }
@@ -411,6 +427,16 @@ function applyBinary(fs, left, op, right) {
     return (0, ast_utils_1.errorFor)('applybinary bad operator');
 }
 exports.applyBinary = applyBinary;
+function errorCascade(dataType, ...es) {
+    if (es.some(e => e.dataType === 'error')) {
+        return {
+            dataType,
+            expressionType: (0, malloy_types_1.maxOfExpressionTypes)(es.map(e => e.expressionType)),
+            value: ["'cascading error'"],
+            evalSpace: (0, malloy_types_1.mergeEvalSpaces)(...es.map(e => e.evalSpace)),
+        };
+    }
+}
 /**
  * Return an error if a binary operation includes unsupported types.
  */

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

@@ -297,14 +297,6 @@ class RunList extends ListOf {
     }
     executeList(doc) {
         while (this.execCursor < this.elements.length) {
-            if (doc.errorsExist()) {
-                // TODO make a better way to stop cascading errors -- this way means that if there are
-                // actual different errors in multiple places, we only see the first one. A better way
-                // might be to make things that have error pass all kinds of typechecks, which prevents
-                // the real cascade.
-                // This stops cascading errors
-                return;
-            }
             const el = this.elements[this.execCursor];
             if (isDocStatement(el)) {
                 const resp = el.execute(doc);

package/dist/lang/ast/types/space-param.js

@@ -40,7 +40,7 @@ class AbstractParameter extends SpaceParam {
         return this.astParam.parameter();
     }
     typeDesc() {
-        const type = this.astParam.type || 'unknown';
+        const type = this.astParam.type || 'error';
         // TODO Not sure whether params are considered "input space". It seems like they
         // could be input or constant, depending on usage.
         return { dataType: type, expressionType: 'scalar', evalSpace: 'input' };

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

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 /*
  * Copyright 2023 Google LLC
@@ -24,30 +27,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 require("./parse-expects");
 const test_translator_1 = require("./test-translator");
+const escapeRegExp_1 = __importDefault(require("lodash/escapeRegExp"));
 describe('import:', () => {
     test('simple source', () => {
         const docParse = new test_translator_1.TestTranslator('import "child"');
         const xr = docParse.unresolved();
-        expect(docParse).toBeErrorless();
+        expect(docParse).toParse();
         expect(xr).toEqual({ urls: ['internal://test/langtests/child'] });
         docParse.update({
             urls: { 'internal://test/langtests/child': 'source: aa is a' },
         });
-        expect(docParse).modelCompiled();
+        expect(docParse).toTranslate();
         const aa = docParse.getSourceDef('aa');
         expect(aa).toBeDefined();
     });
     test('simple query', () => {
         const docParse = new test_translator_1.TestTranslator('import "child"');
         const xr = docParse.unresolved();
-        expect(docParse).toBeErrorless();
+        expect(docParse).toParse();
         expect(xr).toEqual({ urls: ['internal://test/langtests/child'] });
         docParse.update({
             urls: {
                 'internal://test/langtests/child': 'query: aq is a->{ project: * }',
             },
         });
-        expect(docParse).modelCompiled();
+        expect(docParse).toTranslate();
         const aq = docParse.getQuery('aq');
         expect(aq).toBeDefined();
     });
@@ -59,7 +63,7 @@ source: newSrc is a {
 }
 `);
         const xr = docParse.unresolved();
-        expect(docParse).toBeErrorless();
+        expect(docParse).toParse();
         expect(xr).toEqual({ urls: ['internal://test/langtests/child'] });
         docParse.update({
             urls: {
@@ -70,7 +74,7 @@ source: botProjQSrc is from(->botProjQ)
 `,
             },
         });
-        expect(docParse).modelCompiled();
+        expect(docParse).toTranslate();
         const newSrc = docParse.getSourceDef('newSrc');
         const f = newSrc === null || newSrc === void 0 ? void 0 : newSrc.fields.find(f => f.name === 'b');
         expect(f === null || f === void 0 ? void 0 : f.type).toBe('struct');
@@ -85,7 +89,7 @@ source: botProjQSrc is from(->botProjQ)
     test('missing import', () => {
         const docParse = new test_translator_1.TestTranslator('import "child"');
         const xr = docParse.unresolved();
-        expect(docParse).toBeErrorless();
+        expect(docParse).toParse();
         expect(xr).toEqual({ urls: ['internal://test/langtests/child'] });
         const reportedError = 'ENOWAY: No way to find your child';
         docParse.update({
@@ -94,8 +98,7 @@ source: botProjQSrc is from(->botProjQ)
             },
         });
         docParse.translate();
-        expect(docParse).not.toBeErrorless();
-        expect(docParse.prettyErrors()).toContain(reportedError);
+        expect(docParse).translationToFailWith(new RegExp((0, escapeRegExp_1.default)(reportedError)));
     });
     test('chained imports', () => {
         const docParse = new test_translator_1.TestTranslator('import "child"');
@@ -103,12 +106,12 @@ source: botProjQSrc is from(->botProjQ)
             urls: { 'internal://test/langtests/child': 'import "grandChild"' },
         });
         const xr = docParse.unresolved();
-        expect(docParse).toBeErrorless();
+        expect(docParse).toParse();
         expect(xr).toEqual({ urls: ['internal://test/langtests/grandChild'] });
     });
     test('relative imports', () => {
         const docParse = new test_translator_1.TestTranslator('import "../parent.malloy"');
-        expect(docParse).modelParsed();
+        expect(docParse).toParse();
         const xr = docParse.unresolved();
         expect(xr).toEqual({ urls: ['internal://test/parent.malloy'] });
         docParse.update({
@@ -116,11 +119,11 @@ source: botProjQSrc is from(->botProjQ)
                 'internal://test/parent.malloy': "source: aa is table('aTable')",
             },
         });
-        expect(docParse).modelCompiled();
+        expect(docParse).toTranslate();
     });
     test('relative imports with errors', () => {
         const docParse = new test_translator_1.TestTranslator('import "../parent.malloy"');
-        expect(docParse).modelParsed();
+        expect(docParse).toParse();
         const xr = docParse.unresolved();
         expect(xr).toEqual({ urls: ['internal://test/parent.malloy'] });
         docParse.update({
@@ -131,7 +134,7 @@ source: botProjQSrc is from(->botProjQ)
           }`,
             },
         });
-        expect(docParse).compileToFailWith("Cannot redefine 'astr'");
+        expect(docParse).translationToFailWith("Cannot redefine 'astr'");
     });
     test('source references expanded when not exported', () => {
         const srcFiles = {
@@ -145,7 +148,7 @@ source: botProjQSrc is from(->botProjQ)
       import "middle"
     `);
         fullModel.update({ urls: srcFiles });
-        expect(fullModel).modelCompiled();
+        expect(fullModel).toTranslate();
         const ms = fullModel.getSourceDef('midSrc');
         expect(ms).toBeDefined();
         if (ms) {

package/dist/lang/test/parse-expects.d.ts

@@ -3,13 +3,39 @@ declare type ErrorSpec = string | RegExp;
 declare global {
     namespace jest {
         interface Matchers<R> {
-            modelParsed(): R;
-            toBeErrorless(): R;
-            toCompile(): R;
-            modelCompiled(): R;
-            expressionCompiled(): R;
+            /**
+             * expect(X).toParse()
+             *
+             * Passes if the source parses to an AST without errors.
+             *
+             * X can be a MarkedSource, a string, or a model. If it is a marked
+             * source, the errors which are found must match the locations of
+             * the markings.
+             */
+            toParse(): R;
+            /**
+             * expect(X).toTranslate()
+             *
+             * Passes if the source compiles to code which could be used to
+             * generate SQL.
+             *
+             * X can be a MarkedSource, a string, or a model. If it is a marked
+             * source, the errors which are found must match the locations of
+             * the markings.
+             */
+            toTranslate(): R;
             toReturnType(tp: string): R;
-            compileToFailWith(...expectedErrors: ErrorSpec[]): R;
+            /**
+             * expect(X).translateToFailWith(expectedErrors)
+             *
+             * X can be a MarkedSource, a string, or a model. If it is a marked
+             * source, the errors which are found must match the locations of
+             * the markings.
+             *
+             * @param expectedErrors varargs list of strings which must match
+             *        exactly, or regular expressions.
+             */
+            translationToFailWith(...expectedErrors: ErrorSpec[]): R;
             isLocationIn(at: DocumentLocation, txt: string): R;
         }
     }