@malloydata/malloy 0.0.22-dev230117232218 → 0.0.22-dev230119193053

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

@@ -22,215 +22,17 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pick = exports.PickWhen = exports.Range = exports.TopBy = exports.ExprCast = exports.isCastType = exports.ExprFilter = exports.ExprCase = exports.WhenClause = exports.ExprUngroup = exports.ExprSum = exports.ExprAvg = exports.ExprCount = exports.ExprCountDistinct = exports.ExprMax = exports.ExprMin = exports.ExprAlternationTree = exports.ExprMulDiv = exports.ExprAddSub = exports.BinaryNumeric = exports.ExprMinus = exports.ExprParens = exports.ExprNULL = exports.ExprIdReference = exports.ExprLogicalOp = exports.BinaryBoolean = exports.Boolean = exports.ExprNot = exports.ExprTime = exports.ExprRegEx = exports.ExprNumber = exports.ExprString = exports.TypeMistmatch = exports.FieldDeclaration = exports.ConstantSubExpression = exports.ExpressionDef = void 0;
+exports.Apply = exports.Pick = exports.PickWhen = exports.TopBy = exports.ExprCast = exports.isCastType = exports.ExprFilter = exports.ExprCase = exports.WhenClause = exports.ExprUngroup = exports.ExprSum = exports.ExprAvg = exports.ExprCount = exports.ExprCountDistinct = exports.ExprMax = exports.ExprMin = exports.ExprAlternationTree = exports.ExprMulDiv = exports.ExprAddSub = exports.BinaryNumeric = exports.ExprMinus = exports.ExprParens = exports.ExprNULL = exports.ExprIdReference = exports.ExprLogicalOp = exports.Boolean = exports.ExprNot = exports.ExprRegEx = exports.ExprNumber = exports.ExprString = void 0;
 /*
  ** This file is the general framework for expression nodes and expression
  ** evaluation.
  */
 const malloy_types_1 = require("../../model/malloy_types");
-const field_space_1 = require("../field-space");
-const index_1 = require("./index");
+const ast_main_1 = require("./ast-main");
+const ast_types_1 = require("./ast-types");
 const apply_expr_1 = require("./apply-expr");
-const space_field_1 = require("../space-field");
 const time_utils_1 = require("./time-utils");
