@malloydata/malloy 0.0.179 → 0.0.180-dev240906180931

package/dist/lang/lib/Malloy/MalloyParserListener.d.ts

@@ -35,6 +35,8 @@ import { ExprForRangeContext } from "./MalloyParser";
 import { ExprAndTreeContext } from "./MalloyParser";
 import { ExprOrTreeContext } from "./MalloyParser";
 import { ExprCompareContext } from "./MalloyParser";
+import { ExprWarnLikeContext } from "./MalloyParser";
+import { ExprWarnNullCmpContext } from "./MalloyParser";
 import { ExprApplyContext } from "./MalloyParser";
 import { ExprNotContext } from "./MalloyParser";
 import { ExprLogicalAndContext } from "./MalloyParser";
@@ -646,6 +648,30 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitExprCompare?: (ctx: ExprCompareContext) => void;
+    /**
+     * Enter a parse tree produced by the `exprWarnLike`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     */
+    enterExprWarnLike?: (ctx: ExprWarnLikeContext) => void;
+    /**
+     * Exit a parse tree produced by the `exprWarnLike`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     */
+    exitExprWarnLike?: (ctx: ExprWarnLikeContext) => void;
+    /**
+     * Enter a parse tree produced by the `exprWarnNullCmp`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     */
+    enterExprWarnNullCmp?: (ctx: ExprWarnNullCmpContext) => void;
+    /**
+     * Exit a parse tree produced by the `exprWarnNullCmp`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     */
+    exitExprWarnNullCmp?: (ctx: ExprWarnNullCmpContext) => void;
     /**
      * Enter a parse tree produced by the `exprApply`
      * labeled alternative in `MalloyParser.fieldExpr`.

package/dist/lang/lib/Malloy/MalloyParserVisitor.d.ts

@@ -35,6 +35,8 @@ import { ExprForRangeContext } from "./MalloyParser";
 import { ExprAndTreeContext } from "./MalloyParser";
 import { ExprOrTreeContext } from "./MalloyParser";
 import { ExprCompareContext } from "./MalloyParser";
+import { ExprWarnLikeContext } from "./MalloyParser";
+import { ExprWarnNullCmpContext } from "./MalloyParser";
 import { ExprApplyContext } from "./MalloyParser";
 import { ExprNotContext } from "./MalloyParser";
 import { ExprLogicalAndContext } from "./MalloyParser";
@@ -469,6 +471,20 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitExprCompare?: (ctx: ExprCompareContext) => Result;
+    /**
+     * Visit a parse tree produced by the `exprWarnLike`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExprWarnLike?: (ctx: ExprWarnLikeContext) => Result;
+    /**
+     * Visit a parse tree produced by the `exprWarnNullCmp`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExprWarnNullCmp?: (ctx: ExprWarnNullCmpContext) => Result;
     /**
      * Visit a parse tree produced by the `exprApply`
      * labeled alternative in `MalloyParser.fieldExpr`.

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

@@ -9,7 +9,7 @@ import { MalloyParseInfo } from './malloy-parse-info';
 import { FieldDeclarationConstructor } from './ast';
 import { HasString, HasID } from './parse-utils';
 import { CastType } from '../model';
-import { DocumentLocation, Note } from '../model/malloy_types';
+import { DocumentLocation, DocumentRange, Note } from '../model/malloy_types';
 import { Tag } from '../tags';
 declare class ErrorNode extends ast.SourceQueryElement {
     elementType: string;
@@ -49,6 +49,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
      * Log an error message relative to a parse node
      */
     protected contextError(cx: ParserRuleContext, msg: string, sev?: LogSeverity): void;
+    protected warnWithReplacement(message: string, range: DocumentRange, replacement: string): void;
     protected inExperiment(experimentID: string, cx: ParserRuleContext): boolean;
     protected m4Severity(): LogSeverity | false;
     protected m4advisory(cx: ParserRuleContext, msg: string): void;
@@ -221,5 +222,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitSQTable(pcx: parse.SQTableContext): ast.SQSource | ErrorNode;
     visitSQSQL(pcx: parse.SQSQLContext): ast.SQSource;
     visitExperimentalStatementForTesting(pcx: parse.ExperimentalStatementForTestingContext): ast.ExperimentalExperiment;
