@malloydata/malloy 0.0.205-dev241028163321 → 0.0.205-dev241028173215

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

@@ -21,24 +21,47 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprMinus = void 0;
 const ast_utils_1 = require("../ast-utils");
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 const expression_def_1 = require("../types/expression-def");
 class ExprMinus extends expression_def_1.ExpressionDef {
     constructor(expr) {
         super({ expr: expr });
         this.expr = expr;
         this.elementType = 'unary minus';
-        this.legalChildTypes = [fragtype_utils_1.FT.numberT];
+        this.legalChildTypes = [TDU.numberT];
     }
     getExpression(fs) {
         const expr = this.expr.getExpression(fs);
-        if (fragtype_utils_1.FT.typeIn(expr, this.legalChildTypes)) {
+        if (TDU.typeIn(expr, this.legalChildTypes)) {
             return {
                 ...expr,
-                dataType: 'number',
+                type: 'number',
                 value: { node: 'unary-', e: expr.value },
             };
         }

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

@@ -21,22 +21,45 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprNot = void 0;
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 const unary_1 = require("./unary");
 class ExprNot extends unary_1.Unary {
     constructor(expr) {
         super(expr);
         this.elementType = 'not';
-        this.legalChildTypes = [fragtype_utils_1.FT.boolT, fragtype_utils_1.FT.nullT];
+        this.legalChildTypes = [TDU.boolT, TDU.nullT];
     }
     getExpression(fs) {
         const notThis = this.expr.getExpression(fs);
         const doNot = this.typeCheck(this.expr, notThis);
         return {
             ...notThis,
-            dataType: 'boolean',
+            type: 'boolean',
             value: { node: 'not', e: doNot ? notThis.value : { node: 'false' } },
         };
     }

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

@@ -31,7 +31,7 @@ class ExprNow extends expression_def_1.ExpressionDef {
     }
     getExpression(_fs) {
         return {
-            dataType: 'timestamp',
+            type: 'timestamp',
             expressionType: 'scalar',
             // `now` is considered to be a constant, at least in the dialects we support today
             evalSpace: 'constant',

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

@@ -32,7 +32,7 @@ class ExprNULL extends expression_def_1.ExpressionDef {
     }
     getExpression() {
         return (0, expr_value_1.literalExprValue)({
-            dataType: 'null',
+            dataType: { type: 'null' },
             value: { node: 'null' },
         });
     }

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

@@ -35,8 +35,12 @@ class ExprNumber extends expression_def_1.ExpressionDef {
         return this.constantExpression();
     }
     constantExpression() {
+        const n = Number(this.n);
+        const dataType = Number.isNaN(n)
+            ? { type: 'number' }
+            : { type: 'number', numberType: Number.isInteger(n) ? 'integer' : 'float' };
         return (0, expr_value_1.literalExprValue)({
-            dataType: 'number',
+            dataType,
             value: { node: 'numberLiteral', literal: this.n },
         });
     }

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

@@ -21,11 +21,34 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprProps = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const ast_utils_1 = require("../ast-utils");
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 const function_ordering_1 = require("./function-ordering");
 const limit_1 = require("../query-properties/limit");
 const partition_by_1 = require("./partition_by");
@@ -37,7 +60,7 @@ class ExprProps extends expression_def_1.ExpressionDef {
         this.expr = expr;
         this.statements = statements;
         this.elementType = 'expression with props';
-        this.legalChildTypes = fragtype_utils_1.FT.anyAtomicT;
+        this.legalChildTypes = TDU.anyAtomicT;
     }
     getFilteredExpression(fs, expr, wheres) {
         if (wheres.length > 0) {

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

@@ -33,7 +33,7 @@ class ExprRegEx extends expression_def_1.ExpressionDef {
     }
     getExpression() {
         return (0, expr_value_1.literalExprValue)({
-            dataType: 'regular expression',
+            dataType: { type: 'regular expression' },
             value: { node: 'regexpLiteral', literal: this.regex },
         });
     }

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

@@ -33,7 +33,7 @@ class ExprString extends expression_def_1.ExpressionDef {
     }
     getExpression(_fs) {
         return (0, expr_value_1.literalExprValue)({
-            dataType: 'string',
+            dataType: { type: 'string' },
             value: { node: 'stringLiteral', literal: this.value },
         });
     }

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

@@ -53,24 +53,24 @@ 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);
-                if (first.dataType === 'error' || last.dataType === 'error') {
+                if (first.type === 'error' || last.type === 'error') {
                     return (0, expr_value_1.computedErrorExprValue)({
-                        dataType: 'number',
+                        dataType: { type: 'number' },
                         error: 'extract from error',
                         from: [first, last],
                     });
                 }
-                if (!(0, malloy_types_1.isTemporalField)(first.dataType)) {
-                    return from.first.loggedErrorExpr('invalid-type-for-time-extraction', `Can't extract ${extractTo} from '${first.dataType}'`);
+                if (!(0, malloy_types_1.isTemporalField)(first.type)) {
+                    return from.first.loggedErrorExpr('invalid-type-for-time-extraction', `Can't extract ${extractTo} from '${first.type}'`);
                 }
-                if (!(0, malloy_types_1.isTemporalField)(last.dataType)) {
-                    return from.last.loggedErrorExpr('invalid-type-for-time-extraction', `Cannot extract ${extractTo} from '${last.dataType}'`);
+                if (!(0, malloy_types_1.isTemporalField)(last.type)) {
+                    return from.last.loggedErrorExpr('invalid-type-for-time-extraction', `Cannot extract ${extractTo} from '${last.type}'`);
                 }
-                let valueType = first.dataType;
-                if (first.dataType !== last.dataType) {
+                let valueType = first.type;
+                if (!malloy_types_1.TD.eq(first, last)) {
                     let cannotMeasure = true;
                     valueType = 'timestamp';
-                    if (first.dataType === 'date') {
+                    if (first.type === 'date') {
                         const newFirst = (0, expression_def_1.getMorphicValue)(first, 'timestamp');
                         if (newFirst) {
                             first = newFirst;
@@ -85,7 +85,7 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                         }
                     }
                     if (cannotMeasure) {
-                        return from.first.loggedErrorExpr('invalid-types-for-time-measurement', `Cannot measure from ${first.dataType} to ${last.dataType}`);
+                        return from.first.loggedErrorExpr('invalid-types-for-time-measurement', `Cannot measure from ${first.type} to ${last.type}`);
                     }
                 }
                 if (['week', 'month', 'quarter', 'year'].includes(extractTo)) {
@@ -95,7 +95,7 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                     return this.loggedErrorExpr('invalid-time-extraction-unit', `Cannot extract ${extractTo} from a range`);
                 }
                 return (0, expr_value_1.computedExprValue)({
-                    dataType: 'number',
+                    dataType: { type: 'number', numberType: 'integer' },
                     value: {
                         node: 'timeDiff',
                         units: extractTo,
@@ -109,23 +109,23 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
             }
             else {
                 const argV = from.getExpression(fs);
-                if ((0, malloy_types_1.isTemporalField)(argV.dataType)) {
+                if ((0, malloy_types_1.isTemporalField)(argV.type)) {
                     return (0, expr_value_1.computedExprValue)({
-                        dataType: 'number',
+                        dataType: { type: 'number', numberType: 'integer' },
                         value: {
                             node: 'extract',
-                            e: (0, malloy_types_1.mkTemporal)(argV.value, argV.dataType),
+                            e: (0, malloy_types_1.mkTemporal)(argV.value, argV.type),
                             units: extractTo,
                         },
                         from: [argV],
                     });
                 }
-                if (argV.dataType !== 'error') {
-                    this.logError('unsupported-type-for-time-extraction', `${this.extractText}() requires time type, not '${argV.dataType}'`);
+                if (argV.type !== 'error') {
+                    this.logError('unsupported-type-for-time-extraction', `${this.extractText}() requires time type, not '${argV.type}'`);
                 }
                 return (0, expr_value_1.computedErrorExprValue)({
-                    dataType: 'number',
-                    error: `${this.extractText} bad type ${argV.dataType}`,
+                    dataType: { type: 'number', numberType: 'integer' },
+                    error: `${this.extractText} bad type ${argV.type}`,
                     from: [argV],
                 });
             }

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

@@ -32,7 +32,7 @@ class ExprTime extends expression_def_1.ExpressionDef {
         this.elementType = 'timestampOrDate';
         this.elementType = timeType;
         this.translationValue = (0, expr_value_1.computedExprValue)({
-            dataType: timeType,
+            dataType: { type: timeType },
             value,
             from: from !== null && from !== void 0 ? from : [],
         });
@@ -42,15 +42,15 @@ class ExprTime extends expression_def_1.ExpressionDef {
     }
     static fromValue(timeType, expr) {
         let value = expr.value;
-        if (timeType !== expr.dataType) {
+        if (timeType !== expr.type) {
             const toTs = {
                 node: 'cast',
                 safe: false,
                 dstType: { type: timeType },
                 e: expr.value,
             };
-            if ((0, malloy_types_1.isTemporalField)(expr.dataType)) {
-                toTs.srcType = { type: expr.dataType };
+            if ((0, malloy_types_1.isTemporalField)(expr.type)) {
+                toTs.srcType = { type: expr.type };
             }
             value = toTs;
         }

package/dist/lang/ast/expressions/expr-ungroup.d.ts

@@ -1,4 +1,3 @@
-import { FieldValueType } from '../../../model/malloy_types';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldName, FieldSpace } from '../types/field-space';
@@ -9,6 +8,5 @@ export declare class ExprUngroup extends ExpressionDef {
     legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
     elementType: string;
     constructor(control: 'all' | 'exclude', expr: ExpressionDef, fields: FieldName[]);
-    returns(_forExpression: ExprValue): FieldValueType;
     getExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -21,11 +21,34 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprUngroup = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const query_spaces_1 = require("../field-space/query-spaces");
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 const expression_def_1 = require("../types/expression-def");
 class ExprUngroup extends expression_def_1.ExpressionDef {
     constructor(control, expr, fields) {
@@ -33,12 +56,9 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
         this.control = control;
         this.expr = expr;
         this.fields = fields;
-        this.legalChildTypes = fragtype_utils_1.FT.anyAtomicT;
+        this.legalChildTypes = TDU.anyAtomicT;
         this.elementType = 'ungroup';
     }
-    returns(_forExpression) {
-        return 'number';
-    }
     getExpression(fs) {
         const exprVal = this.expr.getExpression(fs);
         if (!(0, malloy_types_1.expressionIsAggregate)(exprVal.expressionType)) {
@@ -82,7 +102,7 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
                 ungroup.fields = dstFields;
             }
             return {
-                dataType: this.returns(exprVal),
+                ...TDU.atomicDef(exprVal),
                 expressionType: 'ungrouped_aggregate',
                 value: ungroup,
                 evalSpace: 'output',

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

@@ -21,10 +21,33 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForRange = void 0;
 const ast_utils_1 = require("../ast-utils");
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 const time_utils_1 = require("../time-utils");
 const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
@@ -37,7 +60,7 @@ class ForRange extends expression_def_1.ExpressionDef {
         this.duration = duration;
         this.timeframe = timeframe;
         this.elementType = 'forRange';
-        this.legalChildTypes = [fragtype_utils_1.FT.timestampT, fragtype_utils_1.FT.dateT];
+        this.legalChildTypes = [TDU.timestampT, TDU.dateT];
     }
     apply(fs, op, expr) {
         const startV = this.from.getExpression(fs);
@@ -46,12 +69,12 @@ class ForRange extends expression_def_1.ExpressionDef {
             return (0, ast_utils_1.errorFor)('no time for range');
         }
         const nV = this.duration.getExpression(fs);
-        if (nV.dataType !== 'number') {
-            if (nV.dataType !== 'error') {
-                this.logError('invalid-duration-quantity', `FOR duration count must be a number, not '${nV.dataType}'`);
+        if (nV.type !== 'number') {
+            if (nV.type !== 'error') {
+                this.logError('invalid-duration-quantity', `FOR duration count must be a number, not '${nV.type}'`);
             }
             return (0, expr_value_1.computedErrorExprValue)({
-                dataType: 'boolean',
+                dataType: { type: 'boolean' },
                 error: 'for not number',
                 from: [startV, checkV],
             });
@@ -62,11 +85,11 @@ class ForRange extends expression_def_1.ExpressionDef {
         let rangeType = (0, time_utils_1.resolution)(units);
         // Next, if the beginning of the range is a timestamp, then we
         // also have to do the computation as a timestamp
-        if (startV.dataType === 'timestamp') {
+        if (startV.type === 'timestamp') {
             rangeType = 'timestamp';
         }
         // everything is dates, do date math
-        if (checkV.dataType === 'date' && rangeType === 'date') {
+        if (checkV.type === 'date' && rangeType === 'date') {
             const rangeStart = this.from;
             const rangeEndV = (0, time_utils_1.timeOffset)('date', startV.value, '+', nV.value, units);
             const rangeEnd = new expr_time_1.ExprTime('date', rangeEndV);
@@ -77,7 +100,7 @@ class ForRange extends expression_def_1.ExpressionDef {
         const applyTo = expr_time_1.ExprTime.fromValue('timestamp', checkV);
         let rangeStart = this.from;
         let from = startV.value;
-        if (startV.dataType === 'date') {
+        if (startV.type === 'date') {
             const tsVersion = startV.morphic && startV.morphic['timestamp'];
             if (tsVersion) {
                 from = tsVersion;

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

@@ -21,16 +21,37 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PickWhen = exports.Pick = void 0;
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
 function typeCoalesce(ev1, ev2) {
-    return ev1 === undefined ||
-        ev1.dataType === 'null' ||
-        ev1.dataType === 'error'
+    return ev1 === undefined || ev1.type === 'null' || ev1.type === 'error'
         ? ev2
         : ev1;
 }
@@ -53,7 +74,7 @@ class Pick extends expression_def_1.ExpressionDef {
                 return undefined;
             }
             const whenResp = c.when.requestExpression(fs);
-            if (whenResp === undefined || whenResp.dataType !== 'boolean') {
+            if (whenResp === undefined || whenResp.type !== 'boolean') {
                 // If when is not a boolean, we'll treat it like a partial compare
                 return undefined;
             }
@@ -77,10 +98,10 @@ class Pick extends expression_def_1.ExpressionDef {
                 ? choice.pick.getExpression(fs)
                 : expr.getExpression(fs);
             dependents.push(whenExpr, thenExpr);
-            if (returnType && !fragtype_utils_1.FT.typeEq(returnType, thenExpr, true)) {
+            if (returnType && !TDU.typeEq(returnType, thenExpr, true)) {
                 return this.loggedErrorExpr('pick-type-does-not-match', {
-                    pickType: thenExpr.dataType,
-                    returnType: returnType.dataType,
+                    pickType: thenExpr.type,
+                    returnType: returnType.type,
                 });
             }
             returnType = typeCoalesce(returnType, thenExpr);
@@ -93,24 +114,24 @@ class Pick extends expression_def_1.ExpressionDef {
         if (elseVal)
             dependents.push(elseVal);
         const defaultVal = elseVal !== null && elseVal !== void 0 ? elseVal : exprVal;
-        returnType = typeCoalesce(returnType, defaultVal);
-        if (!fragtype_utils_1.FT.typeEq(returnType, defaultVal, true)) {
+        const definedReturnType = typeCoalesce(returnType, defaultVal);
+        if (!TDU.typeEq(definedReturnType, defaultVal, true)) {
             if (this.elsePick) {
                 return this.loggedErrorExpr('pick-else-type-does-not-match', {
-                    elseType: defaultVal.dataType,
-                    returnType: returnType.dataType,
+                    elseType: defaultVal.type,
+                    returnType: definedReturnType.type,
                 });
             }
             else {
                 return this.loggedErrorExpr('pick-default-type-does-not-match', {
-                    defaultType: defaultVal.dataType,
-                    returnType: returnType.dataType,
+                    defaultType: defaultVal.type,
+                    returnType: definedReturnType.type,
                 });
             }
         }
         caseValue.kids.caseElse = defaultVal.value;
         return (0, expr_value_1.computedExprValue)({
-            dataType: returnType.dataType,
+            dataType: definedReturnType,
             value: caseValue,
             from: dependents,
         });
@@ -143,15 +164,15 @@ class Pick extends expression_def_1.ExpressionDef {
         }
         let returnType;
         for (const aChoice of choiceValues) {
-            if (!fragtype_utils_1.FT.typeEq(aChoice.when, fragtype_utils_1.FT.boolT)) {
+            if (!TDU.typeEq(aChoice.when, TDU.boolT)) {
                 return this.loggedErrorExpr('pick-when-must-be-boolean', {
-                    whenType: aChoice.when.dataType,
+                    whenType: aChoice.when.type,
                 });
             }
-            if (returnType && !fragtype_utils_1.FT.typeEq(returnType, aChoice.pick, true)) {
+            if (returnType && !TDU.typeEq(returnType, aChoice.pick, true)) {
                 return this.loggedErrorExpr('pick-type-does-not-match', {
-                    pickType: aChoice.pick.dataType,
-                    returnType: returnType.dataType,
+                    pickType: aChoice.pick.type,
+                    returnType: returnType.type,
                 });
             }
             returnType = typeCoalesce(returnType, aChoice.pick);
@@ -160,16 +181,16 @@ class Pick extends expression_def_1.ExpressionDef {
         }
         const defVal = this.elsePick.getExpression(fs);
         dependents.push(defVal);
-        returnType = typeCoalesce(returnType, defVal);
-        if (!fragtype_utils_1.FT.typeEq(returnType, defVal, true)) {
+        const definedReturnType = typeCoalesce(returnType, defVal);
+        if (!TDU.typeEq(definedReturnType, defVal, true)) {
             return this.elsePick.loggedErrorExpr('pick-else-type-does-not-match', {
-                elseType: defVal.dataType,
-                returnType: returnType.dataType,
+                elseType: defVal.type,
+                returnType: definedReturnType.type,
             });
         }
         pick.kids.caseElse = defVal.value;
         return (0, expr_value_1.computedExprValue)({
-            dataType: returnType.dataType,
+            dataType: definedReturnType,
             value: pick,
             from: dependents,
         });

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

@@ -43,7 +43,7 @@ class Range extends expression_def_1.ExpressionDef {
                 const fromValue = this.first.apply(fs, op1, expr);
                 const toValue = this.last.apply(fs, op3, expr);
                 return (0, expr_value_1.computedExprValue)({
-                    dataType: 'boolean',
+                    dataType: { type: 'boolean' },
                     value: {
                         node: op2,
                         kids: { left: fromValue.value, right: toValue.value },

package/dist/lang/ast/expressions/time-literal.js

@@ -82,7 +82,11 @@ class TimeLiteral extends expression_def_1.ExpressionDef {
     }
     makeValue(val, dataType) {
         const value = this.makeLiteral(val, dataType);
-        return (0, expr_value_1.literalTimeResult)({ value, dataType, timeframe: this.units });
+        return (0, expr_value_1.literalTimeResult)({
+            value,
+            dataType: { type: dataType },
+            timeframe: this.units,
+        });
     }
     getExpression(_fs) {
         return this.makeValue(this.literalPart, this.timeType);
@@ -150,7 +154,7 @@ class GranularLiteral extends TimeLiteral {
         let rangeEnd = this.getNext();
         if (rangeEnd) {
             const testValue = left.getExpression(fs);
-            if (testValue.dataType === 'timestamp') {
+            if (testValue.type === 'timestamp') {
                 const newStart = (0, expression_def_1.getMorphicValue)(rangeStart, 'timestamp');
                 const newEnd = (0, expression_def_1.getMorphicValue)(rangeEnd, 'timestamp');
                 if (newStart && newEnd) {
@@ -161,8 +165,9 @@ class GranularLiteral extends TimeLiteral {
                     return super.apply(fs, op, left);
                 }
             }
-            if ((0, malloy_types_1.isTemporalField)(testValue.dataType)) {
-                const rangeType = testValue.dataType;
+            // Compiler is unsure about rangeEnd = newEnd for some reason
+            if (rangeEnd && (0, malloy_types_1.isTemporalField)(testValue.type)) {
+                const rangeType = testValue.type;
                 const range = new range_1.Range(new expr_time_1.ExprTime(rangeType, rangeStart.value), new expr_time_1.ExprTime(rangeType, rangeEnd.value));
                 return range.apply(fs, op, left);
             }