ts2workflows 0.9.0 → 0.11.0

package/dist/transpiler/statements.js

@@ -3,18 +3,15 @@ import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
 import { AssignStepAST, CallStepAST, ForRangeStepAST, ForStepAST, JumpTargetAST, NextStepAST, ParallelStepAST, RaiseStepAST, ReturnStepAST, StepsStepAST, SwitchStepAST, TryStepAST, } from '../ast/steps.js';
 import { BinaryExpression, FunctionInvocationExpression, MemberExpression, PrimitiveExpression, VariableReferenceExpression, asExpression, isExpression, isFullyQualifiedName, isLiteral, isPure, nullEx, safeAsExpression, trueEx, } from '../ast/expressions.js';
 import { InternalTranspilingError, WorkflowSyntaxError } from '../errors.js';
-import { chainPairs, isRecord } from '../utils.js';
-import { convertExpression, convertMemberExpression, convertObjectExpression, convertObjectAsExpressionValues, isMagicFunction, throwIfSpread, isMagicFunctionStatmentOnly, } from './expressions.js';
+import { isRecord } from '../utils.js';
+import { convertExpression, convertMemberExpression, convertObjectExpression, convertObjectAsExpressionValues, isIntrinsic, throwIfSpread, isIntrinsicStatment as isIntrinsicStatement, convertVariableNameExpression, } from './expressions.js';
 import { blockingFunctions } from './generated/functionMetadata.js';
 export function parseStatement(node, ctx) {
-    return parseStatementRecursively(node, undefined, ctx);
-}
-function parseStatementRecursively(node, nextNode, ctx) {
     switch (node.type) {
         case AST_NODE_TYPES.BlockStatement:
-            return chainPairs(R.partialRight(parseStatementRecursively, [ctx]), node.body);
+            return node.body.flatMap((node) => parseStatement(node, ctx));
         case AST_NODE_TYPES.VariableDeclaration:
-            return convertVariableDeclarations(node.declarations, ctx);
+            return convertVariableDeclarations(node, ctx);
         case AST_NODE_TYPES.ExpressionStatement:
             if (node.expression.type === AST_NODE_TYPES.AssignmentExpression) {
                 return assignmentExpressionToSteps(node.expression, ctx);
@@ -45,14 +42,8 @@ function parseStatementRecursively(node, nextNode, ctx) {
             return [breakStatementToNextStep(node, ctx)];
         case AST_NODE_TYPES.ContinueStatement:
             return [continueStatementToNextStep(node, ctx)];
-        case AST_NODE_TYPES.TryStatement: {
-            let retryPolicy = undefined;
-            if (nextNode?.type === AST_NODE_TYPES.ExpressionStatement &&
-                nextNode.expression.type === AST_NODE_TYPES.CallExpression) {
-                retryPolicy = parseRetryPolicy(nextNode.expression);
-            }
-            return tryStatementToTrySteps(node, retryPolicy, ctx);
-        }
+        case AST_NODE_TYPES.TryStatement:
+            return tryStatementToTrySteps(node, ctx);
         case AST_NODE_TYPES.LabeledStatement:
             return labeledStep(node, ctx);
         case AST_NODE_TYPES.EmptyStatement:
@@ -68,8 +59,11 @@ function parseStatementRecursively(node, nextNode, ctx) {
             throw new WorkflowSyntaxError(`TODO: encountered unsupported type: ${node.type}`, node.loc);
     }
 }
-function convertVariableDeclarations(declarations, ctx) {
-    return declarations.flatMap((decl) => {
+function convertVariableDeclarations(node, ctx) {
+    if (node.kind !== 'const' && node.kind !== 'let') {
+        throw new WorkflowSyntaxError('Only const and let variable declarations are supported', node.loc);
+    }
+    return node.declarations.flatMap((decl) => {
         if (decl.id.type === AST_NODE_TYPES.Identifier) {
             return convertInitializer(decl.id.name, decl.init, ctx);
         }
@@ -89,14 +83,15 @@ function convertInitializer(targetVariableName, initializer, ctx) {
         const calleeName = initializer.callee.type === AST_NODE_TYPES.Identifier
             ? initializer.callee.name
             : undefined;
-        if (calleeName && isMagicFunctionStatmentOnly(calleeName)) {
+        if (calleeName && isIntrinsicStatement(calleeName)) {
             throw new WorkflowSyntaxError(`"${calleeName}" can't be called as part of an expression`, initializer.callee.loc);
         }
         return callExpressionToStep(initializer, targetVariableName, ctx);
     }
     else {
+        const name = new VariableReferenceExpression(targetVariableName);
         const value = initializer === null ? nullEx : convertExpression(initializer);
-        return [new AssignStepAST([[targetVariableName, value]])];
+        return [new AssignStepAST([{ name, value }])];
     }
 }
 function convertArrayDestructuring(arrayPattern, initializer, ctx) {
@@ -124,12 +119,12 @@ function arrayDestructuringSteps(patterns, initializerExpression, ctx) {
     if (patterns.filter((p) => p !== null).length === 0) {
         return [];
     }
-    const __temp_len = `${tempName(ctx)}_len`;
+    const __temp_len = new VariableReferenceExpression(`${tempName(ctx)}_len`);
     const initializeVariables = [
-        [
-            __temp_len,
-            new FunctionInvocationExpression('len', [initializerExpression]),
-        ],
+        {
+            name: __temp_len,
+            value: new FunctionInvocationExpression('len', [initializerExpression]),
+        },
     ];
     const branches = R.reverse(patterns).flatMap((pat, i) => {
         if (pat === null) {
@@ -138,7 +133,7 @@ function arrayDestructuringSteps(patterns, initializerExpression, ctx) {
         else {
             return [
                 {
-                    condition: new BinaryExpression(new VariableReferenceExpression(__temp_len), '>=', new PrimitiveExpression(patterns.length - i)),
+                    condition: new BinaryExpression(__temp_len, '>=', new PrimitiveExpression(patterns.length - i)),
                     steps: arrayElementsDestructuringSteps(patterns, initializerExpression, patterns.length - i, ctx),
                 },
             ];
@@ -161,14 +156,15 @@ function arrayElementsDestructuringSteps(patterns, initializerExpression, take,
         switch (pat?.type) {
             case AST_NODE_TYPES.MemberExpression:
             case AST_NODE_TYPES.Identifier: {
-                const name = convertExpression(pat).toString();
-                return [new AssignStepAST([[name, iElement]])];
+                const name = convertVariableNameExpression(pat);
+                return [new AssignStepAST([{ name, value: iElement }])];
             }
             case AST_NODE_TYPES.AssignmentPattern: {
                 if (pat.left.type !== AST_NODE_TYPES.Identifier) {
                     throw new WorkflowSyntaxError('Default value can be used only with an identifier', pat.left.loc);
                 }
-                return [new AssignStepAST([[pat.left.name, iElement]])];
+                const name = new VariableReferenceExpression(pat.left.name);
+                return [new AssignStepAST([{ name, value: iElement }])];
             }
             case AST_NODE_TYPES.ObjectPattern:
                 return objectDestructuringSteps(pat.properties, iElement, ctx);
@@ -192,11 +188,18 @@ function extractDefaultAssignmentsFromDestructuringPattern(pat) {
             if (pat.left.type !== AST_NODE_TYPES.Identifier) {
                 throw new WorkflowSyntaxError('Default value can be used only with an identifier', pat.left.loc);
             }
-            return [[pat.left.name, convertExpression(pat.right)]];
+            return [
+                {
+                    name: new VariableReferenceExpression(pat.left.name),
+                    value: convertExpression(pat.right),
+                },
+            ];
         case AST_NODE_TYPES.Identifier:
-            return [[pat.name, nullEx]];
+            return [
+                { name: new VariableReferenceExpression(pat.name), value: nullEx },
+            ];
         case AST_NODE_TYPES.MemberExpression:
-            return [[convertExpression(pat).toString(), nullEx]];
+            return [{ name: convertVariableNameExpression(pat), value: nullEx }];
         case AST_NODE_TYPES.ObjectPattern:
             return pat.properties.flatMap((p) => {
                 if (p.type === AST_NODE_TYPES.RestElement) {
@@ -217,7 +220,12 @@ function extractDefaultAssignmentsFromDestructuringPattern(pat) {
             if (pat.argument.type !== AST_NODE_TYPES.Identifier) {
                 throw new WorkflowSyntaxError('Identifier expected', pat.argument.loc);
             }
-            return [[pat.argument.name, new PrimitiveExpression([])]];
+            return [
+                {
+                    name: new VariableReferenceExpression(pat.argument.name),
+                    value: new PrimitiveExpression([]),
+                },
+            ];
         default:
             return [];
     }
@@ -233,23 +241,23 @@ function arrayRestDestructuringSteps(patterns, rest, initializerExpression, star
     if (rest.argument.type !== AST_NODE_TYPES.Identifier) {
         throw new WorkflowSyntaxError('Identifier expected', rest.argument.loc);
     }
-    const restName = rest.argument.name;
+    const restName = new VariableReferenceExpression(rest.argument.name);
     const __temp_len = new VariableReferenceExpression(`${tempName(ctx)}_len`);
     const __temp_index = `${tempName(ctx)}_index`;
     const one = new PrimitiveExpression(1);
     const emptyArray = new PrimitiveExpression([]);
     const copyLoop = new ForRangeStepAST([
         new AssignStepAST([
-            [
-                restName,
-                new FunctionInvocationExpression('list.concat', [
-                    new VariableReferenceExpression(restName),
+            {
+                name: restName,
+                value: new FunctionInvocationExpression('list.concat', [
+                    restName,
                     new MemberExpression(initializerExpression, new VariableReferenceExpression(__temp_index), true),
                 ]),
-            ],
+            },
         ]),
     ], __temp_index, startIndex, new BinaryExpression(__temp_len, '-', one));
-    return [new AssignStepAST([[restName, emptyArray]]), copyLoop];
+    return [new AssignStepAST([{ name: restName, value: emptyArray }]), copyLoop];
 }
 function convertObjectDestructuring(objectPattern, initializer, ctx) {
     let initExpression;
@@ -289,7 +297,14 @@ function objectDestructuringSteps(properties, initializerExpression, ctx) {
                 initializerExpression,
                 new PrimitiveExpression(prop.key.name),
             ]);
-            return [new AssignStepAST([[prop.value.name, safeKeyExpression]])];
+            return [
+                new AssignStepAST([
+                    {
+                        name: new VariableReferenceExpression(prop.value.name),
+                        value: safeKeyExpression,
+                    },
+                ]),
+            ];
         }
         else if (prop.value.type === AST_NODE_TYPES.AssignmentPattern) {
             return objectAssignmentPatternSteps(prop.value, initializerExpression, keyExpression);
@@ -305,16 +320,17 @@ function objectAssignmentPatternSteps(pat, initializerExpression, keyExpression)
     }
     // Using Switch step instead of default() because pat.right must be evaluated only
     // in the default value branch (in case it has side effects)
+    const name = new VariableReferenceExpression(pat.left.name);
     return [
         new SwitchStepAST([
             {
                 condition: new BinaryExpression(new PrimitiveExpression(pat.left.name), 'in', initializerExpression),
-                steps: [new AssignStepAST([[pat.left.name, keyExpression]])],
+                steps: [new AssignStepAST([{ name, value: keyExpression }])],
             },
             {
                 condition: trueEx,
                 steps: [
-                    new AssignStepAST([[pat.left.name, convertExpression(pat.right)]]),
+                    new AssignStepAST([{ name, value: convertExpression(pat.right) }]),
                 ],
             },
         ]),
@@ -335,13 +351,14 @@ function objectDestructuringRestSteps(properties, rest, initializerExpression) {
         return p;
     })
         .map((p) => p.name);
+    const name = new VariableReferenceExpression(rest.argument.name);
     const value = nonRestKeys.reduce((acc, propertyName) => 
     // map.delete returns a copy of the object and removes the specified property
     new FunctionInvocationExpression('map.delete', [
         acc,
         new PrimitiveExpression(propertyName),
     ]), initializerExpression);
-    return [new AssignStepAST([[rest.argument.name, value]])];
+    return [new AssignStepAST([{ name, value }])];
 }
 function assignmentExpressionToSteps(node, ctx) {
     let compoundOperator = undefined;
@@ -373,54 +390,132 @@ function assignmentExpressionToSteps(node, ctx) {
         default:
             throw new WorkflowSyntaxError(`Operator ${node.operator} is not supported in assignment expressions`, node.loc);
     }
-    if (node.left.type === AST_NODE_TYPES.ArrayPattern) {
-        if (node.operator === '=') {
-            return convertArrayDestructuring(node.left, node.right, ctx);
-        }
-        else {
-            throw new WorkflowSyntaxError(`Invalid left-hand side in assignment`, node.left.loc);
-        }
-    }
-    else if (node.left.type === AST_NODE_TYPES.ObjectPattern) {
-        if (node.operator === '=') {
-            return convertObjectDestructuring(node.left, node.right, ctx);
-        }
-        else {
-            throw new WorkflowSyntaxError(`Invalid left-hand side in assignment`, node.left.loc);
-        }
+    if (compoundOperator === undefined) {
+        return assignmentSteps(node.left, node.right, ctx);
     }
-    const targetExpression = convertExpression(node.left);
-    if (!isFullyQualifiedName(targetExpression)) {
-        throw new WorkflowSyntaxError('The left-hand side of an assignment must be an identifier or a property access', node.loc);
+    else {
+        return compoundAssignmentSteps(node.left, node.right, compoundOperator, ctx);
     }
+}
+function assignmentSteps(left, right, ctx) {
     let valueExpression;
     const steps = [];
-    const targetName = targetExpression.toString();
-    if (node.right.type === AST_NODE_TYPES.CallExpression &&
-        node.right.callee.type === AST_NODE_TYPES.Identifier &&
-        isMagicFunction(node.right.callee.name)) {
-        const calleeName = node.right.callee.name;
-        if (isMagicFunctionStatmentOnly(calleeName)) {
-            throw new WorkflowSyntaxError(`"${calleeName}" can't be called as part of an expression`, node.right.callee.loc);
-        }
-        const needsTempVariable = compoundOperator === undefined ||
-            node.left.type !== AST_NODE_TYPES.Identifier;
-        const resultVariable = needsTempVariable ? tempName(ctx) : targetName;
-        steps.push(...callExpressionToStep(node.right, resultVariable, ctx));
-        if (!needsTempVariable) {
-            return steps;
-        }
-        valueExpression = new VariableReferenceExpression(tempName(ctx));
+    if (left.type === AST_NODE_TYPES.ArrayPattern) {
+        return convertArrayDestructuring(left, right, ctx);
+    }
+    else if (left.type === AST_NODE_TYPES.ObjectPattern) {
+        return convertObjectDestructuring(left, right, ctx);
+    }
+    if (right.type === AST_NODE_TYPES.CallExpression &&
+        right.callee.type === AST_NODE_TYPES.Identifier &&
+        isIntrinsic(right.callee.name)) {
+        const tr = convertAssignmentExpressionIntrinsicRHS(right, ctx);
+        steps.push(...tr.steps);
+        valueExpression = tr.tempVariable;
     }
     else {
-        valueExpression = convertExpression(node.right);
+        valueExpression = convertExpression(right);
+    }
+    const targetExpression = convertVariableNameExpression(left);
+    steps.push(new AssignStepAST([{ name: targetExpression, value: valueExpression }]));
+    return steps;
+}
+function compoundAssignmentSteps(left, right, operator, ctx) {
+    let valueExpression;
+    const { expression: targetExpression, steps } = convertCompoundAssignmentLeftHandSide(left, ctx);
+    if (right.type === AST_NODE_TYPES.CallExpression &&
+        right.callee.type === AST_NODE_TYPES.Identifier &&
+        isIntrinsic(right.callee.name)) {
+        const tr = convertAssignmentExpressionIntrinsicRHS(right, ctx);
+        steps.push(...tr.steps);
+        valueExpression = tr.tempVariable;
     }
-    if (compoundOperator) {
-        valueExpression = new BinaryExpression(new VariableReferenceExpression(targetName), compoundOperator, valueExpression);
+    else {
+        valueExpression = convertExpression(right);
     }
-    steps.push(new AssignStepAST([[targetName, valueExpression]]));
+    valueExpression = new BinaryExpression(targetExpression, operator, valueExpression);
+    steps.push(new AssignStepAST([{ name: targetExpression, value: valueExpression }]));
     return steps;
 }
+function convertCompoundAssignmentLeftHandSide(left, ctx) {
+    if (left.type === AST_NODE_TYPES.ArrayPattern ||
+        left.type === AST_NODE_TYPES.ObjectPattern) {
+        throw new WorkflowSyntaxError(`Invalid left-hand side in assignment`, left.loc);
+    }
+    const leftEx = convertVariableNameExpression(left);
+    if (leftEx.expressionType === 'member') {
+        const { transformed, assignments } = extractSideEffectsFromMemberExpression(leftEx, tempName(ctx), 0);
+        const steps = [new AssignStepAST(assignments)];
+        return { expression: transformed, steps };
+    }
+    else {
+        return {
+            expression: leftEx,
+            steps: [],
+        };
+    }
+}
+/**
+ * Extract side-effecting computed properties into temporary variable assignments.
+ *
+ * This is used on the left-hand side of a compound assignment expression, which
+ * should only be evaluted once.
+ */
+function extractSideEffectsFromMemberExpression(ex, tempPrefix, tempIndex) {
+    if (ex.computed && !isPure(ex.property)) {
+        let transformedObject;
+        let objectAssignments;
+        if (ex.object.expressionType === 'member') {
+            const object2 = extractSideEffectsFromMemberExpression(ex.object, tempPrefix, tempIndex + 1);
+            transformedObject = object2.transformed;
+            objectAssignments = object2.assignments;
+        }
+        else {
+            transformedObject = ex.object;
+            objectAssignments = [];
+        }
+        const tmp = new VariableReferenceExpression(`${tempPrefix}${tempIndex}`);
+        const transformed = new MemberExpression(transformedObject, tmp, true);
+        const assignments = objectAssignments;
+        assignments.push({
+            name: tmp,
+            value: ex.property,
+        });
+        return { transformed, assignments };
+    }
+    else if (ex.object.expressionType === 'member') {
+        const { transformed: object2, assignments: assignments } = extractSideEffectsFromMemberExpression(ex.object, tempPrefix, tempIndex);
+        const transformed = new MemberExpression(object2, ex.property, ex.computed);
+        return {
+            transformed,
+            assignments,
+        };
+    }
+    else {
+        return {
+            transformed: ex,
+            assignments: [],
+        };
+    }
+}
+/**
+ * Special case for handling call_step() RHS in assignment expressions.
+ *
+ * This can be removed once the generic convertExpression() is able to handle call_step.
+ */
+function convertAssignmentExpressionIntrinsicRHS(callEx, ctx) {
+    if (callEx.callee.type !== AST_NODE_TYPES.Identifier) {
+        throw new InternalTranspilingError('The callee should be an identifier');
+    }
+    const calleeName = callEx.callee.name;
+    if (isIntrinsicStatement(calleeName)) {
+        throw new WorkflowSyntaxError(`"${calleeName}" can't be called as part of an expression`, callEx.callee.loc);
+    }
+    const resultVariable = tempName(ctx);
+    const steps = callExpressionToStep(callEx, resultVariable, ctx);
+    const tempVariable = new VariableReferenceExpression(resultVariable);
+    return { steps, tempVariable };
+}
 function callExpressionToStep(node, resultVariable, ctx) {
     const calleeExpression = convertExpression(node.callee);
     if (isFullyQualifiedName(calleeExpression)) {
@@ -456,10 +551,10 @@ function callExpressionToStep(node, resultVariable, ctx) {
 function callExpressionAssignStep(functionName, argumentsNode, resultVariable) {
     const argumentExpressions = throwIfSpread(argumentsNode).map(convertExpression);
     return new AssignStepAST([
-        [
-            resultVariable,
-            new FunctionInvocationExpression(functionName, argumentExpressions),
-        ],
+        {
+            name: new VariableReferenceExpression(resultVariable),
+            value: new FunctionInvocationExpression(functionName, argumentExpressions),
+        },
     ]);
 }
 function createCallStep(node, argumentsNode, resultVariable) {
@@ -600,7 +695,12 @@ function parseParallelOptions(node) {
     };
 }
 function generalExpressionToAssignStep(node, ctx) {
-    return new AssignStepAST([[tempName(ctx), convertExpression(node)]]);
+    return new AssignStepAST([
+        {
+            name: new VariableReferenceExpression(tempName(ctx)),
+            value: convertExpression(node),
+        },
+    ]);
 }
 function returnStatementToReturnStep(node, ctx) {
     const value = node.argument ? convertExpression(node.argument) : undefined;
@@ -779,7 +879,8 @@ function continueStatementToNextStep(node, ctx) {
     }
     return new NextStepAST(target);
 }
-function tryStatementToTrySteps(node, retryPolicy, ctx) {
+function tryStatementToTrySteps(node, ctx) {
+    const retryPolicy = extractRetryPolicy(node.block);
     if (!node.finalizer) {
         // Basic try-catch without a finally block
         const baseTryStep = parseTryCatchRetry(node, ctx, retryPolicy);
@@ -852,8 +953,14 @@ function extractErrorVariableName(param) {
  */
 function finalizerInitializer(conditionVariable, valueVariable) {
     return new AssignStepAST([
-        [conditionVariable, nullEx],
-        [valueVariable, nullEx],
+        {
+            name: new VariableReferenceExpression(conditionVariable),
+            value: nullEx,
+        },
+        {
+            name: new VariableReferenceExpression(valueVariable),
+            value: nullEx,
+        },
     ]);
 }
 /**
@@ -887,11 +994,14 @@ function finalizerFooter(conditionVariable, valueVariable) {
 function finalizerDelayedException(exceptionVariableName, conditionVariableName, valueVariableName) {
     return [
         new AssignStepAST([
-            [conditionVariableName, new PrimitiveExpression('raise')],
-            [
-                valueVariableName,
-                new VariableReferenceExpression(exceptionVariableName),
-            ],
+            {
+                name: new VariableReferenceExpression(conditionVariableName),
+                value: new PrimitiveExpression('raise'),
+            },
+            {
+                name: new VariableReferenceExpression(valueVariableName),
+                value: new VariableReferenceExpression(exceptionVariableName),
+            },
         ]),
     ];
 }
@@ -901,8 +1011,14 @@ function delayedReturnAndJumpToFinalizer(value, ctx) {
         : undefined;
     const [conditionVariable, valueVariable] = finalizerVariables(ctx);
     return new AssignStepAST([
-        [conditionVariable, new PrimitiveExpression('return')],
-        [valueVariable, value ?? nullEx],
+        {
+            name: new VariableReferenceExpression(conditionVariable),
+            value: new PrimitiveExpression('return'),
+        },
+        {
+            name: new VariableReferenceExpression(valueVariable),
+            value: value ?? nullEx,
+        },
     ], finalizerTarget);
 }
 function labeledStep(node, ctx) {
@@ -912,27 +1028,30 @@ function labeledStep(node, ctx) {
     }
     return steps;
 }
-function parseRetryPolicy(node) {
-    const callee = node.callee;
-    if (callee.type !== AST_NODE_TYPES.Identifier ||
-        callee.name !== 'retry_policy') {
-        // Ignore everything else besides retry_policy()
-        return undefined;
-    }
-    if (node.arguments.length < 1) {
-        throw new WorkflowSyntaxError('Required argument missing', node.loc);
-    }
-    const arg0 = throwIfSpread(node.arguments).map(convertExpression)[0];
-    const argsLoc = node.arguments[0].loc;
-    if (isFullyQualifiedName(arg0)) {
-        return arg0.toString();
-    }
-    else if (arg0.expressionType === 'primitive' && isRecord(arg0.value)) {
-        return retryPolicyFromParams(arg0.value, argsLoc);
-    }
-    else {
-        throw new WorkflowSyntaxError('Unexpected type', argsLoc);
+function extractRetryPolicy(tryBlock) {
+    // Find and parse the first retry_policy() in tryBlock
+    for (const statement of tryBlock.body) {
+        if (statement.type === AST_NODE_TYPES.ExpressionStatement &&
+            statement.expression.type === AST_NODE_TYPES.CallExpression &&
+            statement.expression.callee.type === AST_NODE_TYPES.Identifier &&
+            statement.expression.callee.name === 'retry_policy') {
+            if (statement.expression.arguments.length < 1) {
+                throw new WorkflowSyntaxError('Required argument missing', statement.expression.loc);
+            }
+            const arg0 = throwIfSpread(statement.expression.arguments).map(convertExpression)[0];
+            const argsLoc = statement.expression.arguments[0].loc;
+            if (isFullyQualifiedName(arg0)) {
+                return arg0.toString();
+            }
+            else if (arg0.expressionType === 'primitive' && isRecord(arg0.value)) {
+                return retryPolicyFromParams(arg0.value, argsLoc);
+            }
+            else {
+                throw new WorkflowSyntaxError('Unexpected type', argsLoc);
+            }
+        }
     }
+    return undefined;
 }
 function retryPolicyFromParams(paramsObject, argsLoc) {
     const params = R.map(asExpression, paramsObject);

package/dist/transpiler/transformations.js

@@ -179,10 +179,16 @@ const transformStepExpressions = R.curry(function (transform, step) {
 function transformExpressionsAssign(transform, step) {
     if (step.assignments) {
         const newSteps = [];
-        const newAssignments = step.assignments.map(([name, ex]) => {
-            const [steps2, ex2] = transform(ex);
+        const newAssignments = step.assignments.map(({ name, value }) => {
+            const [steps2, transformedKey] = transform(name);
+            const [steps3, transformedValue] = transform(value);
             newSteps.push(...steps2);
-            return [name, ex2];
+            newSteps.push(...steps3);
+            if (transformedKey.expressionType !== 'variableReference' &&
+                transformedKey.expressionType !== 'member') {
+                throw new InternalTranspilingError('Unexpected key type when transforming assign step');
+            }
+            return { name: transformedKey, value: transformedValue };
         });
         newSteps.push(new AssignStepAST(newAssignments, step.next, step.label));
         return newSteps;
@@ -407,9 +413,11 @@ function extractMapsInMap(primitiveEx, generateName, nestingLevel) {
         newValue = properties;
     }
     else {
-        const name = generateName();
-        tempVariables.push([name, new PrimitiveExpression(properties)]);
-        newValue = new VariableReferenceExpression(name);
+        newValue = new VariableReferenceExpression(generateName());
+        tempVariables.push({
+            name: newValue,
+            value: new PrimitiveExpression(properties),
+        });
     }
     return {
         transformed: newValue,

package/dist/utils.d.ts

@@ -1,9 +1,2 @@
 export declare function isRecord(object: unknown): object is Record<keyof never, unknown>;
-/**
- * Like arr.flatMap() but the callback takes two consecutive array elements.
- *
- * During the last execution of the callback, the second argument (which would
- * be element after the last array element) will be undefined.
- */
-export declare function chainPairs<T, U>(callback: (val: T, next: T | undefined) => U[], arr: readonly T[]): U[];
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,wBAAgB,QAAQ,CACtB,MAAM,EAAE,OAAO,GACd,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,EAAE,OAAO,CAAC,CAExC;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,KAAK,CAAC,EAAE,EAC9C,GAAG,EAAE,SAAS,CAAC,EAAE,GAChB,CAAC,EAAE,CAKL"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CACtB,MAAM,EAAE,OAAO,GACd,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,EAAE,OAAO,CAAC,CAExC"}

package/dist/utils.js

@@ -1,13 +1,3 @@
-import * as R from 'ramda';
 export function isRecord(object) {
     return object instanceof Object && object.constructor === Object;
 }
-/**
- * Like arr.flatMap() but the callback takes two consecutive array elements.
- *
- * During the last execution of the callback, the second argument (which would
- * be element after the last array element) will be undefined.
- */
-export function chainPairs(callback, arr) {
-    return R.chain(R.apply(callback), R.zip(arr, R.append(undefined, R.tail(arr))));
-}