+    visitExprWarnLike(pcx: parse.ExprWarnLikeContext): ast.ExprCompare;
+    visitExprWarnNullCmp(pcx: parse.ExprWarnNullCmpContext): ast.ExprCompare;
 }
 export {};

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

@@ -120,6 +120,14 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
             severity: sev,
         });
     }
+    warnWithReplacement(message, range, replacement) {
+        this.msgLog.log({
+            message,
+            at: { url: this.parseInfo.sourceURL, range },
+            severity: 'warn',
+            replacement,
+        });
+    }
     inExperiment(experimentID, cx) {
         const experimental = this.compilerFlags.tag('experimental');
         if (experimental &&
@@ -1303,6 +1311,34 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         this.inExperiment('compilerTestExperimentParse', pcx);
         return this.astAt(new ast.ExperimentalExperiment('compilerTestExperimentTranslate'), pcx);
     }
+    visitExprWarnLike(pcx) {
+        let op = '~';
+        const left = pcx.fieldExpr(0);
+        const right = pcx.fieldExpr(1);
+        const wholeRange = this.parseInfo.rangeFromContext(pcx);
+        if (pcx.NOT()) {
+            op = '!~';
+            this.warnWithReplacement("Use Malloy operator '!~' instead of 'NOT LIKE'", wholeRange, `${left.text} !~ ${right.text}`);
+        }
+        else {
+            this.warnWithReplacement("Use Malloy operator '~' instead of 'LIKE'", wholeRange, `${left.text} ~ ${right.text}`);
+        }
+        return this.astAt(new ast.ExprCompare(this.getFieldExpr(left), op, this.getFieldExpr(right)), pcx);
+    }
+    visitExprWarnNullCmp(pcx) {
+        let op = '=';
+        const expr = pcx.fieldExpr();
+        const wholeRange = this.parseInfo.rangeFromContext(pcx);
+        if (pcx.NOT()) {
+            op = '!=';
+            this.warnWithReplacement("Use '!= NULL' to check for NULL instead of 'IS NOT NULL'", wholeRange, `${expr.text} != null`);
+        }
+        else {
+            this.warnWithReplacement("Use '= NULL' to check for NULL instead of 'IS NULL'", wholeRange, `${expr.text} = null`);
+        }
+        const nullExpr = new ast.ExprNULL();
+        return this.astAt(new ast.ExprCompare(this.getFieldExpr(expr), op, nullExpr), pcx);
+    }
 }
 exports.MalloyToAST = MalloyToAST;
 //# sourceMappingURL=malloy-to-ast.js.map

package/dist/lang/parse-log.d.ts

