@malloydata/malloy 0.0.203-dev241021171612 → 0.0.203-dev241022210817

package/dist/dialect/dialect.d.ts

@@ -123,5 +123,16 @@ export declare abstract class Dialect {
     abstract sqlTypeToMalloyType(sqlType: string): LeafAtomicTypeDef;
     abstract malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
     abstract validateTypeName(sqlType: string): boolean;
+    /**
+     * Helper function for sql cast implementations. Handles the
+     * wrangling of the raw type and also inferring the source
+     * type if it was not provided.
+     */
+    sqlCastPrep(cast: TypecastExpr): {
+        op: string;
+        srcTypeDef: LeafAtomicTypeDef | undefined;
+        dstTypeDef: LeafAtomicTypeDef | undefined;
+        dstSQLType: string;
+    };
 }
 export {};

package/dist/dialect/dialect.js

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dialect = exports.qtz = exports.inDays = exports.dayIndex = exports.isDialectFieldStruct = void 0;
+const malloy_types_1 = require("../model/malloy_types");
 function isDialectFieldStruct(d) {
     return d.type === 'struct';
 }
@@ -201,6 +202,32 @@ class Dialect {
       ''
     )`;
     }
+    /**
+     * Helper function for sql cast implementations. Handles the
+     * wrangling of the raw type and also inferring the source
+     * type if it was not provided.
+     */
+    sqlCastPrep(cast) {
+        let srcTypeDef = cast.srcType || cast.e.typeDef;
+        const src = (srcTypeDef === null || srcTypeDef === void 0 ? void 0 : srcTypeDef.type) || 'unknown';
+        if (srcTypeDef && !(0, malloy_types_1.isLeafAtomic)(srcTypeDef)) {
+            srcTypeDef = undefined;
+        }
+        if ((0, malloy_types_1.isRawCast)(cast)) {
+            return {
+                op: `${src}::'${cast.dstSQLType}'`,
+                srcTypeDef,
+                dstTypeDef: undefined,
+                dstSQLType: cast.dstSQLType,
+            };
+        }
+        return {
+            op: `${src}::${cast.dstType.type}`,
+            srcTypeDef,
+            dstTypeDef: cast.dstType,
+            dstSQLType: this.malloyTypeToSQLType(cast.dstType),
+        };
+    }
 }
 exports.Dialect = Dialect;
 //# sourceMappingURL=dialect.js.map

package/dist/dialect/duckdb/duckdb.js

@@ -330,10 +330,10 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
         let lVal = from.sql || '';
         let rVal = to.sql || '';
         if (!(0, dialect_1.inDays)(df.units)) {
-            if (from.dataType === 'date') {
+            if (malloy_types_1.TD.isDate(from.typeDef)) {
                 lVal = `${lVal}::TIMESTAMP`;
             }
-            if (to.dataType === 'date') {
+            if (malloy_types_1.TD.isDate(to.typeDef)) {
                 rVal = `${rVal}::TIMESTAMP`;
             }
         }

package/dist/dialect/mysql/mysql.js

@@ -278,7 +278,7 @@ class MySQLDialect extends dialect_1.Dialect {
         if (trunc.units === 'week') {
             truncThis = `DATE_SUB(${truncThis}, INTERVAL DAYOFWEEK(${truncThis}) - 1 DAY)`;
         }
-        if (trunc.e.dataType === 'timestamp') {
+        if (malloy_types_1.TD.isTimestamp(trunc.e.typeDef)) {
             const tz = (0, dialect_1.qtz)(qi);
             if (tz) {
                 const civilSource = `(CONVERT_TZ(${truncThis}, 'UTC','${tz}'))`;
@@ -318,7 +318,7 @@ class MySQLDialect extends dialect_1.Dialect {
     sqlTimeExtractExpr(qi, te) {
         const msUnits = msExtractionMap[te.units] || te.units;
         let extractFrom = te.e.sql;
-        if (te.e.dataType === 'timestamp') {
+        if (malloy_types_1.TD.isTimestamp(te.e.typeDef)) {
             const tz = (0, dialect_1.qtz)(qi);
             if (tz) {
                 extractFrom = `CONVERT_TZ(${extractFrom}, 'UTC', '${tz}')`;
@@ -341,34 +341,31 @@ class MySQLDialect extends dialect_1.Dialect {
         return `(${df.kids.base.sql})${df.op}${interval}`;
     }
     sqlCast(qi, cast) {
-        const op = `${cast.srcType}::${cast.dstType}`;
+        const srcSQL = cast.e.sql || 'internal-error-in-sql-generation';
+        const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         const tz = (0, dialect_1.qtz)(qi);
         if (op === 'timestamp::date' && tz) {
-            return `CAST(CONVERT_TZ(${cast.e.sql}, 'UTC', '${tz}') AS DATE) `;
+            return `CAST(CONVERT_TZ(${srcSQL}, 'UTC', '${tz}') AS DATE) `;
         }
         else if (op === 'date::timestamp' && tz) {
-            return ` CONVERT_TZ(${cast.e.sql}, '${tz}', 'UTC')`;
+            return ` CONVERT_TZ(${srcSQL}, '${tz}', 'UTC')`;
         }
-        if (cast.srcType !== cast.dstType) {
-            const dstType = typeof cast.dstType === 'string'
-                ? this.malloyTypeToSQLType({ type: cast.dstType })
-                : cast.dstType.raw;
+        if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             if (cast.safe) {
                 throw new Error("Mysql dialect doesn't support Safe Cast");
             }
-            if (cast.dstType === 'string') {
-                return `CONCAT(${cast.e.sql}, '')`;
+            if (malloy_types_1.TD.isString(dstTypeDef)) {
+                return `CONCAT(${srcSQL}, '')`;
             }
-            return `CAST(${cast.e.sql}  AS ${dstType})`;
+            return `CAST(${srcSQL} AS ${dstSQLType})`;
         }
-        // LTNOTE: I don't understand how this could be undefined.
-        return cast.e.sql || 'weirdly undefined';
+        return srcSQL;
     }
     sqlRegexpMatch(df) {
         return `REGEXP_LIKE(${df.kids.expr.sql}, ${df.kids.regex.sql})`;
     }
     sqlLiteralTime(qi, lt) {
-        if (lt.dataType === 'date') {
+        if (malloy_types_1.TD.isDate(lt.typeDef)) {
             return `DATE '${lt.literal}'`;
         }
         const tz = lt.timezone || (0, dialect_1.qtz)(qi);

package/dist/dialect/pg_impl.js

@@ -7,6 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresBase = exports.timeExtractMap = void 0;
+const malloy_types_1 = require("../model/malloy_types");
 const dialect_1 = require("./dialect");
 exports.timeExtractMap = {
     'day_of_week': 'dow',
@@ -21,7 +22,7 @@ class PostgresBase extends dialect_1.Dialect {
         // adjusting for monday/sunday weeks
         const week = df.units === 'week';
         const truncThis = week ? `${df.e.sql} + INTERVAL '1' DAY` : df.e.sql;
-        if (df.e.dataType === 'timestamp') {
+        if (malloy_types_1.TD.isTimestamp(df.e.typeDef)) {
             const tz = (0, dialect_1.qtz)(qi);
             if (tz) {
                 const civilSource = `(${truncThis}::TIMESTAMPTZ AT TIME ZONE '${tz}')`;
@@ -44,7 +45,7 @@ class PostgresBase extends dialect_1.Dialect {
     sqlTimeExtractExpr(qi, from) {
         const units = exports.timeExtractMap[from.units] || from.units;
         let extractFrom = from.e.sql;
-        if (from.e.dataType === 'timestamp') {
+        if (malloy_types_1.TD.isTimestamp(from.e.typeDef)) {
             const tz = (0, dialect_1.qtz)(qi);
             if (tz) {
                 extractFrom = `(${extractFrom}::TIMESTAMPTZ AT TIME ZONE '${tz}')`;
@@ -55,7 +56,7 @@ class PostgresBase extends dialect_1.Dialect {
     }
     sqlCast(qi, cast) {
         const expr = cast.e.sql || '';
-        const op = `${cast.srcType}::${cast.dstType}`;
+        const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         const tz = (0, dialect_1.qtz)(qi);
         if (op === 'timestamp::date' && tz) {
             const tstz = `${expr}::TIMESTAMPTZ`;
@@ -64,12 +65,9 @@ class PostgresBase extends dialect_1.Dialect {
         else if (op === 'date::timestamp' && tz) {
             return `CAST((${expr})::TIMESTAMP AT TIME ZONE '${tz}' AS TIMESTAMP)`;
         }
-        if (cast.srcType !== cast.dstType) {
-            const dstType = typeof cast.dstType === 'string'
-                ? this.malloyTypeToSQLType({ type: cast.dstType })
-                : cast.dstType.raw;
+        if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
-            return `${castFunc}(${expr} AS ${dstType})`;
+            return `${castFunc}(${expr} AS ${dstSQLType})`;
         }
         return expr;
     }
@@ -77,7 +75,7 @@ class PostgresBase extends dialect_1.Dialect {
         return `${df.kids.expr.sql} ~ ${df.kids.regex.sql}`;
     }
     sqlLiteralTime(qi, lt) {
-        if (lt.dataType === 'date') {
+        if (malloy_types_1.TD.isDate(lt.typeDef)) {
             return `DATE '${lt.literal}'`;
         }
         const tz = lt.timezone || (0, dialect_1.qtz)(qi);

package/dist/dialect/snowflake/snowflake.js

@@ -239,7 +239,7 @@ ${(0, utils_1.indent)(sql)}
     sqlTruncExpr(qi, te) {
         const tz = (0, dialect_1.qtz)(qi);
         let truncThis = te.e.sql;
-        if (tz && te.e.dataType === 'timestamp') {
+        if (tz && malloy_types_1.TD.isTimestamp(te.e.typeDef)) {
             truncThis = `CONVERT_TIMEZONE('${tz}',${truncThis})`;
         }
         return `DATE_TRUNC('${te.units}',${truncThis})`;
@@ -248,7 +248,7 @@ ${(0, utils_1.indent)(sql)}
         const extractUnits = extractionMap[from.units] || from.units;
         let extractFrom = from.e.sql;
         const tz = (0, dialect_1.qtz)(qi);
-        if (tz && from.e.dataType === 'timestamp') {
+        if (tz && malloy_types_1.TD.isTimestamp(from.e.typeDef)) {
             extractFrom = `CONVERT_TIMEZONE('${tz}', ${extractFrom})`;
         }
         return `EXTRACT(${extractUnits} FROM ${extractFrom})`;
@@ -271,10 +271,11 @@ ${(0, utils_1.indent)(sql)}
     }
     sqlCast(qi, cast) {
         const src = cast.e.sql || '';
-        if (cast.srcType === cast.dstType) {
+        const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
+        if (malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             return src;
         }
-        if (cast.safe && typeof cast.srcType !== 'string') {
+        if (cast.safe && !malloy_types_1.TD.isString(srcTypeDef)) {
             // safe cast is only supported for a few combinations of src -> dst types
             // so we will not support it in the general case
             // see: https://docs.snowflake.com/en/sql-reference/functions/try_cast
@@ -283,22 +284,19 @@ ${(0, utils_1.indent)(sql)}
         }
         const tz = (0, dialect_1.qtz)(qi);
         // casting timestamps and dates
-        if (cast.dstType === 'date' && cast.srcType === 'timestamp') {
+        if (op === 'timestamp::date') {
             let castExpr = src;
             if (tz) {
                 castExpr = `CONVERT_TIMEZONE('${tz}', ${castExpr})`;
             }
             return `TO_DATE(${castExpr})`;
         }
-        else if (cast.dstType === 'timestamp' && cast.srcType === 'date') {
+        else if (op === 'date::timestamp') {
             const retExpr = `TO_TIMESTAMP(${src})`;
             return this.atTz(retExpr, tz);
         }
-        const dstType = typeof cast.dstType === 'string'
-            ? this.malloyTypeToSQLType({ type: cast.dstType })
-            : cast.dstType.raw;
         const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
-        return `${castFunc}(${src} AS ${dstType})`;
+        return `${castFunc}(${src} AS ${dstSQLType})`;
     }
     sqlLiteralTime(qi, lf) {
         var _a;
@@ -313,19 +311,16 @@ ${(0, utils_1.indent)(sql)}
             ret = `${retTimeString} || ${targetTimeZoneSuffix}`;
             ret = `(${ret})::TIMESTAMP_TZ`;
         }
-        switch (lf.dataType) {
-            case 'date':
-                return `TO_DATE(${ret})`;
-            case 'timestamp': {
-                return ret;
-            }
+        if (malloy_types_1.TD.isDate(lf.typeDef)) {
+            return `TO_DATE(${ret})`;
         }
+        return ret;
     }
     sqlMeasureTimeExpr(df) {
         const from = df.kids.left;
         const to = df.kids.right;
         let extractUnits = 'nanoseconds';
-        if (from.dataType === 'date' || to.dataType === 'date') {
+        if (malloy_types_1.TD.isDate(from.typeDef) || malloy_types_1.TD.isDate(to.typeDef)) {
             extractUnits = 'seconds';
         }
         return `TIMESTAMPDIFF(

package/dist/dialect/standardsql/standardsql.js

@@ -308,7 +308,7 @@ ${(0, utils_1.indent)(sql)}
     sqlTruncExpr(qi, trunc) {
         const tz = qtz(qi);
         const tzAdd = tz ? `, "${tz}"` : '';
-        if (trunc.e.dataType === 'date') {
+        if (malloy_types_1.TD.isDate(trunc.e.typeDef)) {
             if (dateMeasureable(trunc.units)) {
                 return `DATE_TRUNC(${trunc.e.sql},${trunc.units})`;
             }
@@ -318,13 +318,13 @@ ${(0, utils_1.indent)(sql)}
     }
     sqlTimeExtractExpr(qi, te) {
         const extractTo = extractMap[te.units] || te.units;
-        const tz = te.e.dataType === 'timestamp' && qtz(qi);
+        const tz = malloy_types_1.TD.isTimestamp(te.e.typeDef) && qtz(qi);
         const tzAdd = tz ? ` AT TIME ZONE '${tz}'` : '';
         return `EXTRACT(${extractTo} FROM ${te.e.sql}${tzAdd})`;
     }
     sqlAlterTimeExpr(df) {
         const from = df.kids.base;
-        let dataType = from.dataType;
+        let dataType = from === null || from === void 0 ? void 0 : from.typeDef.type;
         let sql = from.sql;
         if (df.units !== 'day' && timestampMeasureable(df.units)) {
             // The units must be done in timestamp, no matter the input type
@@ -340,16 +340,16 @@ ${(0, utils_1.indent)(sql)}
         const funcTail = df.op === '+' ? '_ADD' : '_SUB';
         const funcName = `${dataType.toUpperCase()}${funcTail}`;
         const newTime = `${funcName}(${sql}, INTERVAL ${df.kids.delta.sql} ${df.units})`;
-        if (dataType === from.dataType) {
+        if (dataType === from.typeDef.type) {
             return newTime;
         }
-        return `${from.dataType.toUpperCase()}(${newTime})`;
+        return `${from.typeDef.type.toUpperCase()}(${newTime})`;
     }
     ignoreInProject(fieldName) {
         return fieldName === '_PARTITIONTIME';
     }
     sqlCast(qi, cast) {
-        const op = `${cast.srcType}::${cast.dstType}`;
+        const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         const tz = qtz(qi);
         const src = cast.e.sql || '';
         if (op === 'timestamp::date' && tz) {
@@ -358,12 +358,9 @@ ${(0, utils_1.indent)(sql)}
         if (op === 'date::timestamp' && tz) {
             return `TIMESTAMP(${src}, '${tz}')`;
         }
-        if (cast.srcType !== cast.dstType) {
-            const dstType = typeof cast.dstType === 'string'
-                ? this.malloyTypeToSQLType({ type: cast.dstType })
-                : cast.dstType.raw;
+        if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             const castFunc = cast.safe ? 'SAFE_CAST' : 'CAST';
-            return `${castFunc}(${src} AS ${dstType})`;
+            return `${castFunc}(${src} AS ${dstSQLType})`;
         }
         return src;
     }
@@ -371,10 +368,10 @@ ${(0, utils_1.indent)(sql)}
         return `REGEXP_CONTAINS(${match.kids.expr.sql},${match.kids.regex.sql})`;
     }
     sqlLiteralTime(qi, lit) {
-        if (lit.dataType === 'date') {
+        if (malloy_types_1.TD.isDate(lit.typeDef)) {
             return `DATE('${lit.literal}')`;
         }
-        else if (lit.dataType === 'timestamp') {
+        else if (malloy_types_1.TD.isTimestamp(lit.typeDef)) {
             let timestampArgs = `'${lit.literal}'`;
             const tz = lit.timezone || qtz(qi);
             if (tz && tz !== 'UTC') {
@@ -383,7 +380,7 @@ ${(0, utils_1.indent)(sql)}
             return `TIMESTAMP(${timestampArgs})`;
         }
         else {
-            throw new Error(`Unsupported Literal time format ${lit.dataType}`);
+            throw new Error(`Unsupported Literal time format ${lit.typeDef}`);
         }
     }
     sqlMeasureTimeExpr(measure) {
@@ -405,10 +402,10 @@ ${(0, utils_1.indent)(sql)}
             if (!timestampMeasureable(measureIn)) {
                 throw new Error(`Measure in '${measureIn} not implemented`);
             }
-            if (from.dataType !== to.dataType) {
+            if (!malloy_types_1.TD.eq(from.typeDef, to.typeDef)) {
                 throw new Error("Can't measure difference between different types");
             }
-            if (from.dataType === 'date') {
+            if (malloy_types_1.TD.isDate(from.typeDef)) {
                 lVal = `TIMESTAMP(${lVal})`;
                 rVal = `TIMESTAMP(${rVal})`;
             }

package/dist/dialect/trino/trino.js

@@ -370,22 +370,19 @@ ${(0, utils_1.indent)(sql)}
         return `DATE_ADD('${timeframe}', ${n}, ${df.kids.base.sql})`;
     }
     sqlCast(qi, cast) {
-        const op = `${cast.srcType}=>${cast.dstType}`;
+        const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         const tz = qtz(qi);
         const expr = cast.e.sql || '';
-        if (op === 'timestamp=>date' && tz) {
+        if (op === 'timestamp::date' && tz) {
             const tstz = `CAST(${expr} as TIMESTAMP)`;
             return `CAST((${tstz}) AT TIME ZONE '${tz}' AS DATE)`;
         }
-        else if (op === 'date=>timestamp' && tz) {
+        else if (op === 'date::timestamp' && tz) {
             return `CAST(CONCAT(CAST(CAST(${expr} AS TIMESTAMP) AS VARCHAR), ' ${tz}') AS TIMESTAMP WITH TIME ZONE)`;
         }
-        if (cast.srcType !== cast.dstType) {
-            const dstType = typeof cast.dstType === 'string'
-                ? this.malloyTypeToSQLType({ type: cast.dstType })
-                : cast.dstType.raw;
+        if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
-            return `${castFunc}(${expr} AS ${dstType})`;
+            return `${castFunc}(${expr} AS ${dstSQLType})`;
         }
         return expr;
     }
@@ -411,10 +408,10 @@ ${(0, utils_1.indent)(sql)}
             if (!timestampMeasureable(measureIn)) {
                 throw new Error(`Measure in '${measureIn} not implemented`);
             }
-            if (from.dataType !== to.dataType) {
+            if (!malloy_types_1.TD.eq(from.typeDef, to.typeDef)) {
                 throw new Error("Can't measure difference between different types");
             }
-            if (from.dataType === 'date') {
+            if (malloy_types_1.TD.isDate(from.typeDef)) {
                 lVal = `CAST(${lVal} AS TIMESTAMP)`;
                 rVal = `CAST(${rVal} AS TIMESTAMP)`;
             }
@@ -496,7 +493,7 @@ ${(0, utils_1.indent)(sql)}
         return sqlType.match(/^[A-Za-z\s(),<>0-9]*$/) !== null;
     }
     sqlLiteralTime(qi, lit) {
-        if (lit.dataType === 'date') {
+        if (malloy_types_1.TD.isDate(lit.typeDef)) {
             return `DATE '${lit.literal}'`;
         }
         const tz = lit.timezone || qtz(qi);
@@ -508,7 +505,7 @@ ${(0, utils_1.indent)(sql)}
     sqlTimeExtractExpr(qi, from) {
         const pgUnits = pg_impl_1.timeExtractMap[from.units] || from.units;
         let extractFrom = from.e.sql || '';
-        if (from.e.dataType === 'timestamp') {
+        if (malloy_types_1.TD.isTimestamp(from.e.typeDef)) {
             const tz = qtz(qi);
             if (tz) {
                 extractFrom = `at_timezone(${extractFrom},'${tz}')`;

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

@@ -61,7 +61,7 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
             if (this.truncate) {
                 tsVal.value = {
                     node: 'trunc',
-                    e: { ...exprVal.value, dataType: exprVal.dataType },
+                    e: (0, malloy_types_1.mkTemporal)(exprVal.value, exprVal.dataType),
                     units: timeframe,
                 };
             }

package/dist/lang/ast/expressions/expr-record-literal.d.ts

@@ -12,5 +12,5 @@ export declare class RecordLiteral extends ExpressionDef {
     readonly pairs: RecordElement[];
     elementType: string;
     constructor(pairs: RecordElement[]);
-    getExpression(fs: FieldSpace): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/expr-record-literal.js

@@ -7,7 +7,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecordLiteral = exports.RecordElement = void 0;
-const model_1 = require("../../../model");
 const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
 class RecordElement extends malloy_element_1.MalloyElement {
@@ -27,30 +26,34 @@ class RecordLiteral extends expression_def_1.ExpressionDef {
         this.elementType = 'record literal';
         this.has({ pairs });
     }
-    getExpression(fs) {
-        const recLit = {
-            node: 'recordLiteral',
-            kids: {},
-        };
-        let resultExprType = 'scalar';
-        for (const el of this.pairs) {
-            const xVal = el.value.getExpression(fs);
-            const expr = { dataType: 'error', ...xVal.value };
-            if (expr.dataType === 'error' && (0, model_1.isAtomicFieldType)(xVal.dataType)) {
-                expr.dataType = xVal.dataType;
-            }
-            if (expr.dataType === 'error' && xVal.dataType !== 'error') {
-                this.logError('illegal-record-property-type', `Type '${xVal.dataType}' not a legal record value`);
-            }
-            recLit.kids[el.key] = expr;
-            resultExprType = (0, model_1.maxExpressionType)(xVal.expressionType, resultExprType);
-        }
-        return {
-            dataType: 'record',
-            value: recLit,
-            expressionType: resultExprType,
-            evalSpace: 'literal',
-        };
+    getExpression(_fs) {
+        throw new Error('get expression on record todo');
+        // const recLit: RecordLiteralNode = {
+        //   node: 'recordLiteral',
+        //   kids: {},
+        // };
+        // let resultExprType: ExpressionType = 'scalar';
+        // for (const el of this.pairs) {
+        //   const xVal = el.value.getExpression(fs);
+        //   const expr: TypedExpr = {typeDef: 'error', ...xVal.value};
+        //   if (TD.isError(expr.typeDef) && isAtomicFieldType(xVal.dataType)) {
+        //     expr.typeDef = xVal.dataType;
+        //   }
+        //   if (TD.isError(expr.typeDef) && xVal.dataType !== 'error') {
+        //     this.logError(
+        //       'illegal-record-property-type',
+        //       `Type '${xVal.dataType}' not a legal record value`
+        //     );
+        //   }
+        //   recLit.kids[el.key] = expr;
+        //   resultExprType = maxExpressionType(xVal.expressionType, resultExprType);
+        // }
+        // return {
+        //   dataType: 'record',
+        //   value: recLit,
+        //   expressionType: resultExprType,
+        //   evalSpace: 'literal',
+        // };
     }
 }
 exports.RecordLiteral = RecordLiteral;

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

@@ -105,8 +105,8 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                         node: 'timeDiff',
                         units: extractTo,
                         kids: {
-                            left: { ...first.value, dataType: valueType },
-                            right: { ...last.value, dataType: valueType },
+                            left: (0, malloy_types_1.mkTemporal)(first.value, valueType),
+                            right: (0, malloy_types_1.mkTemporal)(last.value, valueType),
                         },
                     },
                 };
@@ -120,7 +120,7 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                         evalSpace: argV.evalSpace,
                         value: {
                             node: 'extract',
-                            e: { ...argV.value, dataType: argV.dataType },
+                            e: (0, malloy_types_1.mkTemporal)(argV.value, argV.dataType),
                             units: extractTo,
                         },
                     };

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

@@ -46,11 +46,11 @@ class ExprTime extends expression_def_1.ExpressionDef {
             const toTs = {
                 node: 'cast',
                 safe: false,
-                dstType: timeType,
+                dstType: { type: timeType },
                 e: expr.value,
             };
             if ((0, malloy_types_1.isTemporalField)(expr.dataType)) {
-                toTs.srcType = expr.dataType;
+                toTs.srcType = { type: expr.dataType };
             }
             value = toTs;
         }

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

@@ -84,7 +84,7 @@ class ForRange extends expression_def_1.ExpressionDef {
                 from = tsVersion;
             }
             else {
-                from = (0, time_utils_1.castDateToTimestamp)(from);
+                from = (0, time_utils_1.castTo)('timestamp', from, 'date');
             }
             rangeStart = new expr_time_1.ExprTime('timestamp', from, startV.expressionType);
         }

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

@@ -72,7 +72,7 @@ class TimeLiteral extends expression_def_1.ExpressionDef {
         const timeFrag = {
             node: 'timeLiteral',
             literal: val,
-            dataType: typ,
+            typeDef: { type: typ },
         };
         if (this.timeZone) {
             timeFrag.timezone = this.timeZone;

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

@@ -4,7 +4,5 @@ export declare function timeOffset(timeType: TemporalFieldType, from: Expr, op:
 export declare function castTo(castType: CastType | {
     raw: string;
 }, from: Expr, fromType: FieldValueType, safe?: boolean): TypecastExpr;
-export declare function castTimestampToDate(from: Expr, safe?: boolean): TypecastExpr;
-export declare function castDateToTimestamp(from: Expr, safe?: boolean): TypecastExpr;
 export declare function resolution(timeframe: string): TemporalFieldType;
-export declare function timeResult(t: TimeResult, tt: TimestampUnit | undefined): TimeResult;
+export declare function mkTimeResult(t: TimeResult, tt: TimestampUnit | undefined): TimeResult;