ts2workflows 0.11.0 → 0.13.0

package/dist/transpiler/parsestatement.js

@@ -0,0 +1,862 @@
+import * as R from 'ramda';
+import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
+import { binaryEx, expressionToString, functionInvocationEx, isQualifiedName, isPrimitive, listEx, memberEx, nullEx, numberEx, stringEx, trueEx, variableReferenceEx, } from '../ast/expressions.js';
+import { AssignStatement, FunctionInvocationStatement, IfStatement, ForStatement, LabelledStatement, ParallelForStatement, ParallelStatement, RaiseStatement, ForRangeStatement, ReturnStatement, TryStatement, WhileStatement, DoWhileStatement, BreakStatement, ContinueStatement, SwitchStatement, } from '../ast/statements.js';
+import { WorkflowSyntaxError } from '../errors.js';
+import { convertExpression, convertMemberExpression, convertObjectExpression, isIntrinsic, throwIfSpread, isIntrinsicStatement, convertAssignmentTarget, } from './parseexpressions.js';
+import { blockingFunctions } from './generated/functionMetadata.js';
+export function parseStatement(node, ctx) {
+    switch (node.type) {
+        case AST_NODE_TYPES.BlockStatement:
+            return node.body.flatMap((node) => parseStatement(node, ctx));
+        case AST_NODE_TYPES.VariableDeclaration:
+            return convertVariableDeclarations(node, ctx);
+        case AST_NODE_TYPES.ExpressionStatement:
+            if (node.expression.type === AST_NODE_TYPES.AssignmentExpression) {
+                return assignmentExpressionToStatement(node.expression, ctx);
+            }
+            else if (node.expression.type === AST_NODE_TYPES.CallExpression) {
+                return callExpressionToStatement(node.expression, undefined, ctx);
+            }
+            else {
+                return [generalExpressionToAssignment(node.expression, ctx)];
+            }
+        case AST_NODE_TYPES.ReturnStatement:
+            return [createReturnStatement(node)];
+        case AST_NODE_TYPES.ThrowStatement:
+            return [createRaiseStatement(node)];
+        case AST_NODE_TYPES.IfStatement:
+            return [createIfStatement(node, ctx)];
+        case AST_NODE_TYPES.SwitchStatement:
+            return createSwitchStatement(node, ctx);
+        case AST_NODE_TYPES.ForStatement:
+            throw new WorkflowSyntaxError('for is not a supported construct. Use for...of.', node.loc);
+        case AST_NODE_TYPES.ForInStatement:
+            throw new WorkflowSyntaxError('for...in is not a supported construct. Use for...of.', node.loc);
+        case AST_NODE_TYPES.ForOfStatement:
+            return [createForOfStatement(node, ctx)];
+        case AST_NODE_TYPES.DoWhileStatement:
+            return createDoWhileStatement(node, ctx);
+        case AST_NODE_TYPES.WhileStatement:
+            return createWhileStatement(node, ctx);
+        case AST_NODE_TYPES.BreakStatement:
+            return [createBreakStatement(node)];
+        case AST_NODE_TYPES.ContinueStatement:
+            return [createContinueStatement(node)];
+        case AST_NODE_TYPES.TryStatement:
+            return createTryStatement(node, ctx);
+        case AST_NODE_TYPES.LabeledStatement:
+            return [createLabeledStatement(node, ctx)];
+        case AST_NODE_TYPES.EmptyStatement:
+            return [];
+        case AST_NODE_TYPES.FunctionDeclaration:
+            throw new WorkflowSyntaxError('Functions must be defined at the top level of a source file', node.loc);
+        case AST_NODE_TYPES.DebuggerStatement:
+        case AST_NODE_TYPES.TSInterfaceDeclaration:
+        case AST_NODE_TYPES.TSTypeAliasDeclaration:
+        case AST_NODE_TYPES.TSDeclareFunction:
+            // Ignore "debugger", "type", "interface" and "declare function"
+            return [];
+        default:
+            throw new WorkflowSyntaxError(`${node.type} is not supported`, node.loc);
+    }
+}
+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.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 {
+            // decl.id.type === AST_NODE_TYPES.Identifier
+            return convertInitializer(decl.id.name, decl.init, ctx);
+        }
+    });
+}
+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 callExpressionToStatement(initializer, targetVariableName, ctx);
+    }
+    else {
+        const name = variableReferenceEx(targetVariableName);
+        const value = initializer === null ? nullEx : convertExpression(initializer);
+        return [new AssignStatement([{ name, value }])];
+    }
+}
+function convertArrayDestructuring(arrayPattern, initializer, ctx) {
+    let initExpression;
+    const statements = [];
+    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);
+        statements.push(...convertInitializer(initName, initializer, ctx));
+        initExpression = variableReferenceEx(initName);
+    }
+    statements.push(...arrayDestructuringStatements(arrayPattern.elements, initExpression, ctx));
+    return statements;
+}
+function arrayDestructuringStatements(patterns, initializerExpression, ctx) {
+    if (patterns.filter((p) => p !== null).length === 0) {
+        return [];
+    }
+    const __temp_len = variableReferenceEx(`${tempName(ctx)}_len`);
+    const initializeVariables = [
+        {
+            name: __temp_len,
+            value: functionInvocationEx('len', [initializerExpression]),
+        },
+    ];
+    const branches = R.reverse(patterns).flatMap((pat, i) => {
+        if (pat === null) {
+            return [];
+        }
+        else {
+            return [
+                {
+                    condition: binaryEx(__temp_len, '>=', numberEx(patterns.length - i)),
+                    body: arrayElementsDestructuringStatements(patterns, initializerExpression, patterns.length - i, ctx),
+                },
+            ];
+        }
+    });
+    branches.push({
+        condition: trueEx,
+        body: arrayElementsDestructuringStatements(patterns, initializerExpression, 0, ctx),
+    });
+    return [new AssignStatement(initializeVariables), new IfStatement(branches)];
+}
+function arrayElementsDestructuringStatements(patterns, initializerExpression, take, ctx) {
+    return patterns.flatMap((pat, i) => {
+        if (i >= take) {
+            return [
+                new AssignStatement(extractDefaultAssignmentsFromDestructuringPattern(pat)),
+            ];
+        }
+        const iElement = memberEx(initializerExpression, numberEx(i), true);
+        switch (pat?.type) {
+            case AST_NODE_TYPES.MemberExpression:
+            case AST_NODE_TYPES.Identifier:
+                return [
+                    new AssignStatement([
+                        { name: convertAssignmentTarget(pat), 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 = variableReferenceEx(pat.left.name);
+                return [new AssignStatement([{ name, value: iElement }])];
+            }
+            case AST_NODE_TYPES.ObjectPattern:
+                return objectDestructuringStatements(pat.properties, iElement, ctx);
+            case AST_NODE_TYPES.ArrayPattern:
+                return arrayDestructuringStatements(pat.elements, iElement, ctx);
+            case AST_NODE_TYPES.RestElement:
+                return arrayRestDestructuringStatements(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 [
+                {
+                    name: variableReferenceEx(pat.left.name),
+                    value: convertExpression(pat.right),
+                },
+            ];
+        case AST_NODE_TYPES.Identifier:
+            return [{ name: variableReferenceEx(pat.name), value: nullEx }];
+        case AST_NODE_TYPES.MemberExpression:
+            return [{ name: convertAssignmentTarget(pat), value: nullEx }];
+        case AST_NODE_TYPES.ObjectPattern:
+            return pat.properties.flatMap((p) => {
+                if (p.type === AST_NODE_TYPES.RestElement) {
+                    if (p.argument.type !== AST_NODE_TYPES.Identifier) {
+                        throw new WorkflowSyntaxError('Identifier expected', p.argument.loc);
+                    }
+                    return [{ name: variableReferenceEx(p.argument.name), value: nullEx }];
+                }
+                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: variableReferenceEx(pat.argument.name),
+                    value: listEx([]),
+                },
+            ];
+    }
+}
+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 arrayRestDestructuringStatements(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 = variableReferenceEx(rest.argument.name);
+    const __temp_len = variableReferenceEx(`${tempName(ctx)}_len`);
+    const __temp_index = `${tempName(ctx)}_index`;
+    const one = numberEx(1);
+    const emptyArray = listEx([]);
+    const copyLoop = new ForRangeStatement([
+        new AssignStatement([
+            {
+                name: restName,
+                value: functionInvocationEx('list.concat', [
+                    restName,
+                    memberEx(initializerExpression, variableReferenceEx(__temp_index), true),
+                ]),
+            },
+        ]),
+    ], __temp_index, startIndex, binaryEx(__temp_len, '-', one));
+    return [
+        new AssignStatement([{ name: restName, value: emptyArray }]),
+        copyLoop,
+    ];
+}
+function convertObjectDestructuring(objectPattern, initializer, ctx) {
+    let initExpression;
+    const statements = [];
+    if (initializer?.type === AST_NODE_TYPES.Identifier ||
+        (initializer?.type === AST_NODE_TYPES.MemberExpression &&
+            isQualifiedName(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);
+        statements.push(...convertInitializer(initName, initializer, ctx));
+        initExpression = variableReferenceEx(initName);
+    }
+    statements.push(...objectDestructuringStatements(objectPattern.properties, initExpression, ctx));
+    return statements;
+}
+function objectDestructuringStatements(properties, initializerExpression, ctx) {
+    return properties.flatMap((prop) => {
+        if (prop.type === AST_NODE_TYPES.RestElement) {
+            return objectDestructuringRestStatements(properties, prop, initializerExpression);
+        }
+        if (prop.key.type !== AST_NODE_TYPES.Identifier) {
+            throw new WorkflowSyntaxError('Identifier expected', prop.key.loc);
+        }
+        const keyExpression = memberEx(initializerExpression, variableReferenceEx(prop.key.name), false);
+        if (prop.value.type === AST_NODE_TYPES.ObjectPattern) {
+            return objectDestructuringStatements(prop.value.properties, keyExpression, ctx);
+        }
+        else if (prop.value.type === AST_NODE_TYPES.ArrayPattern) {
+            return arrayDestructuringStatements(prop.value.elements, keyExpression, ctx);
+        }
+        else if (prop.value.type === AST_NODE_TYPES.Identifier) {
+            const safeKeyExpression = functionInvocationEx('map.get', [
+                initializerExpression,
+                stringEx(prop.key.name),
+            ]);
+            return [
+                new AssignStatement([
+                    {
+                        name: variableReferenceEx(prop.value.name),
+                        value: safeKeyExpression,
+                    },
+                ]),
+            ];
+        }
+        else if (prop.value.type === AST_NODE_TYPES.AssignmentPattern) {
+            return objectAssignmentPatternStatements(prop.value, initializerExpression, keyExpression);
+        }
+        else {
+            throw new WorkflowSyntaxError(`${prop.value.type} is not allowed in object destructuring`, prop.value.loc);
+        }
+    });
+}
+function objectAssignmentPatternStatements(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 an if statement instead of default() because pat.right must be
+    // evaluated only in the default value branch (in case it has side effects)
+    const name = variableReferenceEx(pat.left.name);
+    return [
+        new IfStatement([
+            {
+                condition: binaryEx(stringEx(pat.left.name), 'in', initializerExpression),
+                body: [new AssignStatement([{ name, value: keyExpression }])],
+            },
+            {
+                condition: trueEx,
+                body: [
+                    new AssignStatement([{ name, value: convertExpression(pat.right) }]),
+                ],
+            },
+        ]),
+    ];
+}
+function objectDestructuringRestStatements(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((k) => {
+        if (k.type !== AST_NODE_TYPES.Identifier) {
+            throw new WorkflowSyntaxError('Identifier expected', k.loc);
+        }
+        return k.name;
+    });
+    const name = variableReferenceEx(rest.argument.name);
+    const value = nonRestKeys.reduce((acc, propertyName) => 
+    // map.delete returns a copy of the object and removes the specified property
+    functionInvocationEx('map.delete', [acc, stringEx(propertyName)]), initializerExpression);
+    return [new AssignStatement([{ name, value }])];
+}
+function assignmentExpressionToStatement(node, ctx) {
+    let compoundOperator = undefined;
+    switch (node.operator) {
+        case '=':
+            compoundOperator = undefined;
+            break;
+        case '+=':
+            compoundOperator = '+';
+            break;
+        case '-=':
+            compoundOperator = '-';
+            break;
+        case '*=':
+            compoundOperator = '*';
+            break;
+        case '/=':
+            compoundOperator = '/';
+            break;
+        case '%=':
+            compoundOperator = '%';
+            break;
+        case '&&=':
+            compoundOperator = 'and';
+            break;
+        case '||=':
+            compoundOperator = 'or';
+            break;
+        default:
+            throw new WorkflowSyntaxError(`Operator ${node.operator} is not supported in assignment expressions`, node.loc);
+    }
+    if (compoundOperator === undefined) {
+        return assignmentStatements(node.left, node.right, ctx);
+    }
+    else {
+        return compoundAssignmentStatements(node.left, node.right, compoundOperator, ctx);
+    }
+}
+function assignmentStatements(left, right, ctx) {
+    let valueExpression;
+    const statements = [];
+    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, right.callee.name, ctx);
+        statements.push(...tr.statements);
+        valueExpression = tr.tempVariable;
+    }
+    else {
+        valueExpression = convertExpression(right);
+    }
+    const targetExpression = convertAssignmentTarget(left);
+    statements.push(new AssignStatement([{ name: targetExpression, value: valueExpression }]));
+    return statements;
+}
+function compoundAssignmentStatements(left, right, operator, ctx) {
+    let valueExpression;
+    const { expression: targetExpression, statements } = 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, right.callee.name, ctx);
+        statements.push(...tr.statements);
+        valueExpression = tr.tempVariable;
+    }
+    else {
+        valueExpression = convertExpression(right);
+    }
+    valueExpression = binaryEx(targetExpression, operator, valueExpression);
+    statements.push(new AssignStatement([{ name: targetExpression, value: valueExpression }]));
+    return statements;
+}
+function convertCompoundAssignmentLeftHandSide(left, ctx) {
+    const leftEx = convertAssignmentTarget(left);
+    const { transformed, assignments } = extractSideEffectsFromMemberExpression(leftEx, tempName(ctx), 0);
+    return {
+        expression: transformed,
+        statements: assignments.length > 0 ? [new AssignStatement(assignments)] : [],
+    };
+}
+/**
+ * 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.tag === 'member' && ex.computed && !isPrimitive(ex.property)) {
+        // property potentially has side effects. Move to a temp variable for safety.
+        let transformedObject;
+        let objectAssignments;
+        if (ex.object.tag === 'member') {
+            const object2 = extractSideEffectsFromMemberExpression(ex.object, tempPrefix, tempIndex + 1);
+            transformedObject = object2.transformed;
+            objectAssignments = object2.assignments;
+        }
+        else {
+            transformedObject = ex.object;
+            objectAssignments = [];
+        }
+        const tmp = variableReferenceEx(`${tempPrefix}${tempIndex}`);
+        const transformed = memberEx(transformedObject, tmp, true);
+        const assignments = objectAssignments;
+        assignments.push({
+            name: tmp,
+            value: ex.property,
+        });
+        return { transformed, assignments };
+    }
+    else if (ex.tag === 'member' && ex.object.tag === 'member') {
+        const { transformed: object2, assignments } = extractSideEffectsFromMemberExpression(ex.object, tempPrefix, tempIndex);
+        const transformed = memberEx(object2, ex.property, ex.computed);
+        return { transformed, assignments };
+    }
+    else {
+        return {
+            transformed: ex,
+            assignments: [],
+        };
+    }
+}
+/**
+ * Special case for handling call_step() RHS in assignment expressions.
+ */
+function convertAssignmentExpressionIntrinsicRHS(callEx, calleeName, ctx) {
+    if (isIntrinsicStatement(calleeName)) {
+        throw new WorkflowSyntaxError(`"${calleeName}" can't be called as part of an expression`, callEx.callee.loc);
+    }
+    const resultVariable = tempName(ctx);
+    return {
+        statements: callExpressionToStatement(callEx, resultVariable, ctx),
+        tempVariable: variableReferenceEx(resultVariable),
+    };
+}
+function callExpressionToStatement(node, resultVariable, ctx) {
+    const calleeExpression = convertExpression(node.callee);
+    if (isQualifiedName(calleeExpression)) {
+        const calleeName = expressionToString(calleeExpression);
+        if (calleeName === 'parallel') {
+            // A handle the "parallel" intrinsic
+            return [createParallelStatement(node.arguments, node.loc, ctx)];
+        }
+        else if (calleeName === 'retry_policy') {
+            // retry_policy() is handled by AST_NODE_TYPES.TryStatement and therefore ignored here
+            return [];
+        }
+        else if (calleeName === 'call_step') {
+            return [createCallStatement(node, node.arguments, resultVariable)];
+        }
+        else if (blockingFunctions.has(calleeName)) {
+            const argumentNames = blockingFunctions.get(calleeName) ?? [];
+            return [
+                blockingFunctionStatement(calleeName, argumentNames, node.arguments, resultVariable),
+            ];
+        }
+        else {
+            const resultVariable2 = resultVariable ?? tempName(ctx);
+            return [
+                callExpressionAssignment(calleeName, node.arguments, resultVariable2),
+            ];
+        }
+    }
+    else {
+        throw new WorkflowSyntaxError('Expeced a subworkflow or a standard library function name', node.callee.loc);
+    }
+}
+function callExpressionAssignment(functionName, argumentsNode, resultVariable) {
+    const argumentExpressions = throwIfSpread(argumentsNode).map(convertExpression);
+    return new AssignStatement([
+        {
+            name: variableReferenceEx(resultVariable),
+            value: functionInvocationEx(functionName, argumentExpressions),
+        },
+    ]);
+}
+function createCallStatement(node, argumentsNode, resultVariable) {
+    if (argumentsNode.length < 1) {
+        throw new WorkflowSyntaxError('The first argument must be a Function', node.loc);
+    }
+    let functionName;
+    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 (!isQualifiedName(memberExp)) {
+            throw new WorkflowSyntaxError('Function name must be a qualified name', argNode.loc);
+        }
+        functionName = expressionToString(memberExp);
+    }
+    else {
+        throw new WorkflowSyntaxError('Expected an identifier or a member expression', argNode.loc);
+    }
+    let args = {};
+    if (argumentsNode.length >= 2) {
+        if (argumentsNode[1].type !== AST_NODE_TYPES.ObjectExpression) {
+            throw new WorkflowSyntaxError('The second argument must be a map literal', argumentsNode[1].loc);
+        }
+        args = convertObjectExpression(argumentsNode[1]).value;
+    }
+    return new FunctionInvocationStatement(functionName, args, resultVariable);
+}
+function blockingFunctionStatement(functionName, argumentNames, argumentsNode, resultName) {
+    const argumentExpressions = throwIfSpread(argumentsNode).map(convertExpression);
+    const args = Object.fromEntries(argumentNames.flatMap((argName, i) => {
+        if (i >= argumentExpressions.length) {
+            return [];
+        }
+        else if (argumentsNode[i].type === AST_NODE_TYPES.Identifier &&
+            argumentsNode[i].name === 'undefined') {
+            return [];
+        }
+        else {
+            return [[argName, argumentExpressions[i]]];
+        }
+    }));
+    return new FunctionInvocationStatement(functionName, args, resultName);
+}
+function createParallelStatement(args, loc, ctx) {
+    const { shared, concurrencyLimit, exceptionPolicy } = parseParallelOptions(args[1]);
+    const ctx2 = Object.assign({}, ctx, {
+        parallelNestingLevel: ctx.parallelNestingLevel
+            ? ctx.parallelNestingLevel + 1
+            : 1,
+    });
+    switch (args[0]?.type) {
+        case AST_NODE_TYPES.ArrayExpression:
+            return new ParallelStatement(parseParallelBranches(args[0], ctx2), shared, concurrencyLimit, exceptionPolicy);
+        case AST_NODE_TYPES.ArrowFunctionExpression:
+            return new ParallelForStatement(parseParallelIteration(args[0], ctx2), shared, concurrencyLimit, exceptionPolicy);
+        case undefined:
+            throw new WorkflowSyntaxError('At least one argument required', loc);
+        default:
+            throw new WorkflowSyntaxError('The first parameter must be an array of functions or an arrow function', args[0].loc);
+    }
+}
+function parseParallelBranches(node, ctx) {
+    const branches = node.elements.map((arg) => {
+        switch (arg?.type) {
+            case AST_NODE_TYPES.Identifier:
+                return [new FunctionInvocationStatement(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);
+                }
+                if (arg.params.length > 0) {
+                    throw new WorkflowSyntaxError('Parallel functions must not take arguments', arg.params[0].loc);
+                }
+                return parseStatement(arg.body, ctx);
+            default:
+                throw new WorkflowSyntaxError('Argument should be a function of type () => void', arg ? arg.loc : node.loc);
+        }
+    });
+    return branches.map((statements, i) => ({
+        name: `branch${i + 1}`,
+        body: statements,
+    }));
+}
+function parseParallelIteration(node, ctx) {
+    if (node.body.type !== AST_NODE_TYPES.BlockStatement ||
+        node.body.body.length !== 1 ||
+        node.body.body[0].type !== AST_NODE_TYPES.ForOfStatement) {
+        throw new WorkflowSyntaxError('The parallel function body must be a single for...of statement', node.body.loc);
+    }
+    return createForOfStatement(node.body.body[0], ctx);
+}
+function parseParallelOptions(node) {
+    if (node === undefined) {
+        return {};
+    }
+    if (node.type !== AST_NODE_TYPES.ObjectExpression) {
+        throw new WorkflowSyntaxError('The second parameter must be an object', node.loc);
+    }
+    const parallelOptions = convertObjectExpression(node);
+    const opts = parallelOptions.value;
+    const sharedExpression = opts.shared;
+    if (sharedExpression && sharedExpression.tag !== 'list') {
+        throw new WorkflowSyntaxError('"shared" must be an array of strings', node.loc);
+    }
+    const shared = sharedExpression?.value.map((x) => {
+        if (x.tag !== 'string') {
+            throw new WorkflowSyntaxError('"shared" must be an array of strings', node.loc);
+        }
+        return x;
+    });
+    const concurrencyLimitExpression = opts.concurrency_limit;
+    if (concurrencyLimitExpression &&
+        concurrencyLimitExpression.tag !== 'number') {
+        throw new WorkflowSyntaxError('"concurrency_limit" must be a number', node.loc);
+    }
+    const exceptionPolicyExpression = opts.exception_policy;
+    if (exceptionPolicyExpression && exceptionPolicyExpression.tag !== 'string') {
+        throw new WorkflowSyntaxError('"exception_policy" must be a string', node.loc);
+    }
+    return {
+        shared: shared?.map((x) => x.value),
+        concurrencyLimit: concurrencyLimitExpression?.value,
+        exceptionPolicy: exceptionPolicyExpression?.value,
+    };
+}
+function generalExpressionToAssignment(node, ctx) {
+    return new AssignStatement([
+        {
+            name: variableReferenceEx(tempName(ctx)),
+            value: convertExpression(node),
+        },
+    ]);
+}
+function createReturnStatement(node) {
+    const value = node.argument ? convertExpression(node.argument) : undefined;
+    return new ReturnStatement(value);
+}
+function createRaiseStatement(node) {
+    return new RaiseStatement(convertExpression(node.argument));
+}
+function createIfStatement(node, ctx) {
+    return new IfStatement(flattenIfBranches(node, ctx));
+}
+function flattenIfBranches(ifStatement, ctx) {
+    const branches = [
+        {
+            condition: convertExpression(ifStatement.test),
+            body: parseStatement(ifStatement.consequent, ctx),
+        },
+    ];
+    if (ifStatement.alternate) {
+        if (ifStatement.alternate.type === AST_NODE_TYPES.IfStatement) {
+            branches.push(...flattenIfBranches(ifStatement.alternate, ctx));
+        }
+        else {
+            branches.push({
+                condition: trueEx,
+                body: parseStatement(ifStatement.alternate, ctx),
+            });
+        }
+    }
+    return branches;
+}
+function createSwitchStatement(node, ctx) {
+    const discriminant = convertExpression(node.discriminant);
+    const branches = node.cases.map((switchCase) => {
+        let condition;
+        if (switchCase.test) {
+            const test = convertExpression(switchCase.test);
+            condition = binaryEx(discriminant, '==', test);
+        }
+        else {
+            condition = trueEx;
+        }
+        const body = switchCase.consequent.flatMap((x) => parseStatement(x, ctx));
+        return { condition, body };
+    });
+    return [new SwitchStatement(branches)];
+}
+function createForOfStatement(node, ctx) {
+    const bodyCtx = Object.assign({}, ctx, {
+        continueTarget: undefined,
+        breakTarget: undefined,
+    });
+    const statements = parseStatement(node.body, bodyCtx);
+    let loopVariableName;
+    if (node.left.type === AST_NODE_TYPES.Identifier) {
+        loopVariableName = node.left.name;
+    }
+    else if (node.left.type === AST_NODE_TYPES.VariableDeclaration &&
+        node.left.declarations.length >= 1) {
+        const declaration = node.left.declarations[0];
+        if (declaration.id.type !== AST_NODE_TYPES.Identifier) {
+            throw new WorkflowSyntaxError(`Identifier expected, got ${declaration.id.type}`, declaration.id.loc);
+        }
+        loopVariableName = declaration.id.name;
+    }
+    else {
+        throw new WorkflowSyntaxError('Unsupported initializer', node.left.loc);
+    }
+    const listExpression = convertExpression(node.right);
+    if (isPrimitive(listExpression) || listExpression.tag === 'map') {
+        throw new WorkflowSyntaxError('Must be a list expression', node.right.loc);
+    }
+    return new ForStatement(statements, loopVariableName, listExpression);
+}
+function createWhileStatement(node, ctx) {
+    const condition = convertExpression(node.test);
+    const body = parseStatement(node.body, ctx);
+    return [new WhileStatement(condition, body)];
+}
+function createDoWhileStatement(node, ctx) {
+    const body = parseStatement(node.body, ctx);
+    const condition = convertExpression(node.test);
+    return [new DoWhileStatement(condition, body)];
+}
+function createBreakStatement(node) {
+    return new BreakStatement(node.label?.name);
+}
+function createContinueStatement(node) {
+    return new ContinueStatement(node.label?.name);
+}
+function createTryStatement(node, ctx) {
+    const retryPolicy = extractRetryPolicy(node.block);
+    const tryBody = parseStatement(node.block, ctx);
+    let exceptBody = undefined;
+    let errorVariable = undefined;
+    if (node.handler) {
+        exceptBody = parseStatement(node.handler.body, ctx);
+        errorVariable = extractErrorVariableName(node.handler.param);
+    }
+    let finalizerBody = undefined;
+    if (node.finalizer) {
+        finalizerBody = parseStatement(node.finalizer, ctx);
+    }
+    return [
+        new TryStatement(tryBody, exceptBody, retryPolicy, errorVariable, finalizerBody),
+    ];
+}
+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 (isQualifiedName(arg0)) {
+                return expressionToString(arg0);
+            }
+            else if (arg0.tag === 'map') {
+                return retryPolicyFromParams(arg0.value, argsLoc);
+            }
+            else {
+                throw new WorkflowSyntaxError('Unexpected type', argsLoc);
+            }
+        }
+    }
+    return undefined;
+}
+function retryPolicyFromParams(params, argsLoc) {
+    if (!('backoff' in params)) {
+        throw new WorkflowSyntaxError('Required parameter "backoff" missing', argsLoc);
+    }
+    else if (params.backoff.tag !== 'map') {
+        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: backoff.initial_delay,
+            maxDelay: backoff.max_delay,
+            multiplier: backoff.multiplier,
+        },
+    };
+}
+function predicateFromRetryParams(params, argsLoc) {
+    if (!('predicate' in params)) {
+        return undefined;
+    }
+    else if (isQualifiedName(params.predicate)) {
+        return expressionToString(params.predicate);
+    }
+    else {
+        throw new WorkflowSyntaxError('"predicate" must be a function name', argsLoc);
+    }
+}
+function extractErrorVariableName(param) {
+    if (!param) {
+        return undefined;
+    }
+    if (param.type !== AST_NODE_TYPES.Identifier) {
+        throw new WorkflowSyntaxError('The error variable must be an identifier', param.loc);
+    }
+    return param.name;
+}
+function createLabeledStatement(node, ctx) {
+    return new LabelledStatement(node.label.name, parseStatement(node.body, ctx));
+}
+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}`;
+    }
+    else {
+        return '__temp';
+    }
+}