@malloydata/malloy 0.0.222 → 0.0.223-dev241213043533

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

@@ -33,6 +33,7 @@ exports.ArrayLiteral = void 0;
 const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const TDU = __importStar(require("../typedesc-utils"));
+const expr_record_literal_1 = require("./expr-record-literal");
 class ArrayLiteral extends expression_def_1.ExpressionDef {
     constructor(elements) {
         super();
@@ -46,7 +47,9 @@ class ArrayLiteral extends expression_def_1.ExpressionDef {
         let firstValue = undefined;
         if (this.elements.length > 0) {
             for (const nextElement of this.elements) {
-                const v = nextElement.getExpression(fs);
+                const v = firstValue && nextElement instanceof expr_record_literal_1.RecordLiteral
+                    ? nextElement.getNextElement(fs, firstValue)
+                    : nextElement.getExpression(fs);
                 fromValues.push(v);
                 if (v.type === 'error') {
                     continue;

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

@@ -2,15 +2,24 @@ import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
 import { MalloyElement } from '../types/malloy-element';
+import { ExprIdReference } from './expr-id-reference';
+export type ElementDetails = {
+    path: ExprIdReference;
+} | {
+    key?: string;
+    value: ExpressionDef;
+};
 export declare class RecordElement extends MalloyElement {
-    readonly key: string;
-    readonly value: ExpressionDef;
     elementType: string;
-    constructor(key: string, value: ExpressionDef);
+    value: ExpressionDef;
+    key?: string;
+    constructor(val: ElementDetails);
 }
 export declare class RecordLiteral extends ExpressionDef {
     readonly pairs: RecordElement[];
     elementType: string;
     constructor(pairs: RecordElement[]);
     getExpression(fs: FieldSpace): ExprValue;
+    getRecord(fs: FieldSpace, kidNames: string[]): ExprValue;
+    getNextElement(fs: FieldSpace, headValue: ExprValue): ExprValue;
 }

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

@@ -36,12 +36,22 @@ const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
 const TDU = __importStar(require("../typedesc-utils"));
 class RecordElement extends malloy_element_1.MalloyElement {
-    constructor(key, value) {
+    constructor(val) {
         super();
-        this.key = key;
-        this.value = value;
         this.elementType = 'record element';
-        this.has({ value });
+        if ('value' in val) {
+            this.value = val.value;
+            this.has({ value: val.value });
+            if (val.key) {
+                this.key = val.key;
+            }
+        }
+        else {
+            this.has({ path: val.path });
+            this.value = val.path;
+            const parts = val.path.fieldReference.path;
+            this.key = parts[parts.length - 1];
+        }
     }
 }
 exports.RecordElement = RecordElement;
@@ -53,6 +63,10 @@ class RecordLiteral extends expression_def_1.ExpressionDef {
         this.has({ pairs });
     }
     getExpression(fs) {
+        return this.getRecord(fs, []);
+    }
+    getRecord(fs, kidNames) {
+        var _a;
         const recLit = {
             node: 'recordLiteral',
             kids: {},
@@ -62,15 +76,22 @@ class RecordLiteral extends expression_def_1.ExpressionDef {
             },
         };
         const dependents = [];
+        let kidIndex = 0;
         for (const el of this.pairs) {
+            const key = (_a = el.key) !== null && _a !== void 0 ? _a : kidNames[kidIndex];
+            kidIndex += 1;
+            if (key === undefined) {
+                el.logError('record-literal-needs-keys', 'Anonymous record element not legal here');
+                continue;
+            }
             const xVal = el.value.getExpression(fs);
             if (model_1.TD.isAtomic(xVal)) {
                 dependents.push(xVal);
-                recLit.kids[el.key] = xVal.value;
-                recLit.typeDef.fields.push((0, model_1.mkFieldDef)(TDU.atomicDef(xVal), el.key));
+                recLit.kids[key] = xVal.value;
+                recLit.typeDef.fields.push((0, model_1.mkFieldDef)(TDU.atomicDef(xVal), key));
             }
             else {
-                this.logError('illegal-record-property-type', `Record property '${el.key} is type '${xVal.type}', which is not a legal property value type`);
+                el.value.logError('illegal-record-property-type', `Record property '${el.key} is type '${xVal.type}', which is not a legal property value type`);
             }
         }
         return (0, expr_value_1.computedExprValue)({
@@ -79,6 +100,13 @@ class RecordLiteral extends expression_def_1.ExpressionDef {
             from: dependents,
         });
     }
+    getNextElement(fs, headValue) {
+        const recLit = headValue.value;
+        if (recLit.node === 'recordLiteral') {
+            return this.getRecord(fs, Object.keys(recLit.kids));
+        }
+        return this.getRecord(fs, []);
+    }
 }
 exports.RecordLiteral = RecordLiteral;
 //# sourceMappingURL=expr-record-literal.js.map

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

@@ -2603,9 +2603,9 @@ export declare class RecordRefContext extends RecordElementContext {
     accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
 }
 export declare class RecordExprContext extends RecordElementContext {
-    recordKey(): RecordKeyContext;
-    IS(): TerminalNode;
     fieldExpr(): FieldExprContext;
+    recordKey(): RecordKeyContext | undefined;
+    IS(): TerminalNode | undefined;
     constructor(ctx: RecordElementContext);
     enterRule(listener: MalloyParserListener): void;
     exitRule(listener: MalloyParserListener): void;