@malloydata/malloy 0.0.205-dev241028163321 → 0.0.205-dev241028192658

package/dist/lang/ast/types/expression-def.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.applyBinary = exports.getMorphicValue = exports.ExprDuration = exports.ExpressionDef = exports.ATNodeType = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
+const TDU = __importStar(require("../typedesc-utils"));
 const ast_utils_1 = require("../ast-utils");
-const fragtype_utils_1 = require("../fragtype-utils");
 const expr_value_1 = require("./expr-value");
 const time_utils_1 = require("../time-utils");
 const granular_result_1 = require("./granular-result");
@@ -50,7 +73,7 @@ var ATNodeType;
 class ExpressionDef extends malloy_element_1.MalloyElement {
     constructor() {
         super(...arguments);
-        this.legalChildTypes = fragtype_utils_1.FT.anyAtomicT;
+        this.legalChildTypes = TDU.anyAtomicT;
     }
     granular() {
         return false;
@@ -74,14 +97,14 @@ class ExpressionDef extends malloy_element_1.MalloyElement {
      * @param eVal ...list of expressions that must match legalChildTypes
      */
     typeCheck(eNode, eVal) {
-        if (eVal.dataType !== 'error' && !fragtype_utils_1.FT.in(eVal, this.legalChildTypes)) {
-            if (eVal.dataType === 'sql native') {
+        if (eVal.type !== 'error' && !TDU.any(eVal, this.legalChildTypes)) {
+            if (eVal.type === 'sql native') {
                 eNode.logError('sql-native-not-allowed-in-expression', {
                     rawType: eVal.rawType,
                 });
             }
             else {
-                eNode.logError('expression-type-error', `'${this.elementType}' Can't use type ${fragtype_utils_1.FT.inspect(eVal)}`);
+                eNode.logError('expression-type-error', `'${this.elementType}' Can't use type ${TDU.inspect(eVal)}`);
             }
             return false;
         }
@@ -126,15 +149,15 @@ class ExprDuration extends ExpressionDef {
         this.n = n;
         this.timeframe = timeframe;
         this.elementType = 'duration';
-        this.legalChildTypes = [fragtype_utils_1.FT.timestampT, fragtype_utils_1.FT.dateT];
+        this.legalChildTypes = [TDU.timestampT, TDU.dateT];
     }
     apply(fs, op, left) {
         const lhs = left.getExpression(fs);
         this.typeCheck(this, lhs);
-        if ((0, malloy_types_1.isTemporalField)(lhs.dataType) && (op === '+' || op === '-')) {
+        if ((0, malloy_types_1.isTemporalField)(lhs.type) && (op === '+' || op === '-')) {
             const num = this.n.getExpression(fs);
-            if (!fragtype_utils_1.FT.typeEq(num, fragtype_utils_1.FT.numberT)) {
-                this.logError('invalid-duration-quantity', `Duration quantity needs number not '${num.dataType}`);
+            if (!TDU.typeEq(num, TDU.numberT)) {
+                this.logError('invalid-duration-quantity', `Duration quantity needs number not '${num.type}`);
                 return (0, ast_utils_1.errorFor)('illegal unit expression');
             }
             let resultGranularity;
@@ -144,12 +167,12 @@ class ExprDuration extends ExpressionDef {
             if ((0, granular_result_1.isGranularResult)(lhs) && lhs.timeframe === this.timeframe) {
                 resultGranularity = lhs.timeframe;
             }
-            if (lhs.dataType === 'date' && !(0, malloy_types_1.isDateUnit)(this.timeframe)) {
+            if (lhs.type === 'date' && !(0, malloy_types_1.isDateUnit)(this.timeframe)) {
                 return this.loggedErrorExpr('invalid-timeframe-for-time-offset', `Cannot offset date by ${this.timeframe}`);
             }
             return (0, expr_value_1.computedTimeResult)({
-                dataType: lhs.dataType,
-                value: (0, time_utils_1.timeOffset)(lhs.dataType, lhs.value, op, num.value, this.timeframe),
+                dataType: { type: lhs.type },
+                value: (0, time_utils_1.timeOffset)(lhs.type, lhs.value, op, num.value, this.timeframe),
                 timeframe: resultGranularity,
                 from: [lhs, num],
             });
@@ -159,7 +182,7 @@ class ExprDuration extends ExpressionDef {
     getExpression(fs) {
         const num = this.n.getExpression(fs);
         return (0, expr_value_1.computedErrorExprValue)({
-            dataType: 'duration',
+            dataType: { type: 'duration' },
             error: 'Duration is not a value',
             from: [num],
         });
@@ -167,30 +190,31 @@ class ExprDuration extends ExpressionDef {
 }
 exports.ExprDuration = ExprDuration;
 function willMorphTo(ev, t) {
-    if (ev.dataType === t) {
+    if (ev.type === t) {
         return ev.value;
     }
     return ev.morphic && ev.morphic[t];
 }
 function getMorphicValue(mv, mt) {
-    if (mv.dataType === mt) {
+    if (mv.type === mt) {
         return mv;
     }
     if (mv.morphic && mv.morphic[mt]) {
         return {
-            ...mv,
-            dataType: mt,
+            type: mt,
             value: mv.morphic[mt],
+            expressionType: mv.expressionType,
+            evalSpace: mv.evalSpace,
         };
     }
 }
 exports.getMorphicValue = getMorphicValue;
 function timeCompare(left, lhs, op, rhs) {
-    const leftIsTime = (0, malloy_types_1.isTemporalField)(lhs.dataType);
-    const rightIsTime = (0, malloy_types_1.isTemporalField)(rhs.dataType);
+    const leftIsTime = (0, malloy_types_1.isTemporalField)(lhs.type);
+    const rightIsTime = (0, malloy_types_1.isTemporalField)(rhs.type);
     const node = (0, binary_operators_1.getExprNode)(op);
     if (leftIsTime && rightIsTime) {
-        if (lhs.dataType !== rhs.dataType) {
+        if (lhs.type !== rhs.type) {
             const lval = willMorphTo(lhs, 'timestamp');
             const rval = willMorphTo(rhs, 'timestamp');
             if (lval && rval) {
@@ -202,24 +226,24 @@ function timeCompare(left, lhs, op, rhs) {
         }
     }
     if ((leftIsTime || rightIsTime) &&
-        lhs.dataType !== 'null' &&
-        rhs.dataType !== 'null') {
-        left.logError('time-comparison-type-mismatch', `Cannot compare a ${lhs.dataType} to a ${rhs.dataType}`);
+        lhs.type !== 'null' &&
+        rhs.type !== 'null') {
+        left.logError('time-comparison-type-mismatch', `Cannot compare a ${lhs.type} to a ${rhs.type}`);
         return { node: 'false' };
     }
     return undefined;
 }
 function regexEqual(left, right) {
-    if (left.dataType === 'string') {
-        if (right.dataType === 'regular expression') {
+    if (left.type === 'string') {
+        if (right.type === 'regular expression') {
             return {
                 node: 'regexpMatch',
                 kids: { expr: left.value, regex: right.value },
             };
         }
     }
-    else if (right.dataType === 'string') {
-        if (left.dataType === 'regular expression') {
+    else if (right.type === 'string') {
+        if (left.type === 'regular expression') {
             return {
                 node: 'regexpMatch',
                 kids: { expr: right.value, regex: left.value },
@@ -231,11 +255,11 @@ function regexEqual(left, right) {
 function nullCompare(left, op, right) {
     const not = op === '!=' || op === '!~';
     const nullCmp = not ? 'is-not-null' : 'is-null';
-    if (left.dataType === 'null' || right.dataType === 'null') {
-        if (left.dataType !== 'null') {
+    if (left.type === 'null' || right.type === 'null') {
+        if (left.type !== 'null') {
             return { node: nullCmp, e: left.value };
         }
-        if (right.dataType !== 'null') {
+        if (right.type !== 'null') {
             return { node: nullCmp, e: right.value };
         }
         return { node: not ? 'false' : 'true' };
@@ -251,14 +275,14 @@ function equality(fs, left, op, right) {
     if (err)
         return err;
     // Unsupported types can be compare with null
-    const checkUnsupport = lhs.dataType === 'sql native' || rhs.dataType === 'sql native';
-    if (checkUnsupport) {
-        const oneNull = lhs.dataType === 'null' || rhs.dataType === 'null';
-        const rawMatch = lhs.rawType && lhs.rawType === rhs.rawType;
-        if (!(oneNull || rawMatch)) {
+    const lhRaw = malloy_types_1.TD.isSQL(lhs) ? lhs.rawType || 'typeless-left' : undefined;
+    const rhRaw = malloy_types_1.TD.isSQL(rhs) ? rhs.rawType || 'typeless-right' : undefined;
+    if (lhRaw || rhRaw) {
+        const oneNull = lhs.type === 'null' || rhs.type === 'null';
+        if (!(oneNull || lhRaw === rhRaw)) {
             const noGo = unsupportError(left, lhs, right, rhs);
             if (noGo) {
-                return { ...noGo, dataType: 'boolean' };
+                return { ...noGo, type: 'boolean' };
             }
         }
     }
@@ -266,11 +290,11 @@ function equality(fs, left, op, right) {
         node,
         kids: { left: lhs.value, right: rhs.value },
     };
-    if (lhs.dataType !== 'error' && rhs.dataType !== 'error') {
+    if (lhs.type !== 'error' && rhs.type !== 'error') {
         switch (op) {
             case '~':
             case '!~': {
-                if (lhs.dataType !== 'string' || rhs.dataType !== 'string') {
+                if (lhs.type !== 'string' || rhs.type !== 'string') {
                     let regexCmp = regexEqual(lhs, rhs);
                     if (regexCmp) {
                         if (op[0] === '!') {
@@ -292,7 +316,7 @@ function equality(fs, left, op, right) {
         }
     }
     return (0, expr_value_1.computedExprValue)({
-        dataType: 'boolean',
+        dataType: { type: 'boolean' },
         value,
         from: [lhs, rhs],
     });
@@ -305,14 +329,14 @@ function compare(fs, left, op, right) {
         return err;
     const noCompare = unsupportError(left, lhs, right, rhs);
     if (noCompare) {
-        return { ...noCompare, dataType: 'boolean' };
+        return { ...noCompare, type: 'boolean' };
     }
     const value = timeCompare(left, lhs, op, rhs) || {
         node: (0, binary_operators_1.getExprNode)(op),
         kids: { left: lhs.value, right: rhs.value },
     };
     return (0, expr_value_1.computedExprValue)({
-        dataType: 'boolean',
+        dataType: { type: 'boolean' },
         value,
         from: [lhs, rhs],
     });
@@ -326,15 +350,15 @@ function numeric(fs, left, op, right) {
     const noGo = unsupportError(left, lhs, right, rhs);
     if (noGo)
         return noGo;
-    if (lhs.dataType !== 'number') {
-        left.logError('arithmetic-operation-type-mismatch', `The '${op}' operator requires a number, not a '${lhs.dataType}'`);
+    if (lhs.type !== 'number') {
+        left.logError('arithmetic-operation-type-mismatch', `The '${op}' operator requires a number, not a '${lhs.type}'`);
     }
-    else if (rhs.dataType !== 'number') {
-        right.logError('arithmetic-operation-type-mismatch', `The '${op}' operator requires a number, not a '${rhs.dataType}'`);
+    else if (rhs.type !== 'number') {
+        right.logError('arithmetic-operation-type-mismatch', `The '${op}' operator requires a number, not a '${rhs.type}'`);
     }
     else {
         return (0, expr_value_1.computedExprValue)({
-            dataType: 'number',
+            dataType: { type: 'number' },
             value: { node: op, kids: { left: lhs.value, right: rhs.value } },
             from: [lhs, rhs],
         });
@@ -348,21 +372,21 @@ function delta(fs, left, op, right) {
     if (noGo) {
         return noGo;
     }
-    const timeLHS = (0, malloy_types_1.isTemporalField)(lhs.dataType);
+    const timeLHS = (0, malloy_types_1.isTemporalField)(lhs.type);
     const err = errorCascade(timeLHS ? 'error' : 'number', lhs, rhs);
     if (err)
         return err;
     if (timeLHS) {
         let duration = right;
-        if (rhs.dataType !== 'duration') {
+        if (rhs.type !== 'duration') {
             if ((0, granular_result_1.isGranularResult)(lhs)) {
                 duration = new ExprDuration(right, lhs.timeframe);
             }
-            else if (lhs.dataType === 'date') {
+            else if (lhs.type === 'date') {
                 duration = new ExprDuration(right, 'day');
             }
             else {
-                return left.loggedErrorExpr('time-offset-type-mismatch', `Can not offset time by '${rhs.dataType}'`);
+                return left.loggedErrorExpr('time-offset-type-mismatch', `Can not offset time by '${rhs.type}'`);
             }
         }
         return duration.apply(fs, op, left);
@@ -402,10 +426,10 @@ function applyBinary(fs, left, op, right) {
         const err = errorCascade('number', num, denom);
         if (err)
             return err;
-        if (num.dataType !== 'number') {
+        if (num.type !== 'number') {
             left.logError('arithmetic-operation-type-mismatch', 'Numerator must be a number');
         }
-        else if (denom.dataType !== 'number') {
+        else if (denom.type !== 'number') {
             right.logError('arithmetic-operation-type-mismatch', 'Denominator must be a number');
         }
         else {
@@ -414,7 +438,7 @@ function applyBinary(fs, left, op, right) {
                 kids: { left: num.value, right: denom.value },
             };
             return (0, expr_value_1.computedExprValue)({
-                dataType: 'number',
+                dataType: { type: 'number' },
                 value: divmod,
                 from: [num, denom],
             });
@@ -424,10 +448,10 @@ function applyBinary(fs, left, op, right) {
     return left.loggedErrorExpr('unexpected-binary-operator', `Cannot use ${op} operator here`);
 }
 exports.applyBinary = applyBinary;
-function errorCascade(dataType, ...es) {
-    if (es.some(e => e.dataType === 'error')) {
+function errorCascade(type, ...es) {
+    if (es.some(e => e.type === 'error')) {
         return (0, expr_value_1.computedExprValue)({
-            dataType,
+            dataType: { type },
             value: { node: 'error', message: 'cascading error' },
             from: es,
         });
@@ -438,16 +462,16 @@ function errorCascade(dataType, ...es) {
  */
 function unsupportError(l, lhs, r, rhs) {
     const ret = (0, expr_value_1.computedExprValue)({
-        dataType: lhs.dataType,
+        dataType: lhs,
         value: { node: 'error', message: 'sql-native unsupported' },
         from: [lhs, rhs],
     });
-    if (lhs.dataType === 'sql native') {
+    if (lhs.type === 'sql native') {
         l.logError('sql-native-not-allowed-in-expression', { rawType: lhs.rawType });
-        ret.dataType = rhs.dataType;
+        ret.type = rhs.type;
         return ret;
     }
-    if (rhs.dataType === 'sql native') {
+    if (rhs.type === 'sql native') {
         r.logError('sql-native-not-allowed-in-expression', { rawType: rhs.rawType });
         return ret;
     }

package/dist/lang/ast/types/global-name-space.js

@@ -25,6 +25,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDialectFunctions = exports.GlobalNameSpace = void 0;
 const dialect_1 = require("../../../dialect");
 const dialect_map_1 = require("../../../dialect/dialect_map");
+const model_1 = require("../../../model");
 /**
  * This is a global namespace which exists in the root of all Documents
  * and includes SQL function definitions.
@@ -55,8 +56,7 @@ function paramsEqual(a, b) {
             return (param.isVariadic === otherParam.isVariadic &&
                 param.name === otherParam.name &&
                 param.allowedTypes.length === otherParam.allowedTypes.length &&
-                param.allowedTypes.every(t => otherParam.allowedTypes.some(ot => t.dataType === ot.dataType &&
-                    t.expressionType === ot.expressionType)));
+                param.allowedTypes.every(t => otherParam.allowedTypes.some(ot => model_1.TD.eq(t, ot) && t.expressionType === ot.expressionType)));
         }));
 }
 function getDialectFunctions() {

package/dist/lang/ast/types/granular-result.d.ts

@@ -1,7 +1,7 @@
 import { TimestampUnit } from '../../../model/malloy_types';
 import { ExprValue } from './expr-value';
 import { TimeResult } from './time-result';
-export interface GranularResult extends TimeResult {
+export type GranularResult = TimeResult & {
     timeframe: TimestampUnit;
-}
+};
 export declare function isGranularResult(v: ExprValue): v is GranularResult;

package/dist/lang/ast/types/granular-result.js

@@ -24,7 +24,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isGranularResult = void 0;
 function isGranularResult(v) {
-    if (v.dataType === 'date' || v.dataType === 'timestamp') {
+    if (v.type === 'date' || v.type === 'timestamp') {
         return v.timeframe !== undefined;
     }
     return false;

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

@@ -30,19 +30,8 @@ class SpaceField extends space_entry_1.SpaceEntry {
         this.refType = 'field';
     }
     fieldTypeFromFieldDef(def) {
-        const ref = {
-            dataType: def.type,
-            expressionType: 'scalar',
-            evalSpace: 'input',
-        };
-        if (def.expressionType) {
-            ref.expressionType = def.expressionType;
-        }
-        if (ref.dataType === 'sql native' &&
-            def.type === 'sql native' &&
-            def.rawType) {
-            ref.rawType = def.rawType;
-        }
+        const expressionType = def.expressionType || 'scalar';
+        const ref = { ...def, expressionType, evalSpace: 'input' };
         return ref;
     }
     getQueryFieldDef(_fs) {

package/dist/lang/ast/types/space-param.d.ts

@@ -1,4 +1,4 @@
-import { Parameter, TypeDesc } from '../../../model/malloy_types';
+import { FieldDefType, Parameter, TypeDesc } from '../../../model/malloy_types';
 import { SpaceEntry } from './space-entry';
 import { HasParameter } from '../parameters/has-parameter';
 export declare abstract class SpaceParam extends SpaceEntry {
@@ -11,10 +11,12 @@ export declare class AbstractParameter extends SpaceParam {
     _parameter: Parameter | undefined;
     parameter(): Parameter;
     typeDesc(): TypeDesc;
+    entryType(): FieldDefType;
 }
 export declare class DefinedParameter extends SpaceParam {
     readonly paramDef: Parameter;
     constructor(paramDef: Parameter);
     parameter(): Parameter;
     typeDesc(): TypeDesc;
+    entryType(): FieldDefType;
 }

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

@@ -21,9 +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.DefinedParameter = exports.AbstractParameter = exports.SpaceParam = void 0;
 const space_entry_1 = require("./space-entry");
+const TDU = __importStar(require("../typedesc-utils"));
 class SpaceParam extends space_entry_1.SpaceEntry {
     constructor() {
         super(...arguments);
@@ -44,9 +68,14 @@ class AbstractParameter extends SpaceParam {
         return this._parameter;
     }
     typeDesc() {
-        var _a;
-        const type = (_a = this.parameter().type) !== null && _a !== void 0 ? _a : 'error';
-        return { dataType: type, expressionType: 'scalar', evalSpace: 'constant' };
+        return {
+            ...TDU.atomicDef(this.parameter()),
+            expressionType: 'scalar',
+            evalSpace: 'constant',
+        };
+    }
+    entryType() {
+        return this.parameter().type;
     }
 }
 exports.AbstractParameter = AbstractParameter;
@@ -60,13 +89,16 @@ class DefinedParameter extends SpaceParam {
     }
     typeDesc() {
         return {
-            dataType: this.paramDef.type,
+            ...TDU.atomicDef(this.paramDef),
             expressionType: 'scalar',
             // TODO Not sure whether params are considered "input space". It seems like they
             // could be input or constant, depending on usage (same as above).
             evalSpace: 'input',
         };
     }
+    entryType() {
+        return this.paramDef.type;
+    }
 }
 exports.DefinedParameter = DefinedParameter;
 //# sourceMappingURL=space-param.js.map

package/dist/lang/ast/types/time-result.d.ts

@@ -1,6 +1,5 @@
-import { TemporalFieldType, TimestampUnit } from '../../../model/malloy_types';
+import { TemporalTypeDef, TimestampUnit } from '../../../model/malloy_types';
 import { ExprResult } from './expr-result';
-export interface TimeResult extends ExprResult {
-    dataType: TemporalFieldType;
+export type TimeResult = TemporalTypeDef & ExprResult & {
     timeframe?: TimestampUnit;
-}
+};

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

@@ -1,4 +1,4 @@
-import { DocumentLocation, FieldValueType } from '../model/malloy_types';
+import { DocumentLocation, ExpressionValueType } from '../model/malloy_types';
 import { EventStream } from '../runtime_types';
 export type LogSeverity = 'error' | 'warn' | 'debug';
 /**
@@ -37,22 +37,22 @@ export declare class BaseMessageLogger implements MessageLogger {
 }
 type MessageParameterTypes = {
     'pick-type-does-not-match': {
-        pickType: FieldValueType;
-        returnType: FieldValueType;
+        pickType: ExpressionValueType;
+        returnType: ExpressionValueType;
     };
     'pick-else-type-does-not-match': {
-        elseType: FieldValueType;
-        returnType: FieldValueType;
+        elseType: ExpressionValueType;
+        returnType: ExpressionValueType;
     };
     'pick-default-type-does-not-match': {
-        defaultType: FieldValueType;
-        returnType: FieldValueType;
+        defaultType: ExpressionValueType;
+        returnType: ExpressionValueType;
     };
     'pick-missing-else': {};
     'pick-missing-value': {};
     'pick-illegal-partial': {};
     'pick-when-must-be-boolean': {
-        whenType: FieldValueType;
+        whenType: ExpressionValueType;
     };
     'experiment-not-enabled': {
         experimentId: string;
@@ -318,19 +318,19 @@ type MessageParameterTypes = {
     'not-yet-implemented': string;
     'sql-case': string;
     'case-then-type-does-not-match': {
-        thenType: FieldValueType;
-        returnType: FieldValueType;
+        thenType: ExpressionValueType;
+        returnType: ExpressionValueType;
     };
     'case-else-type-does-not-match': {
-        elseType: FieldValueType;
-        returnType: FieldValueType;
+        elseType: ExpressionValueType;
+        returnType: ExpressionValueType;
     };
     'case-when-must-be-boolean': {
-        whenType: FieldValueType;
+        whenType: ExpressionValueType;
     };
     'case-when-type-does-not-match': {
-        whenType: FieldValueType;
-        valueType: FieldValueType;
+        whenType: ExpressionValueType;
+        valueType: ExpressionValueType;
     };
     'or-choices-only': string;
     'sql-in': string;

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

@@ -89,7 +89,7 @@ describe('literals', () => {
         const exprModel = new test_translator_1.BetaExpression(expr);
         expect(exprModel).toTranslate();
         const ir = exprModel.generated();
-        expect(ir.dataType).toEqual(timeType);
+        expect(ir.type).toEqual(timeType);
         if (timeframe) {
             expect((0, granular_result_1.isGranularResult)(ir)).toBeTruthy();
             if ((0, granular_result_1.isGranularResult)(ir)) {

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

@@ -208,8 +208,8 @@ expect.extend({
             return ok;
         }
         const d = exprModel.generated();
-        const pass = d.dataType === returnType;
-        const msg = `Expression type ${d.dataType} ${pass ? '=' : '!='} ${returnType}`;
+        const pass = d.type === returnType;
+        const msg = `Expression type ${d.type} ${pass ? '=' : '!='} ${returnType}`;
         return { pass, message: () => msg };
     },
     toLog: function (s, ...msgs) {