ts2workflows 0.8.0 → 0.10.0

package/dist/transpiler/statements.js

@@ -1,19 +1,18 @@
+import * as R from 'ramda';
 import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
-import { AssignStepAST, CallStepAST, ForStepAST, JumpTargetAST, NextStepAST, ParallelStepAST, RaiseStepAST, ReturnStepAST, StepsStepAST, SwitchStepAST, TryStepAST, } from '../ast/steps.js';
-import { BinaryExpression, FunctionInvocationExpression, PrimitiveExpression, VariableReferenceExpression, isExpression, isFullyQualifiedName, isLiteral, } from '../ast/expressions.js';
+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 { flatMapPair, isRecord, mapRecordValues } from '../utils.js';
-import { transformAST } from './transformations.js';
-import { convertExpression, convertMemberExpression, convertObjectExpression, convertObjectAsExpressionValues, isMagicFunction, throwIfSpread, isMagicFunctionStatmentOnly, asExpression, } from './expressions.js';
+import { chainPairs, 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, postSteps) {
-    const steps = parseStatementRecursively(node, undefined, ctx);
-    return transformAST(steps.concat(postSteps ?? []));
+export function parseStatement(node, ctx) {
+    return parseStatementRecursively(node, undefined, ctx);
 }
 function parseStatementRecursively(node, nextNode, ctx) {
     switch (node.type) {
         case AST_NODE_TYPES.BlockStatement:
-            return flatMapPair(node.body, (statement, nextStatement) => parseStatementRecursively(statement, nextStatement, ctx));
+            return chainPairs(R.partialRight(parseStatementRecursively, [ctx]), node.body);
         case AST_NODE_TYPES.VariableDeclaration:
             return convertVariableDeclarations(node.declarations, ctx);
         case AST_NODE_TYPES.ExpressionStatement:
@@ -24,7 +23,7 @@ function parseStatementRecursively(node, nextNode, ctx) {
                 return callExpressionToStep(node.expression, undefined, ctx);
             }
             else {
-                return [generalExpressionToAssignStep(node.expression)];
+                return [generalExpressionToAssignStep(node.expression, ctx)];
             }
         case AST_NODE_TYPES.ReturnStatement:
             return [returnStatementToReturnStep(node, ctx)];
@@ -71,27 +70,302 @@ function parseStatementRecursively(node, nextNode, ctx) {
 }
 function convertVariableDeclarations(declarations, ctx) {
     return declarations.flatMap((decl) => {
-        if (decl.id.type !== AST_NODE_TYPES.Identifier) {
-            throw new WorkflowSyntaxError('Expected Identifier', decl.loc);
-        }
-        const targetName = decl.id.name;
-        if (decl.init?.type === AST_NODE_TYPES.CallExpression) {
-            const calleeName = decl.init.callee.type === AST_NODE_TYPES.Identifier
-                ? decl.init.callee.name
-                : undefined;
-            if (calleeName && isMagicFunctionStatmentOnly(calleeName)) {
-                throw new WorkflowSyntaxError(`"${calleeName}" can't be called as part of an expression`, decl.init.callee.loc);
+        if (decl.id.type === AST_NODE_TYPES.Identifier) {
+            return convertInitializer(decl.id.name, decl.init, ctx);
+        }
+        else if (decl.id.type === AST_NODE_TYPES.ArrayPattern) {
+            return convertArrayDestructuring(decl.id, decl.init, ctx);
+        }
+        else if (decl.id.type === AST_NODE_TYPES.ObjectPattern) {
+            return convertObjectDestructuring(decl.id, decl.init, ctx);
+        }
+        else {
+            throw new WorkflowSyntaxError('Unsupported pattern', decl.loc);
+        }
+    });
+}
+function convertInitializer(targetVariableName, initializer, ctx) {
+    if (initializer?.type === AST_NODE_TYPES.CallExpression) {
+        const calleeName = initializer.callee.type === AST_NODE_TYPES.Identifier
+            ? initializer.callee.name
+            : undefined;
+        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([{ name, value }])];
+    }
+}
+function convertArrayDestructuring(arrayPattern, initializer, ctx) {
+    let initExpression;
+    const steps = [];
+    if (initializer?.type === AST_NODE_TYPES.Identifier ||
+        initializer?.type === AST_NODE_TYPES.MemberExpression) {
+        // If the initializer is an Identifier or MemberExpression (array variable?),
+        // use it directly. This ensures that the recursive variables gets initialized
+        // in the correct order. For example:
+        // const arr = [1, 2]
+        // [arr[1], arr[0]] = arr
+        initExpression = convertExpression(initializer);
+    }
+    else {
+        // Otherwise, assign the expression to a temporary variable first.
+        const initName = tempName(ctx);
+        steps.push(...convertInitializer(initName, initializer, ctx));
+        initExpression = new VariableReferenceExpression(initName);
+    }
+    steps.push(...arrayDestructuringSteps(arrayPattern.elements, initExpression, ctx));
+    return steps;
+}
+function arrayDestructuringSteps(patterns, initializerExpression, ctx) {
+    if (patterns.filter((p) => p !== null).length === 0) {
+        return [];
+    }
+    const __temp_len = new VariableReferenceExpression(`${tempName(ctx)}_len`);
+    const initializeVariables = [
+        {
+            name: __temp_len,
+            value: new FunctionInvocationExpression('len', [initializerExpression]),
+        },
+    ];
+    const branches = R.reverse(patterns).flatMap((pat, i) => {
+        if (pat === null) {
+            return [];
+        }
+        else {
+            return [
+                {
+                    condition: new BinaryExpression(__temp_len, '>=', new PrimitiveExpression(patterns.length - i)),
+                    steps: arrayElementsDestructuringSteps(patterns, initializerExpression, patterns.length - i, ctx),
+                },
+            ];
+        }
+    });
+    branches.push({
+        condition: trueEx,
+        steps: arrayElementsDestructuringSteps(patterns, initializerExpression, 0, ctx),
+    });
+    return [new AssignStepAST(initializeVariables), new SwitchStepAST(branches)];
+}
+function arrayElementsDestructuringSteps(patterns, initializerExpression, take, ctx) {
+    return patterns.flatMap((pat, i) => {
+        if (i >= take) {
+            return [
+                new AssignStepAST(extractDefaultAssignmentsFromDestructuringPattern(pat)),
+            ];
+        }
+        const iElement = new MemberExpression(initializerExpression, new PrimitiveExpression(i), true);
+        switch (pat?.type) {
+            case AST_NODE_TYPES.MemberExpression:
+            case AST_NODE_TYPES.Identifier: {
+                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);
+                }
+                const name = new VariableReferenceExpression(pat.left.name);
+                return [new AssignStepAST([{ name, value: iElement }])];
+            }
+            case AST_NODE_TYPES.ObjectPattern:
+                return objectDestructuringSteps(pat.properties, iElement, ctx);
+            case AST_NODE_TYPES.ArrayPattern:
+                return arrayDestructuringSteps(pat.elements, iElement, ctx);
+            case AST_NODE_TYPES.RestElement:
+                return arrayRestDestructuringSteps(patterns, pat, initializerExpression, patterns.length - 1, ctx);
+            default: // pat === null
+                return [];
+        }
+    });
+}
+function extractDefaultAssignmentsFromDestructuringPattern(pat) {
+    if (pat === null) {
+        return [];
+    }
+    switch (pat.type) {
+        case AST_NODE_TYPES.ArrayPattern:
+            return pat.elements.flatMap(extractDefaultAssignmentsFromDestructuringPattern);
+        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 callExpressionToStep(decl.init, targetName, ctx);
+            return [
+                {
+                    name: new VariableReferenceExpression(pat.left.name),
+                    value: convertExpression(pat.right),
+                },
+            ];
+        case AST_NODE_TYPES.Identifier:
+            return [
+                { name: new VariableReferenceExpression(pat.name), value: nullEx },
+            ];
+        case AST_NODE_TYPES.MemberExpression:
+            return [{ name: convertVariableNameExpression(pat), value: nullEx }];
+        case AST_NODE_TYPES.ObjectPattern:
+            return pat.properties.flatMap((p) => {
+                if (p.type === AST_NODE_TYPES.RestElement) {
+                    return extractDefaultAssignmentsFromDestructuringPattern(p);
+                }
+                else if (p.value.type === AST_NODE_TYPES.ArrayPattern ||
+                    p.value.type === AST_NODE_TYPES.AssignmentPattern ||
+                    p.value.type === AST_NODE_TYPES.Identifier ||
+                    p.value.type === AST_NODE_TYPES.MemberExpression ||
+                    p.value.type === AST_NODE_TYPES.ObjectPattern) {
+                    return extractDefaultAssignmentsFromDestructuringPattern(p.value);
+                }
+                else {
+                    throw new WorkflowSyntaxError('Destructuring pattern expected', p.value.loc);
+                }
+            });
+        case AST_NODE_TYPES.RestElement:
+            if (pat.argument.type !== AST_NODE_TYPES.Identifier) {
+                throw new WorkflowSyntaxError('Identifier expected', pat.argument.loc);
+            }
+            return [
+                {
+                    name: new VariableReferenceExpression(pat.argument.name),
+                    value: new PrimitiveExpression([]),
+                },
+            ];
+        default:
+            return [];
+    }
+}
+function throwIfInvalidRestElement(patterns) {
+    const i = patterns.findIndex((p) => p?.type === AST_NODE_TYPES.RestElement);
+    if (i >= 0 && i !== patterns.length - 1) {
+        throw new WorkflowSyntaxError('A rest element must be last in a destructuring pattern', patterns[i].loc);
+    }
+}
+function arrayRestDestructuringSteps(patterns, rest, initializerExpression, startIndex, ctx) {
+    throwIfInvalidRestElement(patterns);
+    if (rest.argument.type !== AST_NODE_TYPES.Identifier) {
+        throw new WorkflowSyntaxError('Identifier expected', rest.argument.loc);
+    }
+    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([
+            {
+                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([{ name: restName, value: emptyArray }]), copyLoop];
+}
+function convertObjectDestructuring(objectPattern, initializer, ctx) {
+    let initExpression;
+    const steps = [];
+    if (initializer?.type === AST_NODE_TYPES.Identifier ||
+        (initializer?.type === AST_NODE_TYPES.MemberExpression &&
+            isPure(convertExpression(initializer)))) {
+        // If the initializer is an Identifier or MemberExpression (object variable?), use it directly.
+        initExpression = convertExpression(initializer);
+    }
+    else {
+        // Otherwise, assign the expression to a temporary variable first.
+        const initName = tempName(ctx);
+        steps.push(...convertInitializer(initName, initializer, ctx));
+        initExpression = new VariableReferenceExpression(initName);
+    }
+    steps.push(...objectDestructuringSteps(objectPattern.properties, initExpression, ctx));
+    return steps;
+}
+function objectDestructuringSteps(properties, initializerExpression, ctx) {
+    return properties.flatMap((prop) => {
+        if (prop.type === AST_NODE_TYPES.RestElement) {
+            return objectDestructuringRestSteps(properties, prop, initializerExpression);
+        }
+        if (prop.key.type !== AST_NODE_TYPES.Identifier) {
+            throw new WorkflowSyntaxError('Identifier expected', prop.key.loc);
+        }
+        const keyExpression = new MemberExpression(initializerExpression, new VariableReferenceExpression(prop.key.name), false);
+        if (prop.value.type === AST_NODE_TYPES.ObjectPattern) {
+            return objectDestructuringSteps(prop.value.properties, keyExpression, ctx);
+        }
+        else if (prop.value.type === AST_NODE_TYPES.ArrayPattern) {
+            return arrayDestructuringSteps(prop.value.elements, keyExpression, ctx);
+        }
+        else if (prop.value.type === AST_NODE_TYPES.Identifier) {
+            const safeKeyExpression = new FunctionInvocationExpression('map.get', [
+                initializerExpression,
+                new PrimitiveExpression(prop.key.name),
+            ]);
+            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);
         }
         else {
-            const value = decl.init == null
-                ? new PrimitiveExpression(null)
-                : convertExpression(decl.init);
-            return [new AssignStepAST([[targetName, value]])];
+            throw new WorkflowSyntaxError(`${prop.value.type} is not allowed in object destructuring`, prop.value.loc);
         }
     });
 }
+function objectAssignmentPatternSteps(pat, initializerExpression, keyExpression) {
+    if (pat.left.type !== AST_NODE_TYPES.Identifier) {
+        throw new WorkflowSyntaxError('Default value can be used only with an identifier', pat.left.loc);
+    }
+    // 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([{ name, value: keyExpression }])],
+            },
+            {
+                condition: trueEx,
+                steps: [
+                    new AssignStepAST([{ name, value: convertExpression(pat.right) }]),
+                ],
+            },
+        ]),
+    ];
+}
+function objectDestructuringRestSteps(properties, rest, initializerExpression) {
+    throwIfInvalidRestElement(properties);
+    if (rest.argument.type !== AST_NODE_TYPES.Identifier) {
+        throw new WorkflowSyntaxError('Identifier expected', rest.argument.loc);
+    }
+    const nonRestProperties = properties.filter((x) => x.type !== AST_NODE_TYPES.RestElement);
+    const nonRestKeys = nonRestProperties
+        .map((p) => p.key)
+        .map((p) => {
+        if (p.type !== AST_NODE_TYPES.Identifier) {
+            throw new WorkflowSyntaxError('Identifier expected', p.loc);
+        }
+        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([{ name, value }])];
+}
 function assignmentExpressionToSteps(node, ctx) {
     let compoundOperator = undefined;
     switch (node.operator) {
@@ -122,44 +396,138 @@ function assignmentExpressionToSteps(node, ctx) {
         default:
             throw new WorkflowSyntaxError(`Operator ${node.operator} is not supported in assignment expressions`, node.loc);
     }
-    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);
+    if (compoundOperator === undefined) {
+        return assignmentSteps(node.left, node.right, ctx);
+    }
+    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 ? '__temp' : targetName;
-        steps.push(...callExpressionToStep(node.right, resultVariable, ctx));
-        if (!needsTempVariable) {
-            return steps;
-        }
-        valueExpression = new VariableReferenceExpression('__temp');
+    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)) {
         const calleeName = calleeExpression.toString();
         if (calleeName === 'parallel') {
-            // A custom implementation for "parallel"
+            // A handle the "parallel" intrinsic
             return [callExpressionToParallelStep(node, ctx)];
         }
         else if (calleeName === 'retry_policy') {
@@ -176,8 +544,9 @@ function callExpressionToStep(node, resultVariable, ctx) {
             ];
         }
         else {
+            const resultVariable2 = resultVariable ?? tempName(ctx);
             return [
-                callExpressionAssignStep(calleeName, node.arguments, resultVariable),
+                callExpressionAssignStep(calleeName, node.arguments, resultVariable2),
             ];
         }
     }
