ts2workflows 0.3.0 → 0.4.0

package/dist/transpiler/statements.js

@@ -1,105 +1,89 @@
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument */
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-import { AssignStepAST, CallStepAST, ForStepAST, JumpTargetAST, NextStepAST, ParallelStepAST, RaiseStepAST, ReturnStepAST, StepsStepAST, SwitchStepAST, TryStepAST, stepWithLabel, } from '../ast/steps.js';
+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 { InternalTranspilingError, WorkflowSyntaxError } from '../errors.js';
 import { isRecord } from '../utils.js';
 import { transformAST } from './transformations.js';
-import { assertType } from './asserts.js';
-import { convertExpression, convertMemberExpression, convertObjectExpression, convertObjectAsExpressionValues, } from './expressions.js';
+import { convertExpression, convertMemberExpression, convertObjectExpression, convertObjectAsExpressionValues, isMagicFunction, throwIfSpread, } from './expressions.js';
 import { blockingFunctions } from './generated/functionMetadata.js';
-const { ArrayExpression, ArrowFunctionExpression, AssignmentExpression, BlockStatement, BreakStatement, CallExpression, ContinueStatement, DoWhileStatement, EmptyStatement, ExpressionStatement, ForInStatement, ForOfStatement, FunctionDeclaration, Identifier, IfStatement, LabeledStatement, MemberExpression, ObjectExpression, ReturnStatement, SwitchCase, SwitchStatement, ThrowStatement, TryStatement, TSDeclareFunction, TSTypeAliasDeclaration, TSInterfaceDeclaration, VariableDeclaration, VariableDeclarator, WhileStatement, } = AST_NODE_TYPES;
-export function parseBlockStatement(node, ctx) {
-    assertType(node, BlockStatement);
-    const body = node.body;
-    return transformAST(body.flatMap((x) => parseStep(x, ctx)));
+export function parseStatement(node, ctx, postSteps) {
+    const steps = parseStatementRecursively(node, ctx);
+    return transformAST(steps.concat(postSteps ?? []));
 }
-function parseStep(node, ctx) {
+function parseStatementRecursively(node, ctx) {
     switch (node.type) {
-        case VariableDeclaration:
-            return convertVariableDeclarations(node.declarations);
-        case ExpressionStatement:
-            if (node.expression.type === AssignmentExpression) {
-                return assignmentExpressionToSteps(node.expression);
+        case AST_NODE_TYPES.BlockStatement:
+            return node.body.flatMap((statement) => parseStatementRecursively(statement, ctx));
+        case AST_NODE_TYPES.VariableDeclaration:
+            return convertVariableDeclarations(node.declarations, ctx);
+        case AST_NODE_TYPES.ExpressionStatement:
+            if (node.expression.type === AST_NODE_TYPES.AssignmentExpression) {
+                return assignmentExpressionToSteps(node.expression, ctx);
             }
-            else if (node.expression.type === CallExpression) {
-                return [callExpressionToStep(node.expression, ctx)];
+            else if (node.expression.type === AST_NODE_TYPES.CallExpression) {
+                return [callExpressionToStep(node.expression, undefined, ctx)];
             }
             else {
                 return [generalExpressionToAssignStep(node.expression)];
             }
-        case ReturnStatement:
+        case AST_NODE_TYPES.ReturnStatement:
             return [returnStatementToReturnStep(node)];
-        case ThrowStatement:
+        case AST_NODE_TYPES.ThrowStatement:
             return [throwStatementToRaiseStep(node)];
-        case IfStatement:
+        case AST_NODE_TYPES.IfStatement:
             return [ifStatementToSwitchStep(node, ctx)];
-        case SwitchStatement:
+        case AST_NODE_TYPES.SwitchStatement:
             return switchStatementToSteps(node, ctx);
-        case ForInStatement:
+        case AST_NODE_TYPES.ForInStatement:
             throw new WorkflowSyntaxError('for...in is not a supported construct. Use for...of.', node.loc);
-        case ForOfStatement:
+        case AST_NODE_TYPES.ForOfStatement:
             return [forOfStatementToForStep(node, ctx)];
-        case DoWhileStatement:
+        case AST_NODE_TYPES.DoWhileStatement:
             return doWhileStatementSteps(node, ctx);
-        case WhileStatement:
+        case AST_NODE_TYPES.WhileStatement:
             return whileStatementSteps(node, ctx);
-        case BreakStatement:
+        case AST_NODE_TYPES.BreakStatement:
             return [breakStatementToNextStep(node, ctx)];
-        case ContinueStatement:
+        case AST_NODE_TYPES.ContinueStatement:
             return [continueStatementToNextStep(node, ctx)];
-        case TryStatement:
+        case AST_NODE_TYPES.TryStatement:
             return [tryStatementToTryStep(node, ctx)];
-        case LabeledStatement:
+        case AST_NODE_TYPES.LabeledStatement:
             return labeledStep(node, ctx);
-        case EmptyStatement:
+        case AST_NODE_TYPES.EmptyStatement:
             return [];
-        case FunctionDeclaration:
+        case AST_NODE_TYPES.FunctionDeclaration:
             throw new WorkflowSyntaxError('Functions must be defined at the top level of a source file', node.loc);
-        case TSInterfaceDeclaration:
-        case TSTypeAliasDeclaration:
-        case TSDeclareFunction:
+        case AST_NODE_TYPES.TSInterfaceDeclaration:
+        case AST_NODE_TYPES.TSTypeAliasDeclaration:
+        case AST_NODE_TYPES.TSDeclareFunction:
             // Ignore "type", "interface" and "declare function"
             return [];
         default:
             throw new WorkflowSyntaxError(`TODO: encountered unsupported type: ${node.type}`, node.loc);
     }
 }
-function convertVariableDeclarations(declarations) {
+function convertVariableDeclarations(declarations, ctx) {
     return declarations.map((decl) => {
-        if (decl.type !== VariableDeclarator) {
+        if (decl.type !== AST_NODE_TYPES.VariableDeclarator) {
             throw new WorkflowSyntaxError('Not a VariableDeclarator', decl.loc);
         }
-        if (decl.id.type !== Identifier) {
+        if (decl.id.type !== AST_NODE_TYPES.Identifier) {
             throw new WorkflowSyntaxError('Expected Identifier', decl.loc);
         }
         const targetName = decl.id.name;
-        if (!decl.init) {
-            return new AssignStepAST([[targetName, new PrimitiveExpression(null)]]);
-        }
-        else if (decl.init.type === CallExpression) {
-            const maybeBlockingcall = getBlockingCallParameters(decl.init);
-            if (maybeBlockingcall.isBlockingCall) {
-                // This branch could be removed. The transform step for extracting
-                // blocking function would take care of this, but it creates an
-                // unnecessary temporary variable assignment step.
-                return blockingFunctionCallStep(maybeBlockingcall.functionName, maybeBlockingcall.argumentNames, decl.init.arguments, targetName);
-            }
-            else if (decl.init.callee.type === Identifier &&
-                decl.init.callee.name === 'call_step') {
-                return createCallStep(decl.init.arguments, targetName);
-            }
-            else {
-                return new AssignStepAST([[targetName, convertExpression(decl.init)]]);
-            }
+        if (decl.init?.type === AST_NODE_TYPES.CallExpression) {
+            return callExpressionToStep(decl.init, targetName, ctx);
         }
         else {
-            return new AssignStepAST([[targetName, convertExpression(decl.init)]]);
+            const value = decl.init == null
+                ? new PrimitiveExpression(null)
+                : convertExpression(decl.init);
+            return new AssignStepAST([[targetName, value]]);
         }
     });
 }
-function assignmentExpressionToSteps(node) {
-    assertType(node, AssignmentExpression);
+function assignmentExpressionToSteps(node, ctx) {
     let compoundOperator = undefined;
     switch (node.operator) {
         case '=':
@@ -133,25 +117,31 @@ function assignmentExpressionToSteps(node) {
     if (!isFullyQualifiedName(targetExpression)) {
         throw new WorkflowSyntaxError('The left-hand side of an assignment must be an identifier or a property access', node.loc);
     }
+    let valueExpression;
+    const steps = [];
     const targetName = targetExpression.toString();
-    let valueExpression = convertExpression(node.right);
+    if (node.right.type === AST_NODE_TYPES.CallExpression &&
+        node.right.callee.type === AST_NODE_TYPES.Identifier &&
+        isMagicFunction(node.right.callee.name)) {
+        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');
+    }
+    else {
+        valueExpression = convertExpression(node.right);
+    }
     if (compoundOperator) {
         valueExpression = new BinaryExpression(new VariableReferenceExpression(targetName), compoundOperator, valueExpression);
     }
-    return [new AssignStepAST([[targetName, valueExpression]])];
-}
-function getBlockingCallParameters(node) {
-    if (node?.type === CallExpression) {
-        const functionName = convertExpression(node.callee).toString();
-        const argumentNames = blockingFunctions.get(functionName);
-        if (argumentNames) {
-            return { isBlockingCall: true, functionName, argumentNames };
-        }
-    }
-    return { isBlockingCall: false };
+    steps.push(new AssignStepAST([[targetName, valueExpression]]));
+    return steps;
 }
-function callExpressionToStep(node, ctx) {
-    assertType(node, CallExpression);
+function callExpressionToStep(node, resultVariable, ctx) {
     const calleeExpression = convertExpression(node.callee);
     if (isFullyQualifiedName(calleeExpression)) {
         const calleeName = calleeExpression.toString();
@@ -160,48 +150,49 @@ function callExpressionToStep(node, ctx) {
             return callExpressionToParallelStep(node, ctx);
         }
         else if (calleeName === 'retry_policy') {
-            return callExpressionToCallStep(calleeName, node.arguments);
+            return callExpressionToCallStep(calleeName, node.arguments, resultVariable);
         }
         else if (calleeName === 'call_step') {
-            return createCallStep(node.arguments);
+            return createCallStep(node.arguments, resultVariable);
         }
         else if (blockingFunctions.has(calleeName)) {
             const argumentNames = blockingFunctions.get(calleeName) ?? [];
-            return blockingFunctionCallStep(calleeName, argumentNames, node.arguments);
+            return blockingFunctionCallStep(calleeName, argumentNames, node.arguments, resultVariable);
         }
         else {
-            return callExpressionAssignStep(calleeName, node.arguments);
+            return callExpressionAssignStep(calleeName, node.arguments, resultVariable);
         }
     }
     else {
         throw new WorkflowSyntaxError('Expeced a subworkflow or a standard library function name', node.callee.loc);
     }
 }
-function callExpressionAssignStep(functionName, argumentsNode) {
-    const argumentExpressions = argumentsNode.map(convertExpression);
+function callExpressionAssignStep(functionName, argumentsNode, resultVariable) {
+    const argumentExpressions = throwIfSpread(argumentsNode).map(convertExpression);
     return new AssignStepAST([
         [
-            '__temp',
+            resultVariable ?? '__temp',
             new FunctionInvocationExpression(functionName, argumentExpressions),
         ],
     ]);
 }
-function callExpressionToCallStep(functionName, argumentsNode) {
-    if (argumentsNode.length < 1 || argumentsNode[0].type !== ObjectExpression) {
+function callExpressionToCallStep(functionName, argumentsNode, resultVariable) {
+    if (argumentsNode.length < 1 ||
+        argumentsNode[0].type !== AST_NODE_TYPES.ObjectExpression) {
         throw new WorkflowSyntaxError('Expected one object parameter', argumentsNode[0].loc);
     }
     const workflowArguments = convertObjectAsExpressionValues(argumentsNode[0]);
-    return new CallStepAST(functionName, workflowArguments);
+    return new CallStepAST(functionName, workflowArguments, resultVariable);
 }
 function createCallStep(argumentsNode, resultVariable) {
     if (argumentsNode.length < 1) {
         throw new WorkflowSyntaxError('The first argument must be a Function', argumentsNode[0].loc);
     }
     let functionName;
-    if (argumentsNode[0].type === Identifier) {
+    if (argumentsNode[0].type === AST_NODE_TYPES.Identifier) {
         functionName = argumentsNode[0].name;
     }
-    else if (argumentsNode[0].type === MemberExpression) {
+    else if (argumentsNode[0].type === AST_NODE_TYPES.MemberExpression) {
         const memberExp = convertMemberExpression(argumentsNode[0]);
         if (!isFullyQualifiedName(memberExp)) {
             throw new WorkflowSyntaxError('Function name must be a fully-qualified name', argumentsNode[0].loc);
@@ -213,7 +204,7 @@ function createCallStep(argumentsNode, resultVariable) {
     }
     let args = {};
     if (argumentsNode.length >= 2) {
-        if (argumentsNode[1].type !== ObjectExpression) {
+        if (argumentsNode[1].type !== AST_NODE_TYPES.ObjectExpression) {
             throw new WorkflowSyntaxError('The second argument must be an object', argumentsNode[1].loc);
         }
         args = convertObjectAsExpressionValues(argumentsNode[1]);
@@ -221,12 +212,12 @@ function createCallStep(argumentsNode, resultVariable) {
     return new CallStepAST(functionName, args, resultVariable);
 }
 function blockingFunctionCallStep(functionName, argumentNames, argumentsNode, resultName) {
-    const argumentExpressions = argumentsNode.map(convertExpression);
+    const argumentExpressions = throwIfSpread(argumentsNode).map(convertExpression);
     const args = Object.fromEntries(argumentNames.flatMap((argName, i) => {
         if (i >= argumentExpressions.length) {
             return [];
         }
-        else if (argumentsNode[i].type === Identifier &&
+        else if (argumentsNode[i].type === AST_NODE_TYPES.Identifier &&
             argumentsNode[i].name === 'undefined') {
             return [];
         }
@@ -237,18 +228,17 @@ function blockingFunctionCallStep(functionName, argumentNames, argumentsNode, re
     return new CallStepAST(functionName, args, resultName);
 }
 function callExpressionToParallelStep(node, ctx) {
-    assertType(node, CallExpression);
-    assertType(node.callee, Identifier);
-    if (node.callee.name !== 'parallel') {
-        throw new TypeError(`The parameter must be a call to "parallel"`);
+    if (node.callee.type !== AST_NODE_TYPES.Identifier ||
+        node.callee.name !== 'parallel') {
+        throw new InternalTranspilingError(`The parameter must be a call to "parallel"`);
     }
     let steps = {};
     if (node.arguments.length > 0) {
         switch (node.arguments[0].type) {
-            case ArrayExpression:
+            case AST_NODE_TYPES.ArrayExpression:
                 steps = parseParallelBranches(node.arguments[0]);
                 break;
-            case ArrowFunctionExpression:
+            case AST_NODE_TYPES.ArrowFunctionExpression:
                 steps = parseParallelIteration(node.arguments[0], ctx);
                 break;
             default:
@@ -267,18 +257,19 @@ function callExpressionToParallelStep(node, ctx) {
     return new ParallelStepAST(steps, shared, concurrencyLimit, exceptionPolicy);
 }
 function parseParallelBranches(node) {
-    assertType(node, ArrayExpression);
-    const nodeElements = node.elements;
-    const stepsArray = nodeElements.map((arg, idx) => {
+    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) {
-            case Identifier:
+            case AST_NODE_TYPES.Identifier:
                 return [branchName, new StepsStepAST([new CallStepAST(arg.name)])];
-            case ArrowFunctionExpression:
-                return [
-                    branchName,
-                    new StepsStepAST(parseBlockStatement(arg.body, {})),
-                ];
+            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, {}))];
             default:
                 throw new WorkflowSyntaxError('Argument should be a function call of type () => void', arg.loc);
         }
@@ -286,15 +277,15 @@ function parseParallelBranches(node) {
     return Object.fromEntries(stepsArray);
 }
 function parseParallelIteration(node, ctx) {
-    assertType(node, ArrowFunctionExpression);
-    if (node.body.body.length !== 1 ||
-        node.body.body[0].type !== ForOfStatement) {
+    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 forOfStatementToForStep(node.body.body[0], ctx);
 }
 function parseParallelOptions(node) {
-    if (node.type !== ObjectExpression) {
+    if (node.type !== AST_NODE_TYPES.ObjectExpression) {
         throw new WorkflowSyntaxError('The second parameter must be an object', node.loc);
     }
     const parallelOptions = convertObjectExpression(node);
@@ -330,53 +321,42 @@ function generalExpressionToAssignStep(node) {
     return new AssignStepAST([['__temp', convertExpression(node)]]);
 }
 function returnStatementToReturnStep(node) {
-    assertType(node, ReturnStatement);
     const value = node.argument ? convertExpression(node.argument) : undefined;
     return new ReturnStepAST(value);
 }
 function throwStatementToRaiseStep(node) {
-    assertType(node, ThrowStatement);
     return new RaiseStepAST(convertExpression(node.argument));
 }
 function ifStatementToSwitchStep(node, ctx) {
-    assertType(node, IfStatement);
     return new SwitchStepAST(flattenIfBranches(node, ctx));
 }
 function flattenIfBranches(ifStatement, ctx) {
-    assertType(ifStatement, IfStatement);
-    assertType(ifStatement.consequent, BlockStatement);
     const branches = [
         {
             condition: convertExpression(ifStatement.test),
-            steps: parseBlockStatement(ifStatement.consequent, ctx),
+            steps: parseStatement(ifStatement.consequent, ctx),
         },
     ];
     if (ifStatement.alternate) {
-        if (ifStatement.alternate.type === BlockStatement) {
-            branches.push({
-                condition: new PrimitiveExpression(true),
-                steps: parseBlockStatement(ifStatement.alternate, ctx),
-            });
-        }
-        else if (ifStatement.alternate.type === IfStatement) {
+        if (ifStatement.alternate.type === AST_NODE_TYPES.IfStatement) {
             branches.push(...flattenIfBranches(ifStatement.alternate, ctx));
         }
         else {
-            throw new InternalTranspilingError(`Expected BlockStatement or IfStatement, got ${ifStatement.alternate.type}`);
+            branches.push({
+                condition: new PrimitiveExpression(true),
+                steps: parseStatement(ifStatement.alternate, ctx),
+            });
         }
     }
     return branches;
 }
 function switchStatementToSteps(node, ctx) {
-    assertType(node, SwitchStatement);
     const endOfSwitch = new JumpTargetAST();
     const switchCtx = Object.assign({}, ctx, { breakTarget: endOfSwitch.label });
     const steps = [];
     const branches = [];
     const discriminant = convertExpression(node.discriminant);
-    const cases = node.cases;
-    cases.forEach((caseNode) => {
-        assertType(caseNode, SwitchCase);
+    node.cases.forEach((caseNode) => {
         let condition;
         if (caseNode.test) {
             const test = convertExpression(caseNode.test);
@@ -386,8 +366,7 @@ function switchStatementToSteps(node, ctx) {
             condition = new PrimitiveExpression(true);
         }
         const jumpTarget = new JumpTargetAST();
-        const consequent = caseNode.consequent;
-        const body = transformAST(consequent.flatMap((x) => parseStep(x, switchCtx)));
+        const body = transformAST(caseNode.consequent.flatMap((x) => parseStatement(x, switchCtx)));
         steps.push(jumpTarget);
         steps.push(...body);
         branches.push({
@@ -401,18 +380,16 @@ function switchStatementToSteps(node, ctx) {
     return steps;
 }
 function forOfStatementToForStep(node, ctx) {
-    assertType(node, ForOfStatement);
-    assertType(node.body, BlockStatement);
     const bodyCtx = Object.assign({}, ctx, {
         continueTarget: undefined,
         breakTarget: undefined,
     });
-    const steps = parseBlockStatement(node.body, bodyCtx);
+    const steps = parseStatement(node.body, bodyCtx);
     let loopVariableName;
-    if (node.left.type === Identifier) {
+    if (node.left.type === AST_NODE_TYPES.Identifier) {
         loopVariableName = node.left.name;
     }
-    else if (node.left.type === VariableDeclaration) {
+    else if (node.left.type === AST_NODE_TYPES.VariableDeclaration) {
         if (node.left.declarations.length !== 1) {
             throw new WorkflowSyntaxError('Only one variable can be declared here', node.left.loc);
         }
@@ -420,7 +397,9 @@ function forOfStatementToForStep(node, ctx) {
         if (declaration.init !== null) {
             throw new WorkflowSyntaxError('Initial value not allowed', declaration.init.loc);
         }
-        assertType(declaration.id, Identifier);
+        if (declaration.id.type !== AST_NODE_TYPES.Identifier) {
+            throw new WorkflowSyntaxError(`Expected identifier, got ${declaration.id.type}`, declaration.id.loc);
+        }
         loopVariableName = declaration.id.name;
     }
     else {
@@ -439,15 +418,14 @@ function forOfStatementToForStep(node, ctx) {
     return new ForStepAST(steps, loopVariableName, listExpression);
 }
 function whileStatementSteps(node, ctx) {
-    assertType(node, WhileStatement);
     const startOfLoop = new JumpTargetAST();
     const endOfLoop = new JumpTargetAST();
     const ctx2 = Object.assign({}, ctx, {
         continueTarget: startOfLoop.label,
         breakTarget: endOfLoop.label,
     });
-    const steps = parseBlockStatement(node.body, ctx2);
-    steps.push(new NextStepAST(startOfLoop.label));
+    const postSteps = [new NextStepAST(startOfLoop.label)];
+    const steps = parseStatement(node.body, ctx2, postSteps);
     return [
         startOfLoop,
         new SwitchStepAST([
@@ -460,7 +438,6 @@ function whileStatementSteps(node, ctx) {
     ];
 }
 function doWhileStatementSteps(node, ctx) {
-    assertType(node, DoWhileStatement);
     const startOfLoop = new JumpTargetAST();
     const endOfLoop = new JumpTargetAST();
     const ctx2 = Object.assign({}, ctx, {
@@ -468,7 +445,7 @@ function doWhileStatementSteps(node, ctx) {
         breakTarget: endOfLoop.label,
     });
     const steps = [startOfLoop];
-    steps.push(...parseBlockStatement(node.body, ctx2));
+    steps.push(...parseStatement(node.body, ctx2));
     steps.push(new SwitchStepAST([
         {
             condition: convertExpression(node.test),
@@ -480,10 +457,8 @@ function doWhileStatementSteps(node, ctx) {
     return steps;
 }
 function breakStatementToNextStep(node, ctx) {
-    assertType(node, BreakStatement);
     let target;
     if (node.label) {
-        assertType(node.label, Identifier);
         target = node.label.name;
     }
     else if (ctx.breakTarget) {
@@ -495,10 +470,8 @@ function breakStatementToNextStep(node, ctx) {
     return new NextStepAST(target);
 }
 function continueStatementToNextStep(node, ctx) {
-    assertType(node, ContinueStatement);
     let target;
     if (node.label) {
-        assertType(node.label, Identifier);
         target = node.label.name;
     }
     else if (ctx.continueTarget) {
@@ -510,14 +483,18 @@ function continueStatementToNextStep(node, ctx) {
     return new NextStepAST(target);
 }
 function tryStatementToTryStep(node, ctx) {
-    assertType(node, TryStatement);
-    const steps = parseBlockStatement(node.block, ctx);
-    const exceptSteps = parseBlockStatement(node.handler.body, ctx);
+    const steps = parseStatement(node.block, ctx);
+    let exceptSteps = [];
     let errorVariable = undefined;
-    const handlerParam = node.handler.param;
-    if (handlerParam) {
-        assertType(handlerParam, Identifier);
-        errorVariable = handlerParam.name;
+    if (node.handler) {
+        exceptSteps = parseStatement(node.handler.body, ctx);
+        const handlerParam = node.handler.param;
+        if (handlerParam) {
+            if (handlerParam.type !== AST_NODE_TYPES.Identifier) {
+                throw new WorkflowSyntaxError('The error variable must be an identifier', handlerParam.loc);
+            }
+            errorVariable = handlerParam.name;
+        }
     }
     if (node.finalizer !== null) {
         // TODO
@@ -526,11 +503,9 @@ function tryStatementToTryStep(node, ctx) {
     return new TryStepAST(steps, exceptSteps, undefined, errorVariable);
 }
 function labeledStep(node, ctx) {
-    assertType(node, LabeledStatement);
-    const steps = parseStep(node.body, ctx);
-    if (steps.length > 0) {
-        steps[0] = stepWithLabel(steps[0], node.label.name);
-        return steps;
+    const steps = parseStatement(node.body, ctx);
+    if (steps.length > 0 && steps[0].tag !== 'jumptarget') {
+        steps[0] = steps[0].withLabel(node.label.name);
     }
     return steps;
 }

package/dist/transpiler/transformations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformations.d.ts","sourceRoot":"","sources":["../../src/transpiler/transformations.ts"],"names":[],"mappings":"AAAA,OAAO,EAUL,eAAe,EAChB,MAAM,iBAAiB,CAAA;AAuBxB;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAUxE;AA0JD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,eAAe,EAAE,GACvB,eAAe,EAAE,CAoBnB"}
+{"version":3,"file":"transformations.d.ts","sourceRoot":"","sources":["../../src/transpiler/transformations.ts"],"names":[],"mappings":"AAAA,OAAO,EAUL,eAAe,EAChB,MAAM,iBAAiB,CAAA;AAuBxB;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAUxE;AA4JD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,eAAe,EAAE,GACvB,eAAe,EAAE,CAqBnB"}

package/dist/transpiler/transformations.js

@@ -23,8 +23,9 @@ function mergeAssignSteps(steps) {
         const prev = acc.length > 0 ? acc[acc.length - 1] : null;
         if (current.tag === 'assign' &&
             prev?.tag === 'assign' &&
-            prev.assignments.length < 50) {
-            const merged = new AssignStepAST(prev.assignments.concat(current.assignments));
+            prev.assignments.length < 50 &&
+            !prev.next) {
+            const merged = new AssignStepAST(prev.assignments.concat(current.assignments), current.next);
             acc.pop();
             acc.push(merged);
         }
@@ -142,26 +143,29 @@ function parseRetryPolicyNumber(record, keyName) {
  *     next: target1
  */
 export function flattenPlainNextConditions(steps) {
-    /*
-    const res = steps.reduce((acc: WorkflowStepAST[], step: WorkflowStepAST) => {
-      if (acc.length > 0) {
-        if (step.tag === 'next') {
-          const prev = acc[-1]
-  
-          if (prev.tag === 'assign') {
-            
-          }
-  
+    return steps.reduce((acc, step) => {
+        if (acc.length > 0 && step.tag === 'next') {
+            // Merge a "next" to the previous "assign" step
+            const prev = acc[acc.length - 1];
+            if (prev.tag === 'assign' && !prev.next) {
+                acc.pop();
+                acc.push(prev.withNext(step.target));
+            }
+            else {
+                acc.push(step);
+            }
+        }
+        else if (step.tag === 'switch') {
+            // If the condition steps consists of a single "next", merge it with the condition
+            acc.push(flattenNextToCondition(step));
         }
-      }
-  
-      return acc
-    }, [])
-  
-    */
-    return steps.map((step) => (step.tag === 'switch' ? flattenNext(step) : step));
+        else {
+            acc.push(step);
+        }
+        return acc;
+    }, []);
 }
-function flattenNext(step) {
+function flattenNextToCondition(step) {
     const transformedBranches = step.branches.map((cond) => {
         if (!cond.next && cond.steps.length === 1 && cond.steps[0].tag === 'next') {
             const nextStep = cond.steps[0];
@@ -287,7 +291,7 @@ function transformExpressionsAssign(step, transform) {
             newSteps.push(...steps2);
             return [name, ex2];
         });
-        newSteps.push(new AssignStepAST(newAssignments, step.label));
+        newSteps.push(new AssignStepAST(newAssignments, step.next, step.label));
         return newSteps;
     }
     else {