ts2workflows 0.7.0 → 0.9.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, isMagicFunction, throwIfSpread, isMagicFunctionStatmentOnly, } 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,279 @@ 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 && isMagicFunctionStatmentOnly(calleeName)) {
+            throw new WorkflowSyntaxError(`"${calleeName}" can't be called as part of an expression`, initializer.callee.loc);
+        }
+        return callExpressionToStep(initializer, targetVariableName, ctx);
+    }
+    else {
+        const value = initializer === null ? nullEx : convertExpression(initializer);
+        return [new AssignStepAST([[targetVariableName, 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 = `${tempName(ctx)}_len`;
+    const initializeVariables = [
+        [
+            __temp_len,
+            new FunctionInvocationExpression('len', [initializerExpression]),
+        ],
+    ];
+    const branches = R.reverse(patterns).flatMap((pat, i) => {
+        if (pat === null) {
+            return [];
+        }
+        else {
+            return [
+                {
+                    condition: new BinaryExpression(new VariableReferenceExpression(__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 = convertExpression(pat).toString();
+                return [new AssignStepAST([[name, 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]])];
             }
-            return callExpressionToStep(decl.init, targetName, ctx);
+            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 [[pat.left.name, convertExpression(pat.right)]];
+        case AST_NODE_TYPES.Identifier:
+            return [[pat.name, nullEx]];
+        case AST_NODE_TYPES.MemberExpression:
+            return [[convertExpression(pat).toString(), 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 [[pat.argument.name, 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 = 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),
+                    new MemberExpression(initializerExpression, new VariableReferenceExpression(__temp_index), true),
+                ]),
+            ],
+        ]),
+    ], __temp_index, startIndex, new BinaryExpression(__temp_len, '-', one));
+    return [new AssignStepAST([[restName, 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([[prop.value.name, 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)
+    return [
+        new SwitchStepAST([
+            {
+                condition: new BinaryExpression(new PrimitiveExpression(pat.left.name), 'in', initializerExpression),
+                steps: [new AssignStepAST([[pat.left.name, keyExpression]])],
+            },
+            {
+                condition: trueEx,
+                steps: [
+                    new AssignStepAST([[pat.left.name, 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 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]])];
+}
 function assignmentExpressionToSteps(node, ctx) {
     let compoundOperator = undefined;
     switch (node.operator) {
@@ -122,6 +373,22 @@ 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);
+        }
+    }
     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);
@@ -138,12 +405,12 @@ function assignmentExpressionToSteps(node, ctx) {
         }
         const needsTempVariable = compoundOperator === undefined ||
             node.left.type !== AST_NODE_TYPES.Identifier;
-        const resultVariable = needsTempVariable ? '__temp' : targetName;
+        const resultVariable = needsTempVariable ? tempName(ctx) : targetName;
         steps.push(...callExpressionToStep(node.right, resultVariable, ctx));
         if (!needsTempVariable) {
             return steps;
         }
-        valueExpression = new VariableReferenceExpression('__temp');
+        valueExpression = new VariableReferenceExpression(tempName(ctx));
     }
     else {
         valueExpression = convertExpression(node.right);
@@ -159,7 +426,7 @@ function callExpressionToStep(node, resultVariable, ctx) {
     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 +443,9 @@ function callExpressionToStep(node, resultVariable, ctx) {
             ];
         }
         else {
+            const resultVariable2 = resultVariable ?? tempName(ctx);
             return [
-                callExpressionAssignStep(calleeName, node.arguments, resultVariable),
+                callExpressionAssignStep(calleeName, node.arguments, resultVariable2),
             ];
         }
     }
@@ -189,7 +457,7 @@ function callExpressionAssignStep(functionName, argumentsNode, resultVariable) {
     const argumentExpressions = throwIfSpread(argumentsNode).map(convertExpression);
     return new AssignStepAST([
         [
-            resultVariable ?? '__temp',
+            resultVariable,
             new FunctionInvocationExpression(functionName, argumentExpressions),
         ],
     ]);
@@ -199,18 +467,21 @@ function createCallStep(node, argumentsNode, resultVariable) {
         throw new WorkflowSyntaxError('The first argument must be a Function', node.loc);
     }
     let functionName;
-    if (argumentsNode[0].type === AST_NODE_TYPES.Identifier) {
-        functionName = argumentsNode[0].name;
-    }
-    else if (argumentsNode[0].type === AST_NODE_TYPES.MemberExpression) {
-        const memberExp = convertMemberExpression(argumentsNode[0]);
+    const argNode = argumentsNode[0].type === AST_NODE_TYPES.TSInstantiationExpression
+        ? argumentsNode[0].expression
+        : argumentsNode[0];
+    if (argNode.type === AST_NODE_TYPES.Identifier) {
+        functionName = argNode.name;
+    }
+    else if (argNode.type === AST_NODE_TYPES.MemberExpression) {
+        const memberExp = convertMemberExpression(argNode);
         if (!isFullyQualifiedName(memberExp)) {
-            throw new WorkflowSyntaxError('Function name must be a fully-qualified name', argumentsNode[0].loc);
+            throw new WorkflowSyntaxError('Function name must be a fully-qualified name', argNode.loc);
         }
         functionName = memberExp.toString();
     }
     else {
-        throw new WorkflowSyntaxError('Expected an identifier or a member expression', argumentsNode[0].loc);
+        throw new WorkflowSyntaxError('Expected an identifier or a member expression', argNode.loc);
     }
     let args = {};
     if (argumentsNode.length >= 2) {
@@ -242,14 +513,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);
@@ -266,25 +542,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 ||
@@ -327,8 +599,8 @@ function parseParallelOptions(node) {
         exceptionPolicy,
     };
 }
-function generalExpressionToAssignStep(node) {
-    return new AssignStepAST([['__temp', convertExpression(node)]]);
+function generalExpressionToAssignStep(node, ctx) {
+    return new AssignStepAST([[tempName(ctx), convertExpression(node)]]);
 }
 function returnStatementToReturnStep(node, ctx) {
     const value = node.argument ? convertExpression(node.argument) : undefined;
@@ -358,7 +630,7 @@ function flattenIfBranches(ifStatement, ctx) {
         }
         else {
             branches.push({
-                condition: new PrimitiveExpression(true),
+                condition: trueEx,
                 steps: parseStatement(ifStatement.alternate, ctx),
             });
         }
@@ -378,10 +650,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({
@@ -413,12 +685,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) &&
@@ -440,7 +712,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([
@@ -580,8 +852,8 @@ function extractErrorVariableName(param) {
  */
 function finalizerInitializer(conditionVariable, valueVariable) {
     return new AssignStepAST([
-        [conditionVariable, new PrimitiveExpression(null)],
-        [valueVariable, new PrimitiveExpression(null)],
+        [conditionVariable, nullEx],
+        [valueVariable, nullEx],
     ]);
 }
 /**
@@ -597,16 +869,18 @@ 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)],
         },
     ]);
 }
@@ -628,7 +902,7 @@ function delayedReturnAndJumpToFinalizer(value, ctx) {
     const [conditionVariable, valueVariable] = finalizerVariables(ctx);
     return new AssignStepAST([
         [conditionVariable, new PrimitiveExpression('return')],
-        [valueVariable, value ?? new PrimitiveExpression(null)],
+        [valueVariable, value ?? nullEx],
     ], finalizerTarget);
 }
 function labeledStep(node, ctx) {
@@ -661,43 +935,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';
     }
 }