@@ -188,10 +557,10 @@ function callExpressionToStep(node, resultVariable, ctx) {
 function callExpressionAssignStep(functionName, argumentsNode, resultVariable) {
     const argumentExpressions = throwIfSpread(argumentsNode).map(convertExpression);
     return new AssignStepAST([
-        [
-            resultVariable ?? '__temp',
-            new FunctionInvocationExpression(functionName, argumentExpressions),
-        ],
+        {
+            name: new VariableReferenceExpression(resultVariable),
+            value: new FunctionInvocationExpression(functionName, argumentExpressions),
+        },
     ]);
 }
 function createCallStep(node, argumentsNode, resultVariable) {
@@ -245,14 +614,19 @@ function callExpressionToParallelStep(node, ctx) {
         node.callee.name !== 'parallel') {
         throw new InternalTranspilingError(`The parameter must be a call to "parallel"`);
     }
+    const ctx2 = Object.assign({}, ctx, {
+        parallelNestingLevel: ctx.parallelNestingLevel
+            ? ctx.parallelNestingLevel + 1
+            : 1,
+    });
     let steps = {};
     if (node.arguments.length > 0) {
         switch (node.arguments[0].type) {
             case AST_NODE_TYPES.ArrayExpression:
-                steps = parseParallelBranches(node.arguments[0]);
+                steps = parseParallelBranches(node.arguments[0], ctx2);
                 break;
             case AST_NODE_TYPES.ArrowFunctionExpression:
-                steps = parseParallelIteration(node.arguments[0], ctx);
+                steps = parseParallelIteration(node.arguments[0], ctx2);
                 break;
             default:
                 throw new WorkflowSyntaxError('The first parameter must be an array of functions or an arrow function', node.arguments[0].loc);
@@ -269,25 +643,21 @@ function callExpressionToParallelStep(node, ctx) {
     }
     return new ParallelStepAST(steps, shared, concurrencyLimit, exceptionPolicy);
 }
-function parseParallelBranches(node) {
-    const stepsArray = node.elements.map((arg, idx) => {
-        const branchName = `branch${idx + 1}`;
-        if (arg === null) {
-            throw new WorkflowSyntaxError('Argument should be a function call of type () => void', node.loc);
-        }
-        switch (arg.type) {
+function parseParallelBranches(node, ctx) {
+    const branches = node.elements.map((arg) => {
+        switch (arg?.type) {
             case AST_NODE_TYPES.Identifier:
-                return [branchName, new StepsStepAST([new CallStepAST(arg.name)])];
+                return new StepsStepAST([new CallStepAST(arg.name)]);
             case AST_NODE_TYPES.ArrowFunctionExpression:
                 if (arg.body.type !== AST_NODE_TYPES.BlockStatement) {
                     throw new WorkflowSyntaxError('The body must be a block statement', arg.body.loc);
                 }
-                return [branchName, new StepsStepAST(parseStatement(arg.body, {}))];
+                return new StepsStepAST(parseStatement(arg.body, ctx));
             default:
-                throw new WorkflowSyntaxError('Argument should be a function call of type () => void', arg.loc);
+                throw new WorkflowSyntaxError('Argument should be a function of type () => void', arg ? arg.loc : node.loc);
         }
     });
-    return Object.fromEntries(stepsArray);
+    return Object.fromEntries(branches.map((step, i) => [`branch${i + 1}`, step]));
 }
 function parseParallelIteration(node, ctx) {
     if (node.body.type !== AST_NODE_TYPES.BlockStatement ||
@@ -330,8 +700,13 @@ function parseParallelOptions(node) {
         exceptionPolicy,
     };
 }
-function generalExpressionToAssignStep(node) {
-    return new AssignStepAST([['__temp', convertExpression(node)]]);
+function generalExpressionToAssignStep(node, ctx) {
+    return new AssignStepAST([
+        {
+            name: new VariableReferenceExpression(tempName(ctx)),
+            value: convertExpression(node),
+        },
+    ]);
 }
 function returnStatementToReturnStep(node, ctx) {
     const value = node.argument ? convertExpression(node.argument) : undefined;
@@ -361,7 +736,7 @@ function flattenIfBranches(ifStatement, ctx) {
         }
         else {
             branches.push({
-                condition: new PrimitiveExpression(true),
+                condition: trueEx,
                 steps: parseStatement(ifStatement.alternate, ctx),
             });
         }
@@ -381,10 +756,10 @@ function switchStatementToSteps(node, ctx) {
             condition = new BinaryExpression(discriminant, '==', test);
         }
         else {
-            condition = new PrimitiveExpression(true);
+            condition = trueEx;
         }
         const jumpTarget = new JumpTargetAST();
-        const body = transformAST(caseNode.consequent.flatMap((x) => parseStatement(x, switchCtx)));
+        const body = caseNode.consequent.flatMap((x) => parseStatement(x, switchCtx));
         steps.push(jumpTarget);
         steps.push(...body);
         branches.push({
@@ -416,12 +791,12 @@ function forOfStatementToForStep(node, ctx) {
             throw new WorkflowSyntaxError('Initial value not allowed', declaration.init.loc);
         }
         if (declaration.id.type !== AST_NODE_TYPES.Identifier) {
-            throw new WorkflowSyntaxError(`Expected identifier, got ${declaration.id.type}`, declaration.id.loc);
+            throw new WorkflowSyntaxError(`Identifier expected, got ${declaration.id.type}`, declaration.id.loc);
         }
         loopVariableName = declaration.id.name;
     }
     else {
-        throw new InternalTranspilingError(`Expected Identifier or VariableDeclaration, got ${node.left.type}`);
+        throw new InternalTranspilingError(`Identifier or VariableDeclaration expected, got ${node.left.type}`);
     }
     const listExpression = convertExpression(node.right);
     if (isLiteral(listExpression) &&
@@ -443,7 +818,7 @@ function whileStatementSteps(node, ctx) {
         breakTarget: endOfLoop.label,
     });
     const postSteps = [new NextStepAST(startOfLoop.label)];
-    const steps = parseStatement(node.body, ctx2, postSteps);
+    const steps = parseStatement(node.body, ctx2).concat(postSteps);
     return [
         startOfLoop,
         new SwitchStepAST([
@@ -583,8 +958,14 @@ function extractErrorVariableName(param) {
  */
 function finalizerInitializer(conditionVariable, valueVariable) {
     return new AssignStepAST([
-        [conditionVariable, new PrimitiveExpression(null)],
-        [valueVariable, new PrimitiveExpression(null)],
+        {
+            name: new VariableReferenceExpression(conditionVariable),
+            value: nullEx,
+        },
+        {
+            name: new VariableReferenceExpression(valueVariable),
+            value: nullEx,
+        },
     ]);
 }
 /**
@@ -600,27 +981,32 @@ function finalizerInitializer(conditionVariable, valueVariable) {
  * }
  */
 function finalizerFooter(conditionVariable, valueVariable) {
+    const variable = new VariableReferenceExpression(conditionVariable);
+    const val = new VariableReferenceExpression(valueVariable);
+    const returnString = new PrimitiveExpression('return');
+    const raiseString = new PrimitiveExpression('raise');
     return new SwitchStepAST([
         {
-            condition: new BinaryExpression(new VariableReferenceExpression(conditionVariable), '==', new PrimitiveExpression('return')),
-            steps: [
-                new ReturnStepAST(new VariableReferenceExpression(valueVariable)),
-            ],
+            condition: new BinaryExpression(variable, '==', returnString),
+            steps: [new ReturnStepAST(val)],
         },
         {
-            condition: new BinaryExpression(new VariableReferenceExpression(conditionVariable), '==', new PrimitiveExpression('raise')),
-            steps: [new RaiseStepAST(new VariableReferenceExpression(valueVariable))],
+            condition: new BinaryExpression(variable, '==', raiseString),
+            steps: [new RaiseStepAST(val)],
         },
     ]);
 }
 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),
+            },
         ]),
     ];
 }
@@ -630,8 +1016,14 @@ function delayedReturnAndJumpToFinalizer(value, ctx) {
         : undefined;
     const [conditionVariable, valueVariable] = finalizerVariables(ctx);
     return new AssignStepAST([
-        [conditionVariable, new PrimitiveExpression('return')],
-        [valueVariable, value ?? new PrimitiveExpression(null)],
+        {
+            name: new VariableReferenceExpression(conditionVariable),
+            value: new PrimitiveExpression('return'),
+        },
+        {
+            name: new VariableReferenceExpression(valueVariable),
+            value: value ?? nullEx,
+        },
     ], finalizerTarget);
 }
 function labeledStep(node, ctx) {
@@ -664,43 +1056,45 @@ function parseRetryPolicy(node) {
     }
 }
 function retryPolicyFromParams(paramsObject, argsLoc) {
-    const params = mapRecordValues(paramsObject, asExpression);
-    if ('backoff' in params) {
-        let predicate = '';
-        const predicateEx = params.predicate;
-        if (predicateEx === undefined) {
-            predicate = undefined;
-        }
-        else if (isFullyQualifiedName(predicateEx)) {
-            predicate = predicateEx.toString();
-        }
-        else {
-            throw new WorkflowSyntaxError('"predicate" must be a function name', argsLoc);
-        }
-        const backoffEx = params.backoff;
-        if (backoffEx.expressionType === 'primitive' && isRecord(backoffEx.value)) {
-            const backoffLit = backoffEx.value;
-            return {
-                predicate,
-                maxRetries: params.max_retries,
-                backoff: {
-                    initialDelay: backoffLit.initial_delay
-                        ? asExpression(backoffLit.initial_delay)
-                        : undefined,
-                    maxDelay: backoffLit.max_delay
-                        ? asExpression(backoffLit.max_delay)
-                        : undefined,
-                    multiplier: backoffLit.multiplier
-                        ? asExpression(backoffLit.multiplier)
-                        : undefined,
-                },
-            };
-        }
-        else {
-            throw new WorkflowSyntaxError('Expected an object literal', argsLoc);
-        }
+    const params = R.map(asExpression, paramsObject);
+    if (!('backoff' in params)) {
+        throw new WorkflowSyntaxError('Required parameter "backoff" missing', argsLoc);
+    }
+    else if (params.backoff.expressionType !== 'primitive' ||
+        !isRecord(params.backoff.value)) {
+        throw new WorkflowSyntaxError('Expected "backoff" to be an object literal', argsLoc);
+    }
+    const backoff = params.backoff.value;
+    return {
+        predicate: predicateFromRetryParams(params, argsLoc),
+        maxRetries: params.max_retries,
+        backoff: {
+            initialDelay: safeAsExpression(backoff.initial_delay),
+            maxDelay: safeAsExpression(backoff.max_delay),
+            multiplier: safeAsExpression(backoff.multiplier),
+        },
+    };
+}
+function predicateFromRetryParams(params, argsLoc) {
+    if (!('predicate' in params)) {
+        return undefined;
+    }
+    else if (isFullyQualifiedName(params.predicate)) {
+        return params.predicate.toString();
+    }
+    else {
+        throw new WorkflowSyntaxError('"predicate" must be a function name', argsLoc);
+    }
+}
+function tempName(ctx) {
+    if (ctx.parallelNestingLevel !== undefined) {
+        // Temporary variable inside a parallel step can not be the same as temporary
+        // variables on the outside. Sharing the variable name would cause deployment
+        // error, if the variable is not marked as shared by including it in the
+        // "shared" array.
+        return `__temp_parallel${ctx.parallelNestingLevel ?? 0}`;
     }
     else {
-        throw new WorkflowSyntaxError('Some required retry policy parameters are missing', argsLoc);
+        return '__temp';
     }
 }