-/**
- * Root node for any element in an expression. These essentially
- * create a sub-tree in the larger AST. Expression nodes know
- * how to write themselves as SQL (or rather, generate the
- * template for SQL required by the query writer)
- */
-class ExpressionDef extends index_1.MalloyElement {
-    constructor() {
-        super(...arguments);
-        this.legalChildTypes = index_1.FT.anyAtomicT;
-    }
-    granular() {
-        return false;
-    }
-    /**
-     * Some operators want to give the right hand value a chance to
-     * rewrite itself. This requests a translation for a rewrite,
-     * or returns undefined if that request should be denied.
-     * @param fs FieldSpace
-     * @returns Translated expression or undefined
-     */
-    requestExpression(fs) {
-        return this.getExpression(fs);
-    }
-    defaultFieldName() {
-        return undefined;
-    }
-    /**
-     * Check an expression for type compatibility
-     * @param _eNode currently unused, will be used to get error location
-     * @param eVal ...list of expressions that must match legalChildTypes
-     */
-    typeCheck(eNode, eVal) {
-        if (!index_1.FT.in(eVal, this.legalChildTypes)) {
-            eNode.log(`'${this.elementType}' Can't use type ${index_1.FT.inspect(eVal)}`);
-            return false;
-        }
-        return true;
-    }
-    /**
-     * This is the operation which makes partial comparison and value trees work
-     * The default implemention merely constructs LEFT OP RIGHT, but specialized
-     * nodes like alternation trees or or partial comparison can control how
-     * the appplication gets generated
-     * @param fs The symbol table
-     * @param op The operator being applied
-     * @param expr The "other" (besdies 'this') value
-     * @returns The translated expression
-     */
-    apply(fs, op, left) {
-        return (0, apply_expr_1.applyBinary)(fs, left, op, this);
-    }
-}
-exports.ExpressionDef = ExpressionDef;
-class DollarReference extends ExpressionDef {
-    constructor(refType) {
-        super();
-        this.refType = refType;
-        this.elementType = "$";
-    }
-    getExpression(_fs) {
-        return {
-            dataType: this.refType,
-            value: [{ type: "applyVal" }],
-            expressionType: "scalar",
-        };
-    }
-}
-class ConstantFieldSpace {
-    constructor() {
-        this.type = "fieldSpace";
-    }
-    structDef() {
-        throw new Error("ConstantFieldSpace cannot generate a structDef");
-    }
-    emptyStructDef() {
-        throw new Error("ConstantFieldSpace cannot generate a structDef");
-    }
-    lookup(_name) {
-        return {
-            error: "Only constants allowed in parameter expressions",
-            found: undefined,
-        };
-    }
-    dialectObj() {
-        return undefined;
-    }
-    whenComplete(step) {
-        step();
-    }
-}
-class ConstantSubExpression extends ExpressionDef {
-    constructor(expr) {
-        super({ expr });
-        this.expr = expr;
-        this.elementType = "constantExpression";
-    }
-    getExpression(_fs) {
-        return this.constantValue();
-    }
-    get constantFs() {
-        if (!this.cfs) {
-            this.cfs = new ConstantFieldSpace();
-        }
-        return this.cfs;
-    }
-    constantValue() {
-        return this.expr.getExpression(this.constantFs);
-    }
-    constantCondition(type) {
-        const compareAndContrast = new index_1.ExprCompare(new DollarReference(type), "=", this.expr);
-        const application = compareAndContrast.getExpression(this.constantFs);
-        return { ...application, value: (0, index_1.compressExpr)(application.value) };
-    }
-    apply(fs, op, expr) {
-        return this.expr.apply(fs, op, expr);
-    }
-    requestExpression(fs) {
-        return this.expr.requestExpression(fs);
-    }
-}
-exports.ConstantSubExpression = ConstantSubExpression;
-class FieldDeclaration extends index_1.MalloyElement {
-    constructor(expr, defineName, exprSrc) {
-        super({ expr });
-        this.expr = expr;
-        this.defineName = defineName;
-        this.exprSrc = exprSrc;
-        this.elementType = "fieldDeclaration";
-    }
-    fieldDef(fs, exprName) {
-        /*
-         * In an explore we cannot reference the thing we are defining, you need
-         * to use rename. In a query, the output space is a new thing, and expressions
-         * can reference the outer value in order to make a value with the new name,
-         * and it feels wrong that this is HERE and not somehow in the QueryOperation.
-         * For now, this stops the stack overflow, and passes all tests, but I think
-         * a refactor of QueryFieldSpace might someday be the place where this should
-         * happen.
-         */
-        return this.queryFieldDef(new field_space_1.DefSpace(fs, this), exprName);
-    }
-    queryFieldDef(exprFS, exprName) {
-        let exprValue;
-        try {
-            exprValue = this.expr.getExpression(exprFS);
-        }
-        catch (error) {
-            this.log(`Cannot define '${exprName}', ${error.message}`);
-            return {
-                name: `error_defining_${exprName}`,
-                type: "string",
-            };
-        }
-        const compressValue = (0, index_1.compressExpr)(exprValue.value);
-        const retType = exprValue.dataType;
-        if ((0, malloy_types_1.isAtomicFieldType)(retType)) {
-            const template = {
-                name: exprName,
-                type: retType,
-                location: this.location,
-            };
-            if (compressValue.length > 0) {
-                template.e = compressValue;
-            }
-            if (exprValue.expressionType) {
-                template.expressionType = exprValue.expressionType;
-            }
-            if (this.exprSrc) {
-                template.code = this.exprSrc;
-            }
-            // TODO this should work for dates too
-            if ((0, index_1.isGranularResult)(exprValue) && template.type === "timestamp") {
-                template.timeframe = exprValue.timeframe;
-            }
-            return template;
-        }
-        const circularDef = exprFS instanceof field_space_1.DefSpace && exprFS.foundCircle;
-        if (!circularDef) {
-            if (exprValue.dataType == "unknown") {
-                this.log(`Cannot define '${exprName}', value has unknown type`);
-            }
-            else {
-                const badType = index_1.FT.inspect(exprValue);
-                this.log(`Cannot define '${exprName}', unexpected type: ${badType}`);
-            }
-        }
-        return {
-            name: `error_defining_${exprName}`,
-            type: "string",
-        };
-    }
-}
-exports.FieldDeclaration = FieldDeclaration;
-class TypeMistmatch extends Error {
-}
-exports.TypeMistmatch = TypeMistmatch;
-class ExprString extends ExpressionDef {
+class ExprString extends ast_main_1.ExpressionDef {
     constructor(src) {
         super();
         this.elementType = "string literal";
@@ -240,7 +42,7 @@ class ExprString extends ExpressionDef {
     }
     getExpression(_fs) {
         return {
-            ...index_1.FT.stringT,
+            ...ast_types_1.FT.stringT,
             value: [
                 {
                     type: "dialect",
@@ -252,7 +54,7 @@ class ExprString extends ExpressionDef {
     }
 }
 exports.ExprString = ExprString;
-class ExprNumber extends ExpressionDef {
+class ExprNumber extends ast_main_1.ExpressionDef {
     constructor(n) {
         super();
         this.n = n;
@@ -262,11 +64,11 @@ class ExprNumber extends ExpressionDef {
         return this.constantExpression();
     }
     constantExpression() {
-        return { ...index_1.FT.numberT, value: [this.n] };
+        return { ...ast_types_1.FT.numberT, value: [this.n] };
     }
 }
 exports.ExprNumber = ExprNumber;
-class ExprRegEx extends ExpressionDef {
+class ExprRegEx extends ast_main_1.ExpressionDef {
     constructor(regex) {
         super();
         this.regex = regex;
@@ -281,40 +83,7 @@ class ExprRegEx extends ExpressionDef {
     }
 }
 exports.ExprRegEx = ExprRegEx;
-class ExprTime extends ExpressionDef {
-    constructor(timeType, value, expressionType = "scalar") {
-        super();
-        this.elementType = "timestampOrDate";
-        this.elementType = timeType;
-        this.translationValue = {
-            dataType: timeType,
-            expressionType,
-            value: typeof value === "string" ? [value] : value,
-        };
-    }
-    getExpression(_fs) {
-        return this.translationValue;
-    }
-    static fromValue(timeType, expr) {
-        let value = expr.value;
-        if (timeType != expr.dataType) {
-            const toTs = {
-                type: "dialect",
-                function: "cast",
-                safe: false,
-                dstType: timeType,
-                expr: expr.value,
-            };
-            if ((0, malloy_types_1.isTimeFieldType)(expr.dataType)) {
-                toTs.srcType = expr.dataType;
-            }
-            value = (0, index_1.compressExpr)([toTs]);
-        }
-        return new ExprTime(timeType, value, expr.expressionType);
-    }
-}
-exports.ExprTime = ExprTime;
-class Unary extends ExpressionDef {
+class Unary extends ast_main_1.ExpressionDef {
     constructor(expr) {
         super({ expr });
         this.expr = expr;
@@ -324,7 +93,7 @@ class ExprNot extends Unary {
     constructor(expr) {
         super(expr);
         this.elementType = "not";
-        this.legalChildTypes = [index_1.FT.boolT, index_1.FT.nullT];
+        this.legalChildTypes = [ast_types_1.FT.boolT, ast_types_1.FT.nullT];
     }
     getExpression(fs) {
         const notThis = this.expr.getExpression(fs);
@@ -335,53 +104,30 @@ class ExprNot extends Unary {
                 value: (0, apply_expr_1.nullsafeNot)(notThis.value),
             };
         }
-        return (0, index_1.errorFor)("not requires boolean");
+        return (0, ast_types_1.errorFor)("not requires boolean");
     }
 }
 exports.ExprNot = ExprNot;
-class Boolean extends ExpressionDef {
+class Boolean extends ast_main_1.ExpressionDef {
     constructor(value) {
         super();
         this.value = value;
         this.elementType = "boolean literal";
     }
     getExpression() {
-        return { ...index_1.FT.boolT, value: [this.value] };
+        return { ...ast_types_1.FT.boolT, value: [this.value] };
     }
 }
 exports.Boolean = Boolean;
-class BinaryBoolean extends ExpressionDef {
-    constructor(left, op, right) {
-        super({ left, right });
-        this.left = left;
-        this.op = op;
-        this.right = right;
-        this.elementType = "abstract boolean binary";
-        this.legalChildTypes = [index_1.FT.boolT];
-    }
-    getExpression(fs) {
-        const left = this.left.getExpression(fs);
-        const right = this.right.getExpression(fs);
-        if (this.typeCheck(this.left, left) && this.typeCheck(this.right, right)) {
-            return {
-                dataType: "boolean",
-                expressionType: (0, malloy_types_1.maxExpressionType)(left.expressionType, right.expressionType),
-                value: (0, index_1.compose)(left.value, this.op, right.value),
-            };
-        }
-        return (0, index_1.errorFor)("logial required boolean");
-    }
-}
-exports.BinaryBoolean = BinaryBoolean;
-class ExprLogicalOp extends BinaryBoolean {
+class ExprLogicalOp extends ast_main_1.BinaryBoolean {
     constructor() {
         super(...arguments);
         this.elementType = "logical operator";
-        this.legalChildTypes = [index_1.FT.boolT, { ...index_1.FT.boolT, aggregate: true }];
+        this.legalChildTypes = [ast_types_1.FT.boolT, { ...ast_types_1.FT.boolT, aggregate: true }];
     }
 }
 exports.ExprLogicalOp = ExprLogicalOp;
-class ExprIdReference extends ExpressionDef {
+class ExprIdReference extends ast_main_1.ExpressionDef {
     constructor(fieldReference) {
         super();
         this.fieldReference = fieldReference;
@@ -402,11 +148,11 @@ class ExprIdReference extends ExpressionDef {
             return { dataType, expressionType, value };
         }
         this.log(def.error);
-        return (0, index_1.errorFor)(def.error);
+        return (0, ast_types_1.errorFor)(def.error);
     }
     apply(fs, op, expr) {
         const entry = this.fieldReference.getField(fs).found;
-        if (entry instanceof space_field_1.SpaceParam) {
+        if (entry instanceof ast_main_1.SpaceParam) {
             const cParam = entry.parameter();
             if ((0, malloy_types_1.isConditionParameter)(cParam)) {
                 const lval = expr.getExpression(fs);
@@ -427,7 +173,7 @@ class ExprIdReference extends ExpressionDef {
     }
 }
 exports.ExprIdReference = ExprIdReference;
-class ExprNULL extends ExpressionDef {
+class ExprNULL extends ast_main_1.ExpressionDef {
     constructor() {
         super(...arguments);
         this.elementType = "NULL";
@@ -441,7 +187,7 @@ class ExprNULL extends ExpressionDef {
     }
 }
 exports.ExprNULL = ExprNULL;
-class ExprParens extends ExpressionDef {
+class ExprParens extends ast_main_1.ExpressionDef {
     constructor(expr) {
         super({ expr });
         this.expr = expr;
@@ -456,12 +202,12 @@ class ExprParens extends ExpressionDef {
     }
 }
 exports.ExprParens = ExprParens;
-class ExprMinus extends ExpressionDef {
+class ExprMinus extends ast_main_1.ExpressionDef {
     constructor(expr) {
         super({ expr });
         this.expr = expr;
         this.elementType = "unary minus";
-        this.legalChildTypes = [index_1.FT.numberT];
+        this.legalChildTypes = [ast_types_1.FT.numberT];
     }
     getExpression(fs) {
         const expr = this.expr.getExpression(fs);
@@ -471,18 +217,18 @@ class ExprMinus extends ExpressionDef {
             }
             return { ...expr, value: ["-", ...expr.value] };
         }
-        return (0, index_1.errorFor)("negate requires number");
+        return (0, ast_types_1.errorFor)("negate requires number");
     }
 }
 exports.ExprMinus = ExprMinus;
-class BinaryNumeric extends ExpressionDef {
+class BinaryNumeric extends ast_main_1.ExpressionDef {
     constructor(left, op, right) {
         super({ left, right });
         this.left = left;
         this.op = op;
         this.right = right;
         this.elementType = "numeric binary abstract";
-        this.legalChildTypes = [index_1.FT.numberT];
+        this.legalChildTypes = [ast_types_1.FT.numberT];
     }
     getExpression(fs) {
         return this.right.apply(fs, this.op, this.left);
@@ -503,7 +249,7 @@ class ExprMulDiv extends BinaryNumeric {
     }
 }
 exports.ExprMulDiv = ExprMulDiv;
-class ExprAlternationTree extends BinaryBoolean {
+class ExprAlternationTree extends ast_main_1.BinaryBoolean {
     constructor(left, op, right) {
         super(left, op, right);
         this.elementType = "alternation";
@@ -515,7 +261,7 @@ class ExprAlternationTree extends BinaryBoolean {
         return {
             dataType: "boolean",
             expressionType: (0, malloy_types_1.maxExpressionType)(choice1.expressionType, choice2.expressionType),
-            value: (0, index_1.compose)(choice1.value, this.op === "&" ? "and" : "or", choice2.value),
+            value: (0, ast_types_1.compose)(choice1.value, this.op === "&" ? "and" : "or", choice2.value),
         };
     }
     requestExpression(_fs) {
@@ -523,15 +269,15 @@ class ExprAlternationTree extends BinaryBoolean {
     }
     getExpression(_fs) {
         this.log(`Alternation tree has no value`);
-        return (0, index_1.errorFor)("no value from alternation tree");
+        return (0, ast_types_1.errorFor)("no value from alternation tree");
     }
 }
 exports.ExprAlternationTree = ExprAlternationTree;
-class ExprAggregateFunction extends ExpressionDef {
+class ExprAggregateFunction extends ast_main_1.ExpressionDef {
     constructor(func, expr) {
         super();
         this.func = func;
-        this.legalChildTypes = [index_1.FT.numberT];
+        this.legalChildTypes = [ast_types_1.FT.numberT];
         this.elementType = func;
         if (expr) {
             this.expr = expr;
@@ -558,20 +304,20 @@ class ExprAggregateFunction extends ExpressionDef {
                     structPath = this.source.sourceString;
                 }
                 else {
-                    if (!(sourceFoot instanceof space_field_1.StructSpaceField)) {
+                    if (!(sourceFoot instanceof ast_main_1.StructSpaceField)) {
                         this.log(`Aggregate source cannot be a ${footType.type}`);
-                        return (0, index_1.errorFor)(`Aggregate source cannot be a ${footType.type}`);
+                        return (0, ast_types_1.errorFor)(`Aggregate source cannot be a ${footType.type}`);
                     }
                 }
             }
             else {
                 this.log(`Reference to undefined value ${this.source.refString}`);
-                return (0, index_1.errorFor)(`Reference to undefined value ${this.source.refString}`);
+                return (0, ast_types_1.errorFor)(`Reference to undefined value ${this.source.refString}`);
             }
         }
         if (exprVal === undefined) {
             this.log("Missing expression for aggregate function");
-            return (0, index_1.errorFor)("agggregate without expression");
+            return (0, ast_types_1.errorFor)("agggregate without expression");
         }
         if (this.typeCheck(this.expr || this, {
             ...exprVal,
@@ -591,13 +337,13 @@ class ExprAggregateFunction extends ExpressionDef {
                 value: [f],
             };
         }
-        return (0, index_1.errorFor)("aggregate type check");
+        return (0, ast_types_1.errorFor)("aggregate type check");
     }
 }
 class ExprMin extends ExprAggregateFunction {
     constructor(expr) {
         super("min", expr);
-        this.legalChildTypes = [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT];
+        this.legalChildTypes = [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT];
     }
     returns(forExpression) {
         return forExpression.dataType;
@@ -607,7 +353,7 @@ exports.ExprMin = ExprMin;
 class ExprMax extends ExprAggregateFunction {
     constructor(expr) {
         super("max", expr);
-        this.legalChildTypes = [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT];
+        this.legalChildTypes = [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT];
     }
     returns(forExpression) {
         return forExpression.dataType;
@@ -617,7 +363,7 @@ exports.ExprMax = ExprMax;
 class ExprCountDistinct extends ExprAggregateFunction {
     constructor(expr) {
         super("count_distinct", expr);
-        this.legalChildTypes = [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT];
+        this.legalChildTypes = [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT];
     }
 }
 exports.ExprCountDistinct = ExprCountDistinct;
@@ -686,13 +432,13 @@ class ExprSum extends ExprAsymmetric {
     }
 }
 exports.ExprSum = ExprSum;
-class ExprUngroup extends ExpressionDef {
+class ExprUngroup extends ast_main_1.ExpressionDef {
     constructor(control, expr, fields) {
         super({ expr, fields });
         this.control = control;
         this.expr = expr;
         this.fields = fields;
-        this.legalChildTypes = index_1.FT.anyAtomicT;
+        this.legalChildTypes = ast_types_1.FT.anyAtomicT;
         this.elementType = "ungroup";
     }
     returns(_forExpression) {
@@ -702,18 +448,18 @@ class ExprUngroup extends ExpressionDef {
         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, index_1.errorFor)("ungrouped scalar");
+            return (0, ast_types_1.errorFor)("ungrouped scalar");
         }
         const ungroup = { type: this.control, e: exprVal.value };
         if (this.typeCheck(this.expr, { ...exprVal, expressionType: "scalar" })) {
             if (this.fields.length > 0) {
                 let qs = fs;
-                if (fs instanceof field_space_1.DefSpace) {
+                if (fs instanceof ast_main_1.DefSpace) {
                     qs = fs.realFS;
                 }
-                if (!(qs instanceof field_space_1.QuerySpace)) {
+                if (!(qs instanceof ast_main_1.QuerySpace)) {
                     this.log(`${this.control}() must be in a query -- weird internal error`);
-                    return (0, index_1.errorFor)("ungroup query check");
+                    return (0, ast_types_1.errorFor)("ungroup query check");
                 }
                 const output = qs.result;
                 const dstFields = [];
@@ -733,11 +479,11 @@ class ExprUngroup extends ExpressionDef {
             };
         }
         this.log(`${this.control}() incompatible type`);
-        return (0, index_1.errorFor)("ungrouped type check");
+        return (0, ast_types_1.errorFor)("ungrouped type check");
     }
 }
 exports.ExprUngroup = ExprUngroup;
-class WhenClause extends ExpressionDef {
+class WhenClause extends ast_main_1.ExpressionDef {
     constructor(whenThis, thenThis) {
         super({ whenThis, thenThis });
         this.whenThis = whenThis;
@@ -749,7 +495,7 @@ class WhenClause extends ExpressionDef {
     }
 }
 exports.WhenClause = WhenClause;
-class ExprCase extends ExpressionDef {
+class ExprCase extends ast_main_1.ExpressionDef {
     constructor(when, elseClause) {
         super({ when });
         this.when = when;
@@ -766,9 +512,9 @@ class ExprCase extends ExpressionDef {
             const thenExpr = clause.thenThis.getExpression(fs);
             expressionType = (0, malloy_types_1.maxExpressionType)(expressionType, (0, malloy_types_1.maxExpressionType)(whenExpr.expressionType, thenExpr.expressionType));
             if (thenExpr.dataType !== "null") {
-                if (retType && !index_1.FT.typeEq(retType, thenExpr)) {
-                    this.log(`Mismatched THEN clause types, ${index_1.FT.inspect(retType, thenExpr)}`);
-                    return (0, index_1.errorFor)("then typecheck");
+                if (retType && !ast_types_1.FT.typeEq(retType, thenExpr)) {
+                    this.log(`Mismatched THEN clause types, ${ast_types_1.FT.inspect(retType, thenExpr)}`);
+                    return (0, ast_types_1.errorFor)("then typecheck");
                 }
                 else {
                     retType = thenExpr;
@@ -781,9 +527,9 @@ class ExprCase extends ExpressionDef {
             expressionType = (0, malloy_types_1.maxExpressionType)(expressionType, elseExpr.expressionType);
             caseExpr.push(" ELSE ", ...elseExpr.value);
             if (elseExpr.dataType !== "null") {
-                if (retType && !index_1.FT.typeEq(retType, elseExpr)) {
-                    this.log(`Mismatched ELSE clause type, ${index_1.FT.inspect(retType, elseExpr)}`);
-                    return (0, index_1.errorFor)("else typecheck");
+                if (retType && !ast_types_1.FT.typeEq(retType, elseExpr)) {
+                    this.log(`Mismatched ELSE clause type, ${ast_types_1.FT.inspect(retType, elseExpr)}`);
+                    return (0, ast_types_1.errorFor)("else typecheck");
                 }
                 else {
                     retType = elseExpr;
@@ -792,7 +538,7 @@ class ExprCase extends ExpressionDef {
         }
         if (retType === undefined) {
             this.log("case statement type not computable");
-            return (0, index_1.errorFor)("typeless case");
+            return (0, ast_types_1.errorFor)("typeless case");
         }
         caseExpr.push(" END");
         return {
@@ -803,13 +549,13 @@ class ExprCase extends ExpressionDef {
     }
 }
 exports.ExprCase = ExprCase;
-class ExprFilter extends ExpressionDef {
+class ExprFilter extends ast_main_1.ExpressionDef {
     constructor(expr, filter) {
         super({ expr, filter });
         this.expr = expr;
         this.filter = filter;
         this.elementType = "filtered expression";
-        this.legalChildTypes = index_1.FT.anyAtomicT;
+        this.legalChildTypes = ast_types_1.FT.anyAtomicT;
     }
     getExpression(fs) {
         const testList = this.filter.getFilterList(fs);
@@ -817,7 +563,7 @@ class ExprFilter extends ExpressionDef {
         for (const cond of testList) {
             if ((0, malloy_types_1.expressionIsCalculation)(cond.expressionType)) {
                 this.filter.log("Cannot filter a field with an aggregate or analytical computation");
-                return (0, index_1.errorFor)("no filter on aggregate");
+                return (0, ast_types_1.errorFor)("no filter on aggregate");
             }
         }
         if (resultExpr.expressionType === "scalar") {
@@ -838,7 +584,7 @@ class ExprFilter extends ExpressionDef {
             };
         }
         this.expr.log(`Cannot filter '${resultExpr.dataType}' data`);
-        return (0, index_1.errorFor)("cannot filter type");
+        return (0, ast_types_1.errorFor)("cannot filter type");
     }
 }
 exports.ExprFilter = ExprFilter;
@@ -846,7 +592,7 @@ function isCastType(t) {
     return ["string", "number", "boolean", "date", "timestamp"].includes(t);
 }
 exports.isCastType = isCastType;
-class ExprCast extends ExpressionDef {
+class ExprCast extends ast_main_1.ExpressionDef {
     constructor(expr, castType, safe = false) {
         super({ expr });
         this.expr = expr;
@@ -859,83 +605,33 @@ class ExprCast extends ExpressionDef {
         return {
             dataType: this.castType,
             expressionType: expr.expressionType,
-            value: (0, index_1.compressExpr)((0, time_utils_1.castTo)(this.castType, expr.value, this.safe)),
+            value: (0, ast_types_1.compressExpr)((0, time_utils_1.castTo)(this.castType, expr.value, this.safe)),
         };
     }
 }
 exports.ExprCast = ExprCast;
-class TopBy extends index_1.MalloyElement {
+class TopBy extends ast_main_1.MalloyElement {
     constructor(by) {
         super();
         this.by = by;
         this.elementType = "topBy";
-        if (by instanceof ExpressionDef) {
+        if (by instanceof ast_main_1.ExpressionDef) {
             this.has({ by });
         }
     }
     getBy(fs) {
-        if (this.by instanceof ExpressionDef) {
+        if (this.by instanceof ast_main_1.ExpressionDef) {
             const byExpr = this.by.getExpression(fs);
             if (!(0, malloy_types_1.expressionIsAggregate)(byExpr.expressionType)) {
                 this.log("top by expression must be an aggregate");
             }
-            return { by: "expression", e: (0, index_1.compressExpr)(byExpr.value) };
+            return { by: "expression", e: (0, ast_types_1.compressExpr)(byExpr.value) };
         }
         return { by: "name", name: this.by };
     }
 }
 exports.TopBy = TopBy;
-class Range extends ExpressionDef {
-    constructor(first, last) {
-        super({ first, last });
-        this.first = first;
-        this.last = last;
-        this.elementType = "range";
-    }
-    apply(fs, op, expr) {
-        switch (op) {
-            case "=":
-            case "!=": {
-                const op1 = op === "=" ? ">=" : "<";
-                const op2 = op === "=" ? "and" : "or";
-                const op3 = op === "=" ? "<" : ">=";
-                const fromValue = this.first.apply(fs, op1, expr);
-                const toValue = this.last.apply(fs, op3, expr);
-                return {
-                    dataType: "boolean",
-                    expressionType: (0, malloy_types_1.maxExpressionType)(fromValue.expressionType, toValue.expressionType),
-                    value: (0, index_1.compose)(fromValue.value, op2, toValue.value),
-                };
-            }
-            /**
-             * This is a little surprising, but is actually how you comapre a
-             * value to a range ...
-             *
-             * val > begin to end     val >= end
-             * val >= begin to end    val >= begin
-             * val < begin to end     val < begin
-             * val <= begin to end    val < end
-             */
-            case ">":
-                return this.last.apply(fs, ">=", expr);
-            case ">=":
-                return this.first.apply(fs, ">=", expr);
-            case "<":
-                return this.first.apply(fs, "<", expr);
-            case "<=":
-                return this.last.apply(fs, "<", expr);
-        }
-        throw new Error("mysterious error in range computation");
-    }
-    requestExpression(_fs) {
-        return undefined;
-    }
-    getExpression(_fs) {
-        return (0, index_1.errorFor)("a range is not a value");
-    }
-}
-exports.Range = Range;
-class PickWhen extends index_1.MalloyElement {
+class PickWhen extends ast_main_1.MalloyElement {
     constructor(pick, when) {
         super({ when });
         this.pick = pick;
@@ -945,7 +641,7 @@ class PickWhen extends index_1.MalloyElement {
     }
 }
 exports.PickWhen = PickWhen;
-class Pick extends ExpressionDef {
+class Pick extends ast_main_1.ExpressionDef {
     constructor(choices, elsePick) {
         super({ choices });
         this.choices = choices;
@@ -982,10 +678,10 @@ class Pick extends ExpressionDef {
                 : expr.getExpression(fs);
             anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(whenExpr.expressionType, thenExpr.expressionType));
             if (returnType) {
-                if (!index_1.FT.typeEq(returnType, thenExpr, true)) {
-                    const whenType = index_1.FT.inspect(thenExpr);
+                if (!ast_types_1.FT.typeEq(returnType, thenExpr, true)) {
+                    const whenType = ast_types_1.FT.inspect(thenExpr);
                     this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
-                    return (0, index_1.errorFor)("pick when type");
+                    return (0, ast_types_1.errorFor)("pick when type");
                 }
             }
             else {
@@ -996,32 +692,32 @@ class Pick extends ExpressionDef {
         const elsePart = this.elsePick || expr;
         const elseVal = elsePart.getExpression(fs);
         returnType || (returnType = elseVal);
-        if (!index_1.FT.typeEq(returnType, elseVal, true)) {
+        if (!ast_types_1.FT.typeEq(returnType, elseVal, true)) {
             const errSrc = this.elsePick ? "else" : "pick default";
-            this.log(`${errSrc} type '${index_1.FT.inspect(elseVal)}', expected '${returnType.dataType}'`);
-            return (0, index_1.errorFor)("pick else type");
+            this.log(`${errSrc} type '${ast_types_1.FT.inspect(elseVal)}', expected '${returnType.dataType}'`);
+            return (0, ast_types_1.errorFor)("pick else type");
         }
         return {
             dataType: returnType.dataType,
             expressionType: (0, malloy_types_1.maxExpressionType)(anyExpressionType, elseVal.expressionType),
-            value: (0, index_1.compressExpr)([...caseValue, " ELSE ", ...elseVal.value, " END"]),
+            value: (0, ast_types_1.compressExpr)([...caseValue, " ELSE ", ...elseVal.value, " END"]),
         };
     }
     getExpression(fs) {
         if (this.elsePick === undefined) {
             this.log("pick incomplete, missing 'else'");
-            return (0, index_1.errorFor)("no value for partial pick");
+            return (0, ast_types_1.errorFor)("no value for partial pick");
         }
         const choiceValues = [];
         for (const c of this.choices) {
             if (c.pick === undefined) {
                 this.log("pick with no value can only be used with apply");
-                return (0, index_1.errorFor)("no value for partial pick");
+                return (0, ast_types_1.errorFor)("no value for partial pick");
             }
             const pickWhen = c.when.requestExpression(fs);
             if (pickWhen === undefined) {
                 this.log("pick with partial when can only be used with apply");
-                return (0, index_1.errorFor)("partial when");
+                return (0, ast_types_1.errorFor)("partial when");
             }
             choiceValues.push({
                 pick: c.pick.getExpression(fs),
@@ -1032,31 +728,54 @@ class Pick extends ExpressionDef {
         const caseValue = ["CASE"];
         let anyExpressionType = returnType.expressionType;
         for (const aChoice of choiceValues) {
-            if (!index_1.FT.typeEq(aChoice.when, index_1.FT.boolT)) {
-                this.log(`when expression must be boolean, not '${index_1.FT.inspect(aChoice.when)}`);
-                return (0, index_1.errorFor)("pick when type");
+            if (!ast_types_1.FT.typeEq(aChoice.when, ast_types_1.FT.boolT)) {
+                this.log(`when expression must be boolean, not '${ast_types_1.FT.inspect(aChoice.when)}`);
+                return (0, ast_types_1.errorFor)("pick when type");
             }
-            if (!index_1.FT.typeEq(returnType, aChoice.pick, true)) {
-                const whenType = index_1.FT.inspect(aChoice.pick);
+            if (!ast_types_1.FT.typeEq(returnType, aChoice.pick, true)) {
+                const whenType = ast_types_1.FT.inspect(aChoice.pick);
                 this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
-                return (0, index_1.errorFor)("pick value type");
+                return (0, ast_types_1.errorFor)("pick value type");
             }
             anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(aChoice.pick.expressionType, aChoice.when.expressionType));
             caseValue.push(" WHEN ", ...aChoice.when.value, " THEN ", ...aChoice.pick.value);
         }
         const defVal = this.elsePick.getExpression(fs);
         anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, defVal.expressionType);
-        if (!index_1.FT.typeEq(returnType, defVal, true)) {
-            this.elsePick.log(`else type '${index_1.FT.inspect(defVal)}', expected '${returnType.dataType}'`);
-            return (0, index_1.errorFor)("pick value type mismatch");
+        if (!ast_types_1.FT.typeEq(returnType, defVal, true)) {
+            this.elsePick.log(`else type '${ast_types_1.FT.inspect(defVal)}', expected '${returnType.dataType}'`);
+            return (0, ast_types_1.errorFor)("pick value type mismatch");
         }
         caseValue.push(" ELSE ", ...defVal.value, " END");
         return {
             dataType: returnType.dataType,
             expressionType: anyExpressionType,
-            value: (0, index_1.compressExpr)(caseValue),
+            value: (0, ast_types_1.compressExpr)(caseValue),
         };
     }
 }
 exports.Pick = Pick;
+function nullCompare(left, op, right) {
+    const not = op === "!=" || op === "!~";
+    if (left.dataType === "null" || right.dataType === "null") {
+        const maybeNot = not ? " NOT" : "";
+        if (left.dataType !== "null") {
+            return [...left.value, ` IS${maybeNot} NULL`];
+        }
+        if (right.dataType !== "null") {
+            return [...right.value, `IS${maybeNot} NULL`];
+        }
+        return [not ? "false" : "true"];
+    }
+    return undefined;
+}
+class Apply extends ast_main_1.ExprCompare {
+    constructor(left, right) {
+        super(left, "=", right);
+        this.left = left;
+        this.right = right;
+        this.elementType = "apply";
+    }
+}
+exports.Apply = Apply;
 //# sourceMappingURL=ast-expr.js.map