@@ -8,6 +8,7 @@ export interface LogMessage {
     at?: DocumentLocation;
     severity: LogSeverity;
     errorTag?: string;
+    replacement?: string;
 }
 export interface MessageLogger {
     log(logMsg: LogMessage): void;

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

@@ -24,41 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const test_translator_1 = require("./test-translator");
 require("./parse-expects");
-/**
- * Try and write a generic version of the expression, might some day be the basis for
- * a much better expression matcher.
- */
-function exprToString(e, symbols = {}) {
-    switch (e.node) {
-        case '=':
-        case '>':
-        case '>=':
-        case '<':
-        case '<=':
-        case '+':
-        case '-':
-        case '*':
-        case '/':
-        case '%':
-            return `${exprToString(e.kids.left, symbols)}${e.node}${exprToString(e.kids.right, symbols)}`;
-        case 'and':
-        case 'or':
-            return `(${exprToString(e.kids.left, symbols)})${e.node}(${exprToString(e.kids.right, symbols)})`;
-        case 'field': {
-            const ref = e.path.join('.');
-            if (symbols[ref] === undefined) {
-                const nSyms = Object.keys(symbols).length;
-                symbols[ref] = String.fromCharCode('A'.charCodeAt(0) + nSyms);
-            }
-            return symbols[ref];
-        }
-        case '()':
-            return `(${exprToString(e.e, symbols)})`;
-        case 'not':
-            return `not(${exprToString(e.e, symbols)})`;
-    }
-    return `{${e.node}}`;
-}
 describe('expressions', () => {
     describe('timeframes', () => {
         const timeframes = [
@@ -91,14 +56,14 @@ describe('expressions', () => {
         });
     });
     test('field name', () => {
-        expect((0, test_translator_1.expr) `astr`).toTranslate();
+        expect((0, test_translator_1.expr) `astr`).compilesTo('astr');
     });
     test('function call', () => {
         expect((0, test_translator_1.expr) `concat('foo')`).toTranslate();
     });
     describe('operators', () => {
         test('addition', () => {
-            expect((0, test_translator_1.expr) `42 + 7`).toTranslate();
+            expect('42 + 7').compilesTo('{42 + 7}');
         });
         test('typecheck addition lhs', () => {
             const wrong = (0, test_translator_1.expr) `${'"string"'} + 1`;
@@ -109,58 +74,58 @@ describe('expressions', () => {
             expect(wrong).translationToFailWith("The '+' operator requires a number, not a 'string'");
         });
         test('subtraction', () => {
-            expect((0, test_translator_1.expr) `42 - 7`).toTranslate();
+            expect('42 - 7').compilesTo('{42 - 7}');
         });
         test('multiplication', () => {
-            expect((0, test_translator_1.expr) `42 * 7`).toTranslate();
+            expect('42 * 7').compilesTo('{42 * 7}');
         });
         test('mod', () => {
-            expect((0, test_translator_1.expr) `42 % 7`).toTranslate();
+            expect('42 % 7').compilesTo('{42 % 7}');
         });
         test('division', () => {
-            expect((0, test_translator_1.expr) `42 / 7`).toTranslate();
+            expect('42 / 7').compilesTo('{42 / 7}');
         });
         test('unary negation', () => {
-            expect((0, test_translator_1.expr) `- ai`).toTranslate();
+            expect('- ai').compilesTo('{unary- ai}');
         });
         test('equal', () => {
-            expect((0, test_translator_1.expr) `42 = 7`).toTranslate();
+            expect('42 = 7').compilesTo('{42 = 7}');
         });
         test('not equal', () => {
-            expect((0, test_translator_1.expr) `42 != 7`).toTranslate();
+            expect('42 != 7').compilesTo('{42 != 7}');
         });
         test('greater than', () => {
-            expect((0, test_translator_1.expr) `42 > 7`).toTranslate();
+            expect('42 > 7').compilesTo('{42 > 7}');
         });
         test('greater than or equal', () => {
-            expect((0, test_translator_1.expr) `42 >= 7`).toTranslate();
+            expect('42 >= 7').compilesTo('{42 >= 7}');
         });
         test('less than or equal', () => {
-            expect((0, test_translator_1.expr) `42 <= 7`).toTranslate();
+            expect('42 <= 7').compilesTo('{42 <= 7}');
         });
         test('less than', () => {
-            expect((0, test_translator_1.expr) `42 < 7`).toTranslate();
+            expect('42 < 7').compilesTo('{42 < 7}');
         });
         test('match', () => {
-            expect((0, test_translator_1.expr) `'forty-two' ~ 'fifty-four'`).toTranslate();
+            expect("'forty-two' ~ 'fifty-four'").compilesTo('{"forty-two" like "fifty-four"}');
         });
         test('not match', () => {
-            expect((0, test_translator_1.expr) `'forty-two' !~ 'fifty-four'`).toTranslate();
+            expect("'forty-two' !~ 'fifty-four'").compilesTo('{"forty-two" !like "fifty-four"}');
         });
-        test('apply', () => {
-            expect((0, test_translator_1.expr) `'forty-two' ? 'fifty-four'`).toTranslate();
+        test('apply as equality', () => {
+            expect("'forty-two' ? 'fifty-four'").compilesTo('{"forty-two" = "fifty-four"}');
         });
         test('not', () => {
-            expect((0, test_translator_1.expr) `not true`).toTranslate();
+            expect('not true').compilesTo('{not true}');
         });
         test('and', () => {
-            expect((0, test_translator_1.expr) `true and false`).toTranslate();
+            expect('true and false').compilesTo('{true and false}');
         });
         test('or', () => {
-            expect((0, test_translator_1.expr) `true or false`).toTranslate();
+            expect('true or false').compilesTo('{true or false}');
         });
         test('null-check (??)', () => {
-            expect((0, test_translator_1.expr) `ai ?? 7`).toTranslate();
+            expect('ai ?? 7').compilesTo('{ai coalesce 7}');
         });
         test('coalesce type mismatch', () => {
             expect(new test_translator_1.BetaExpression('ai ?? @2003')).translationToFailWith('Mismatched types for coalesce (number, date)');
@@ -175,37 +140,16 @@ describe('expressions', () => {
             expect(new test_translator_1.BetaExpression('days(ad to ats)')).translationToFailWith('Cannot measure from date to timestamp');
         });
         test('compare to truncation uses straight comparison', () => {
-            const compare = (0, test_translator_1.expr) `ad = ad.quarter`;
-            expect(compare).toTranslate();
-            const compare_expr = compare.translator.generated().value;
-            expect(exprToString(compare_expr)).toEqual('A={trunc}');
+            expect('ad = ad.quarter').compilesTo('{ad = {timeTrunc-quarter ad}}');
         });
         test('compare to granular result expression uses straight comparison', () => {
-            const compare = (0, test_translator_1.expr) `ad = ad.quarter + 1`;
-            expect(compare).toTranslate();
-            const compare_expr = compare.translator.generated().value;
-            expect(exprToString(compare_expr)).toEqual('A={delta}');
+            expect('ad = ad.quarter + 1').compilesTo('{ad = {+quarter {timeTrunc-quarter ad} 1}}');
         });
         test('apply granular-truncation uses range', () => {
-            const compare = (0, test_translator_1.expr) `ad ? ad.quarter`;
-            expect(compare).toTranslate();
-            const compare_expr = compare.translator.generated().value;
-            expect(exprToString(compare_expr)).toEqual('(A>={trunc})and(A<{delta})');
+            expect('ad ? ad.quarter').compilesTo('{{ad >= {timeTrunc-quarter ad}} and {ad < {+quarter {timeTrunc-quarter ad} 1}}}');
         });
         test('apply granular-literal alternation uses all literals for range', () => {
-            const compare = (0, test_translator_1.expr) `ad ? @2020 | @2022`;
-            expect(compare).toTranslate();
-            const compare_expr = compare.translator.generated().value;
-            expect(exprToString(compare_expr)).toEqual('((A>={timeLiteral})and(A<{timeLiteral}))or((A>={timeLiteral})and(A<{timeLiteral}))');
-        });
-        // this should use range, but it uses = and alternations are
-        // kind of needing help so this is a placeholder for
-        // future work
-        test.skip('apply granular-result alternation uses range', () => {
-            const compare = (0, test_translator_1.expr) `ad ? ad.year | ad.month`;
-            expect(compare).toTranslate();
-            const compare_expr = compare.translator.generated().value;
-            expect(exprToString(compare_expr)).toEqual('((A>=B)and(A<C))or((A>=D)and(A<E))');
+            expect('ad ? @2020 | @2022').compilesTo('{{{ad >= @2020-01-01} and {ad < @2021-01-01}} or {{ad >= @2022-01-01} and {ad < @2023-01-01}}}');
         });
         test('comparison promotes date literal to timestamp', () => {
             expect((0, test_translator_1.expr) `@2001 = ats`).toTranslate();
@@ -220,6 +164,68 @@ describe('expressions', () => {
         test('apply with parens', () => {
             expect((0, test_translator_1.expr) `ai ? (> 1 & < 100)`).toTranslate();
         });
+        describe('sql friendly warnings', () => {
+            test('is null with warning', () => {
+                const warnSrc = (0, test_translator_1.expr) `ai is null`;
+                expect(warnSrc).toTranslateWithWarnings("Use '= NULL' to check for NULL instead of 'IS NULL'");
+                expect(warnSrc).compilesTo('{is-null ai}');
+                const warning = warnSrc.translator.problems()[0];
+                expect(warning.replacement).toEqual('ai = null');
+            });
+            test('is not null with warning', () => {
+                const warnSrc = (0, test_translator_1.expr) `ai is not null`;
+                expect(warnSrc).toTranslateWithWarnings("Use '!= NULL' to check for NULL instead of 'IS NOT NULL'");
+                expect(warnSrc).compilesTo('{is-not-null ai}');
+                const warning = warnSrc.translator.problems()[0];
+                expect(warning.replacement).toEqual('ai != null');
+            });
+            test('like with warning', () => {
+                const warnSrc = (0, test_translator_1.expr) `astr like 'a'`;
+                expect(warnSrc).toTranslateWithWarnings("Use Malloy operator '~' instead of 'LIKE'");
+                expect(warnSrc).compilesTo('{astr like "a"}');
+                const warning = warnSrc.translator.problems()[0];
+                expect(warning.replacement).toEqual("astr ~ 'a'");
+            });
+            test('NOT LIKE with warning', () => {
+                const warnSrc = (0, test_translator_1.expr) `astr not like 'a'`;
+                expect(warnSrc).toTranslateWithWarnings("Use Malloy operator '!~' instead of 'NOT LIKE'");
+                expect(warnSrc).compilesTo('{astr !like "a"}');
+                const warning = warnSrc.translator.problems()[0];
+                expect(warning.replacement).toEqual("astr !~ 'a'");
+            });
+            test('is is-null in a model', () => {
+                const isNullSrc = (0, test_translator_1.model) `source: xa is a extend { dimension: x1 is astr is null }`;
+                expect(isNullSrc).toTranslateWithWarnings("Use '= NULL' to check for NULL instead of 'IS NULL'");
+            });
+            test('is not-null in a model', () => {
+                const isNullSrc = (0, test_translator_1.model) `source: xa is a extend { dimension: x1 is not null }`;
+                expect(isNullSrc).toTranslate();
+            });
+            test('is not-null is in a model', () => {
+                const isNullSrc = (0, test_translator_1.model) `source: xa is a extend { dimension: x1 is not null is null }`;
+                expect(isNullSrc).toTranslateWithWarnings("Use '= NULL' to check for NULL instead of 'IS NULL'");
+                const warning = isNullSrc.translator.problems()[0];
+                expect(warning.replacement).toEqual('null = null');
+            });
+            test('x is expr y is not null', () => {
+                const isNullSrc = (0, test_translator_1.model) `source: xa is a extend { dimension: x is 1 y is not null }`;
+                expect(isNullSrc).toTranslate();
+                const xaModel = isNullSrc.translator.translate().translated;
+                const xa = (0, test_translator_1.getExplore)(xaModel.modelDef, 'xa');
+                const x = (0, test_translator_1.getFieldDef)(xa, 'x');
+                expect(x).toMatchObject({ e: { node: 'numberLiteral' } });
+                const y = (0, test_translator_1.getFieldDef)(xa, 'y');
+                expect(y).toMatchObject({ e: { node: 'not' } });
+            });
+            test('not null::number', () => {
+                const notNull = (0, test_translator_1.expr) `not null::number`;
+                expect(notNull).translationToFailWith("'not' Can't use type number");
+            });
+            test('(not null)::number', () => {
+                const notNull = (0, test_translator_1.expr) `(not null)::number`;
+                expect(notNull).toTranslate();
+            });
+        });
     });
     test('filtered measure', () => {
         expect((0, test_translator_1.expr) `acount {where: astr = 'why?' }`).toTranslate();
@@ -818,11 +824,7 @@ describe('expressions', () => {
         });
     });
     test('paren and applied div', () => {
-        const one34 = (0, test_translator_1.expr) `1+(3/4)`;
-        expect(one34).toTranslate();
-        const exprVal = one34.translator.generated();
-        const exprE = exprVal.value;
-        expect(exprToString(exprE)).toEqual('{numberLiteral}+({numberLiteral}/{numberLiteral})');
+        expect('1+(3/4)').compilesTo('{1 + ({3 / 4})}');
     });
     test.each([
         ['ats', 'timestamp'],

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

@@ -14,9 +14,7 @@ declare global {
              *
              * 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.
+             * X can be a MarkedSource, a string, or a model.
              */
             toParse(): R;
             /**
@@ -25,9 +23,7 @@ declare global {
              * 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.
+             * X can be a MarkedSource, a string, or a model.
              */
             toTranslate(): R;
             /**
@@ -56,6 +52,17 @@ declare global {
              */
             translationToFailWith(...expectedErrors: ProblemSpec[]): R;
             isLocationIn(at: DocumentLocation, txt: string): R;
+            /**
+             * expect(X).compilesTo('expression-string')
+             *
+             * X should be a string or an expr`string` or a BetaExpression
+             *
+             * The string is compiled, and the compiled string is then "translated" into an expression,
+             * which can be used to check that the compiler did the right thing.
+             *
+             * Warnings are ignored, so need to be checked seperately
+             */
+            compilesTo(exprString: string): R;
         }
     }
 }

package/dist/lang/test/parse-expects.js

@@ -23,6 +23,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+const model_1 = require("../../model");
 const test_translator_1 = require("./test-translator");
 function rangeToStr(loc) {
     if (loc) {
@@ -134,6 +135,51 @@ function xlated(tt) {
     tt.translate();
     return checkForNeededs(tt);
 }
+function eToStr(e, symbols) {
+    function subExpr(e) {
+        return eToStr(e, symbols);
+    }
+    switch (e.node) {
+        case 'field': {
+            const ref = e.path.join('.');
+            if (symbols) {
+                if (symbols[ref] === undefined) {
+                    const nSyms = Object.keys(symbols).length;
+                    symbols[ref] = String.fromCharCode('A'.charCodeAt(0) + nSyms);
+                }
+                return symbols[ref];
+            }
+            else {
+                return ref;
+            }
+        }
+        case '()':
+            return `(${subExpr(e.e)})`;
+        case 'numberLiteral':
+            return `${e.literal}`;
+        case 'stringLiteral':
+            return `"${e.literal}"`;
+        case 'timeLiteral':
+            return `@${e.literal}`;
+        case 'trunc':
+            return `{timeTrunc-${e.units} ${subExpr(e.e)}}`;
+        case 'delta':
+            return `{${e.op}${e.units} ${subExpr(e.kids.base)} ${subExpr(e.kids.delta)}}`;
+        case 'true':
+        case 'false':
+            return e.node;
+    }
+    if ((0, model_1.exprHasKids)(e) && e.kids['left'] && e.kids['right']) {
+        return `{${subExpr(e.kids['left'])} ${e.node} ${subExpr(e.kids['right'])}}`;
+    }
+    else if ((0, model_1.exprHasE)(e)) {
+        return `{${e.node} ${subExpr(e.e)}}`;
+    }
+    else if ((0, model_1.exprIsLeaf)(e)) {
+        return `{${e.node}}`;
+    }
+    return `{?${e.node}}`;
+}
 expect.extend({
     toParse: function (tx) {
         const x = xlator(tx);
@@ -178,6 +224,40 @@ expect.extend({
             message: () => errMsg,
         };
     },
+    compilesTo: function (tx, expr) {
+        let bx;
+        if (typeof tx === 'string') {
+            bx = new test_translator_1.BetaExpression(tx);
+        }
+        else {
+            const x = xlator(tx);
+            if (x instanceof test_translator_1.BetaExpression) {
+                bx = x;
+            }
+            else {
+                return {
+                    pass: false,
+                    message: () => 'Must pass expr`EXPRESSION` to expect(EXPRSSION).compilesTo()',
+                };
+            }
+        }
+        bx.compile();
+        // Only report errors, callers will need to test for warnings
+        if (bx.logger.hasErrors()) {
+            return {
+                message: () => `Translation problems:\n${bx.prettyErrors()}`,
+                pass: false,
+            };
+        }
+        const badRefs = checkForNeededs(bx);
+        if (!badRefs.pass) {
+            return badRefs;
+        }
+        const rcvExpr = eToStr(bx.generated().value, undefined);
+        const pass = this.equals(rcvExpr, expr);
+        const msg = pass ? `Matched: ${rcvExpr}` : this.utils.diff(expr, rcvExpr);
+        return { pass, message: () => `${msg}` };
+    },
 });
 function checkForProblems(context, expectCompiles, s, defaultSeverity, ...msgs) {
     var _a;

package/dist/lang/test/test-translator.d.ts

@@ -1,4 +1,4 @@
-import { DocumentLocation, FieldDef, ModelDef, NamedModelObject, PipeSegment, Query, QueryFieldDef, SQLBlockSource, SQLBlockStructDef, StructDef, TurtleDef } from '../../model/malloy_types';
+import { DocumentLocation, Expr, FieldDef, ModelDef, NamedModelObject, PipeSegment, Query, QueryFieldDef, SQLBlockSource, SQLBlockStructDef, StructDef, TurtleDef } from '../../model/malloy_types';
 import { MalloyElement } from '../ast';
 import { NameSpace } from '../ast/types/name-space';
 import { ModelEntry } from '../ast/types/model-entry';
@@ -72,4 +72,5 @@ export declare function makeModelFunc(options: {
 }): (unmarked: TemplateStringsArray, ...marked: string[]) => HasTranslator<TestTranslator>;
 export declare function markSource(unmarked: TemplateStringsArray, ...marked: string[]): MarkedSource;
 export declare function getSelectOneStruct(sqlBlock: SQLBlockSource): SQLBlockStructDef;
+export declare function exprToString(e: Expr, symbols?: Record<string, string>): string;
 export {};

package/dist/lang/test/test-translator.js

@@ -23,7 +23,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSelectOneStruct = exports.markSource = exports.makeModelFunc = exports.model = exports.expr = exports.getJoinField = exports.getQueryField = exports.getQueryFieldDef = exports.getFieldDef = exports.getModelQuery = exports.getExplore = exports.BetaExpression = exports.TestTranslator = exports.TestChildTranslator = exports.aTableDef = exports.pretty = void 0;
+exports.exprToString = exports.getSelectOneStruct = exports.markSource = exports.makeModelFunc = exports.model = exports.expr = exports.getJoinField = exports.getQueryField = exports.getQueryFieldDef = exports.getFieldDef = exports.getModelQuery = exports.getExplore = exports.BetaExpression = exports.TestTranslator = exports.TestChildTranslator = exports.aTableDef = exports.pretty = void 0;
 const util_1 = require("util");
 const malloy_types_1 = require("../../model/malloy_types");
 const ast_1 = require("../ast");
@@ -549,4 +549,44 @@ function getSelectOneStruct(sqlBlock) {
     };
 }
 exports.getSelectOneStruct = getSelectOneStruct;
+function exprToString(e, symbols = {}) {
+    function subExpr(e) {
+        const x = exprToString(e, symbols);
+        return x[0] === '{' || (0, malloy_types_1.exprIsLeaf)(e) ? x : `(${x})`;
+    }
+    switch (e.node) {
+        case '=':
+        case '>':
+        case '>=':
+        case '<':
+        case '<=':
+        case '+':
+        case '-':
+        case '*':
+        case '/':
+        case '%':
+            return `${subExpr(e.kids.left)}${e.node}${subExpr(e.kids.right)}`;
+        case 'and':
+        case 'like':
+        case '!like':
+        case 'or':
+            return `${subExpr(e.kids.left)} ${e.node} ${subExpr(e.kids.right)}`;
+        case 'field': {
+            const ref = e.path.join('.');
+            if (symbols[ref] === undefined) {
+                const nSyms = Object.keys(symbols).length;
+                symbols[ref] = String.fromCharCode('A'.charCodeAt(0) + nSyms);
+            }
+            return symbols[ref];
+        }
+        case '()':
+            return `(${subExpr(e.e)})`;
+        case 'not':
+            return `not(${exprToString(e.e, symbols)})`;
+        case 'coalesce':
+            return `${subExpr(e.kids.left)} ?? ${subExpr(e.kids.right)}`;
+    }
+    return `{${e.node}}`;
+}
+exports.exprToString = exprToString;
 //# sourceMappingURL=test-translator.js.map