ts2workflows 0.10.0 → 0.12.0

package/dist/ast/steps.js

@@ -1,538 +1,48 @@
 import * as R from 'ramda';
-import { isRecord } from '../utils.js';
-import { expressionToLiteralValueOrLiteralExpression, } from './expressions.js';
+import { InternalTranspilingError } from '../errors.js';
+import { binaryEx, expressionToLiteralValueOrLiteralExpression, expressionToString, nullEx, stringEx, variableReferenceEx, } from './expressions.js';
 import { Subworkflow } from './workflows.js';
-export class SubworkflowAST {
-    name;
-    steps;
-    params;
-    constructor(name, steps, params) {
-        this.name = name;
-        this.steps = steps;
-        this.params = params;
-    }
-    withStepNames(generate) {
-        const steps = this.steps.map((step) => namedSteps(step, generate));
-        return new Subworkflow(this.name, steps, this.params);
-    }
-}
-// https://cloud.google.com/workflows/docs/reference/syntax/variables#assign-step
-export class AssignStepAST {
-    tag = 'assign';
-    assignments;
-    label;
-    next;
-    constructor(assignments, next, label) {
-        this.assignments = assignments;
-        this.next = next;
-        this.label = label;
-    }
-    withNext(newNext) {
-        if (newNext === this.next) {
-            return this;
-        }
-        else {
-            return new AssignStepAST(this.assignments, newNext, this.label);
-        }
-    }
-    withLabel(newLabel) {
-        return new AssignStepAST(this.assignments, this.next, newLabel);
-    }
-    applyNestedSteps() {
-        return this;
-    }
-}
-// https://cloud.google.com/workflows/docs/reference/syntax/calls
-export class CallStepAST {
-    tag = 'call';
-    call;
-    args;
-    result;
-    label;
-    constructor(call, args, result, label) {
-        this.call = call;
-        this.args = args;
-        this.result = result;
-        this.label = label;
-    }
-    labelPrefix() {
-        return 'call_' + this.call.replaceAll(/[^a-zA-Z0-9]/g, '_') + '_';
-    }
-    withLabel(newLabel) {
-        return new CallStepAST(this.call, this.args, this.result, newLabel);
-    }
-    applyNestedSteps() {
-        return this;
-    }
-}
-// https://cloud.google.com/workflows/docs/reference/syntax/iteration
-export class ForStepAST {
-    tag = 'for';
-    steps;
-    loopVariableName;
-    indexVariableName;
-    listExpression;
-    label;
-    constructor(steps, loopVariableName, listExpression, indexVariable, label) {
-        this.steps = steps;
-        this.loopVariableName = loopVariableName;
-        this.listExpression = listExpression;
-        this.indexVariableName = indexVariable;
-        this.label = label;
-    }
-    withLabel(newLabel) {
-        return new ForStepAST(this.steps, this.loopVariableName, this.listExpression, this.indexVariableName, newLabel);
-    }
-    applyNestedSteps(fn) {
-        return new ForStepAST(fn(this.steps), this.loopVariableName, this.listExpression, this.indexVariableName, this.label);
-    }
-}
-export class ForRangeStepAST {
-    tag = 'forrange';
-    steps;
-    loopVariableName;
-    rangeStart;
-    rangeEnd;
-    label;
-    constructor(steps, loopVariableName, rangeStart, rangeEnd, label) {
-        this.steps = steps;
-        this.loopVariableName = loopVariableName;
-        this.rangeStart = rangeStart;
-        this.rangeEnd = rangeEnd;
-        this.label = label;
-    }
-    withLabel(newLabel) {
-        return new ForRangeStepAST(this.steps, this.loopVariableName, this.rangeStart, this.rangeEnd, newLabel);
-    }
-    applyNestedSteps(fn) {
-        return new ForRangeStepAST(fn(this.steps), this.loopVariableName, this.rangeStart, this.rangeEnd, this.label);
-    }
-}
-export class ForStepASTNamed {
-    tag = 'for';
-    steps;
-    loopVariableName;
-    indexVariableName;
-    listExpression;
-    rangeStart;
-    rangeEnd;
-    constructor(steps, loopVariableName, listExpression, indexVariable, rangeStart, rangeEnd) {
-        this.steps = steps;
-        this.loopVariableName = loopVariableName;
-        this.listExpression = listExpression;
-        this.indexVariableName = indexVariable;
-        this.rangeStart = rangeStart;
-        this.rangeEnd = rangeEnd;
-    }
-}
-export class NextStepAST {
-    tag = 'next';
-    target;
-    label;
-    constructor(target, label) {
-        this.target = target;
-        this.label = label;
-    }
-    withLabel(newLabel) {
-        return new NextStepAST(this.target, newLabel);
-    }
-    applyNestedSteps() {
-        return this;
-    }
-}
-// https://cloud.google.com/workflows/docs/reference/syntax/parallel-steps
-export class ParallelStepAST {
-    tag = 'parallel';
-    steps;
-    shared;
-    concurrencyLimit;
-    exceptionPolicy;
-    label;
-    constructor(steps, shared, concurrencyLimit, exceptionPolicy, label) {
-        this.steps = steps;
-        this.shared = shared;
-        this.concurrencyLimit = concurrencyLimit;
-        this.exceptionPolicy = exceptionPolicy;
-        this.label = label;
-    }
-    withLabel(newLabel) {
-        return new ParallelStepAST(this.steps, this.shared, this.concurrencyLimit, this.exceptionPolicy, newLabel);
-    }
-    applyNestedSteps(fn) {
-        let transformedSteps;
-        if (this.steps instanceof ForStepAST) {
-            transformedSteps = this.steps.applyNestedSteps(fn);
-        }
-        else {
-            transformedSteps = R.map((s) => new StepsStepAST(fn(s.steps), s.label), this.steps);
-        }
-        return new ParallelStepAST(transformedSteps, this.shared, this.concurrencyLimit, this.exceptionPolicy, this.label);
-    }
-}
-export class ParallelStepASTNamed {
-    tag = 'parallel';
-    branches; // Either steps for each branch
-    forStep; // ... or a parallel for
-    shared;
-    concurrenceLimit;
-    exceptionPolicy;
-    constructor(steps, shared, concurrencyLimit, exceptionPolicy) {
-        this.shared = shared;
-        this.concurrenceLimit = concurrencyLimit;
-        this.exceptionPolicy = exceptionPolicy;
-        if (!isRecord(steps)) {
-            this.forStep = steps;
-        }
-        else {
-            this.branches = Object.entries(steps).map((x) => {
-                return { name: x[0], step: x[1] };
-            });
-        }
-    }
-}
-// https://cloud.google.com/workflows/docs/reference/syntax/raising-errors
-export class RaiseStepAST {
-    tag = 'raise';
-    value;
-    label;
-    constructor(value, label) {
-        this.value = value;
-        this.label = label;
-    }
-    withLabel(newLabel) {
-        return new RaiseStepAST(this.value, newLabel);
-    }
-    applyNestedSteps() {
-        return this;
-    }
-}
-// https://cloud.google.com/workflows/docs/reference/syntax/completing
-export class ReturnStepAST {
-    tag = 'return';
-    value;
-    label;
-    constructor(value, label) {
-        this.value = value;
-        this.label = label;
-    }
-    withLabel(newLabel) {
-        return new ReturnStepAST(this.value, newLabel);
-    }
-    applyNestedSteps() {
-        return this;
-    }
-}
-// https://cloud.google.com/workflows/docs/reference/syntax/steps#embedded-steps
-export class StepsStepAST {
-    tag = 'steps';
-    steps;
-    label;
-    constructor(steps, label) {
-        this.steps = steps;
-        this.label = label;
-    }
-    withLabel(newLabel) {
-        return new StepsStepAST(this.steps, newLabel);
-    }
-    applyNestedSteps(fn) {
-        return new StepsStepAST(fn(this.steps), this.label);
-    }
-}
-export class StepsStepASTNamed {
-    tag = 'steps';
-    steps;
-    constructor(steps) {
-        this.steps = steps;
-    }
-}
-// https://cloud.google.com/workflows/docs/reference/syntax/conditions
-export class SwitchStepAST {
-    tag = 'switch';
-    branches;
-    label;
-    constructor(branches, label) {
-        this.branches = branches;
-        this.label = label;
-    }
-    withLabel(newLabel) {
-        return new SwitchStepAST(this.branches, newLabel);
-    }
-    applyNestedSteps(fn) {
-        return new SwitchStepAST(this.branches.map((branch) => ({
-            condition: branch.condition,
-            steps: fn(branch.steps),
-            next: branch.next,
-        })), this.label);
-    }
-}
-export class SwitchStepASTNamed {
-    tag = 'switch';
-    conditions;
-    next;
-    constructor(conditions, next) {
-        this.conditions = conditions;
-        this.next = next;
-    }
-}
-// https://cloud.google.com/workflows/docs/reference/syntax/catching-errors
-export class TryStepAST {
-    tag = 'try';
-    trySteps;
-    exceptSteps;
-    retryPolicy;
-    errorMap;
-    label;
-    constructor(trySteps, exceptSteps, retryPolicy, errorMap, label) {
-        this.trySteps = trySteps;
-        this.exceptSteps = exceptSteps;
-        this.retryPolicy = retryPolicy;
-        this.errorMap = errorMap;
-        this.label = label;
-    }
-    withLabel(newLabel) {
-        return new TryStepAST(this.trySteps, this.exceptSteps, this.retryPolicy, this.errorMap, newLabel);
-    }
-    applyNestedSteps(fn) {
-        return new TryStepAST(fn(this.trySteps), this.exceptSteps ? fn(this.exceptSteps) : undefined, this.retryPolicy, this.errorMap, this.label);
-    }
-}
-export class TryStepASTNamed {
-    tag = 'try';
-    retryPolicy;
-    errorMap;
-    // Steps in the try block
-    trySteps;
-    // Steps in the except block
-    exceptSteps;
-    constructor(steps, exceptSteps, retryPolicy, errorMap) {
-        this.trySteps = steps;
-        this.retryPolicy = retryPolicy;
-        this.errorMap = errorMap;
-        this.exceptSteps = exceptSteps;
-    }
-}
-// Internal step that represents a potential jump target.
-// This can be ued as a placeholder when the actual target step is not yet known.
-// JumpTargetAST is removed before transpiling to workflows YAML.
-export class JumpTargetAST {
-    tag = 'jumptarget';
-    label;
-    constructor() {
-        this.label = `jumptarget_${Math.floor(Math.random() * 2 ** 32).toString(16)}`;
-    }
-    applyNestedSteps() {
-        return this;
-    }
-}
-/**
- * Assign a name for this step and its child steps.
- *
- * The name is generated by calling generateName with a prefix identifying the step type.
- */
-export function namedSteps(step, generateName) {
-    switch (step.tag) {
-        case 'assign':
-        case 'next':
-        case 'raise':
-        case 'return':
-            return {
-                name: step.label ?? generateName(step.tag),
-                step,
-            };
-        case 'call':
-            return {
-                name: step.label ?? generateName(step.labelPrefix()),
-                step,
-            };
-        case 'for':
-            return namedStepsFor(step, generateName);
-        case 'forrange':
-            return namedStepsForRange(step, generateName);
-        case 'parallel':
-            return namedStepsParallel(step, generateName);
-        case 'steps':
-            return namedStepsSteps(step, generateName);
-        case 'switch':
-            return namedStepsSwitch(step, generateName);
-        case 'try':
-            return namedStepsTry(step, generateName);
-        case 'jumptarget':
-            return {
-                name: step.label,
-                step: step,
-            };
-    }
-}
-function namedStepsFor(step, generateName) {
-    return {
-        name: step.label ?? generateName('for'),
-        step: new ForStepASTNamed(step.steps.map((nestedStep) => namedSteps(nestedStep, generateName)), step.loopVariableName, step.listExpression, step.indexVariableName),
-    };
-}
-function namedStepsForRange(step, generateName) {
-    return {
-        name: step.label ?? generateName('for'),
-        step: new ForStepASTNamed(step.steps.map((nestedStep) => namedSteps(nestedStep, generateName)), step.loopVariableName, undefined, undefined, step.rangeStart, step.rangeEnd),
-    };
-}
-function namedStepsParallel(step, generateName) {
-    let steps;
-    const mainLabel = step.label ?? generateName('parallel');
-    if (!isRecord(step.steps)) {
-        const forStep = namedSteps(step.steps, generateName).step;
-        if (forStep.tag !== 'for') {
-            throw new Error(`Encountered a step of type ${forStep.tag} when a for step was expected`);
-        }
-        steps = forStep;
-    }
-    else {
-        steps = R.map((step) => {
-            const named = step.steps.map((x) => namedSteps(x, generateName));
-            return new StepsStepASTNamed(named);
-        }, step.steps);
-    }
-    return {
-        name: mainLabel,
-        step: new ParallelStepASTNamed(steps, step.shared, step.concurrencyLimit, step.exceptionPolicy),
-    };
-}
-function namedStepsSteps(step, generateName) {
-    return {
-        name: step.label ?? generateName('steps'),
-        step: new StepsStepASTNamed(step.steps.map((nested) => namedSteps(nested, generateName))),
-    };
-}
-function namedStepsSwitch(step, generateName) {
-    const mainLabel = step.label ?? generateName('switch');
-    const namedBranches = step.branches.map((branch) => ({
-        condition: branch.condition,
-        steps: branch.steps.map((nested) => namedSteps(nested, generateName)),
-        next: branch.next,
-    }));
-    return {
-        name: mainLabel,
-        step: new SwitchStepASTNamed(namedBranches),
-    };
-}
-function namedStepsTry(step, generateName) {
-    const mainLabel = step.label ?? generateName('try');
-    const namedTrySteps = step.trySteps.map((nested) => namedSteps(nested, generateName));
-    const namedExceptSteps = step.exceptSteps?.map((nested) => namedSteps(nested, generateName));
-    return {
-        name: mainLabel,
-        step: new TryStepASTNamed(namedTrySteps, namedExceptSteps, step.retryPolicy, step.errorMap),
-    };
-}
-/**
- * Returns the nested steps in contained in this step.
- *
- * Used in iterating the AST tree.
- */
-export function nestedSteps(step) {
-    switch (step.tag) {
-        case 'assign':
-        case 'call':
-        case 'next':
-        case 'raise':
-        case 'return':
-        case 'jumptarget':
-            return [];
-        case 'for':
-        case 'steps':
-            return [step.steps];
-        case 'parallel':
-            return nestedStepsParallel(step);
-        case 'switch':
-            return step.conditions.map((x) => x.steps);
-        case 'try':
-            return nestedStepsTry(step);
-    }
-}
-function nestedStepsParallel(step) {
-    const nested = [];
-    if (step.branches && step.branches.length > 0) {
-        // return each branch as a separate child
-        nested.push(...step.branches.map((x) => [x]));
-    }
-    if (step.forStep?.steps && step.forStep.steps.length > 0) {
-        nested.push(step.forStep.steps);
-    }
-    return nested;
-}
-function nestedStepsTry(step) {
-    const nested = [];
-    if (step.trySteps.length > 0) {
-        nested.push(step.trySteps);
-    }
-    if (step.exceptSteps) {
-        nested.push(step.exceptSteps);
-    }
-    return nested;
-}
 /**
  * Returns an GCP Workflows object representation of a step.
  */
 export function renderStep(step) {
     switch (step.tag) {
         case 'assign':
-            return {
-                assign: step.assignments.map(({ name, value }) => {
-                    return {
-                        [name.toString()]: expressionToLiteralValueOrLiteralExpression(value),
-                    };
-                }),
-                ...(step.next && { next: step.next }),
-            };
+            return { [step.label]: renderAssignStep(step) };
         case 'call':
-            return renderCallStep(step);
+            return { [step.label]: renderCallStep(step) };
         case 'for':
-            return {
-                for: renderForBody(step),
-            };
-        case 'parallel':
-            return {
-                parallel: {
-                    ...(step.shared && { shared: step.shared }),
-                    ...(step.concurrenceLimit !== undefined && {
-                        concurrency_limit: step.concurrenceLimit,
-                    }),
-                    ...(step.exceptionPolicy !== undefined && {
-                        exception_policy: step.exceptionPolicy,
-                    }),
-                    ...(step.branches && { branches: renderSteps(step.branches) }),
-                    ...(step.forStep && { for: renderForBody(step.forStep) }),
-                },
-            };
+            return { [step.label]: renderForStep(step) };
         case 'next':
-            return {
-                next: step.target,
-            };
+            return { [step.label]: { next: step.next } };
+        case 'parallel':
+            return { [step.label]: renderParallelStep(step) };
+        case 'parallel-for':
+            return { [step.label]: renderParallelIterationStep(step) };
         case 'raise':
-            return {
-                raise: expressionToLiteralValueOrLiteralExpression(step.value),
-            };
+            return { [step.label]: renderRaiseStep(step) };
         case 'return':
-            return renderReturnStep(step);
-        case 'steps':
-            return {
-                steps: renderSteps(step.steps),
-            };
+            return { [step.label]: renderReturnStep(step) };
         case 'switch':
-            return {
-                switch: step.conditions.map(renderSwitchCondition),
-                ...(step.next && { next: step.next }),
-            };
+            return { [step.label]: renderSwitchStep(step) };
         case 'try':
-            return renderTryStep(step);
-        case 'jumptarget':
+            return { [step.label]: renderTryStep(step) };
+        case 'jump-target':
+            // Should not be reached
             return {};
     }
 }
-function renderSwitchCondition(cond) {
+function renderSteps(steps) {
+    return steps.map(renderStep);
+}
+function renderAssignStep(step) {
     return {
-        condition: expressionToLiteralValueOrLiteralExpression(cond.condition),
-        ...(cond.steps.length > 0 && { steps: renderSteps(cond.steps) }),
-        ...(cond.next && { next: cond.next }),
+        assign: step.assignments.map(({ name, value }) => {
+            return {
+                [expressionToString(name)]: expressionToLiteralValueOrLiteralExpression(value),
+            };
+        }),
+        ...(step.next !== undefined && { next: step.next }),
     };
 }
 function renderCallStep(step) {
@@ -546,6 +56,11 @@ function renderCallStep(step) {
         ...(step.result !== undefined && { result: step.result }),
     };
 }
+function renderForStep(step) {
+    return {
+        for: renderForBody(step),
+    };
+}
 function renderForBody(step) {
     let range;
     let inValue;
@@ -571,13 +86,56 @@ function renderForBody(step) {
     };
 }
 function renderForRangeLimit(value) {
-    if (value === undefined || typeof value === 'number') {
-        return value ?? null;
+    if (value === undefined) {
+        return null;
+    }
+    else if (typeof value === 'number') {
+        return value;
     }
     else {
         return expressionToLiteralValueOrLiteralExpression(value);
     }
 }
+function renderParallelStep(step) {
+    const renderedBranches = {
+        branches: step.branches.map(({ name, steps }) => ({
+            [name]: {
+                steps: renderSteps(steps),
+            },
+        })),
+    };
+    return {
+        parallel: {
+            ...renderedBranches,
+            ...(step.shared && { shared: step.shared }),
+            ...(step.concurrencyLimit !== undefined && {
+                concurrency_limit: step.concurrencyLimit,
+            }),
+            ...(step.exceptionPolicy !== undefined && {
+                exception_policy: step.exceptionPolicy,
+            }),
+        },
+    };
+}
+function renderParallelIterationStep(step) {
+    return {
+        parallel: {
+            for: renderForBody(step.forStep),
+            ...(step.shared && { shared: step.shared }),
+            ...(step.concurrencyLimit !== undefined && {
+                concurrency_limit: step.concurrencyLimit,
+            }),
+            ...(step.exceptionPolicy !== undefined && {
+                exception_policy: step.exceptionPolicy,
+            }),
+        },
+    };
+}
+function renderRaiseStep(step) {
+    return {
+        raise: expressionToLiteralValueOrLiteralExpression(step.value),
+    };
+}
 function renderReturnStep(step) {
     if (step.value) {
         return {
@@ -590,6 +148,20 @@ function renderReturnStep(step) {
         };
     }
 }
+function renderSwitchStep(step) {
+    return {
+        switch: step.branches.map(renderSwitchBranch),
+        ...(step.next !== undefined && { next: step.next }),
+    };
+}
+function renderSwitchBranch(branch) {
+    const includeSteps = (branch.steps ?? []).length > 0 || branch.next === undefined;
+    return {
+        condition: expressionToLiteralValueOrLiteralExpression(branch.condition),
+        ...(includeSteps && { steps: renderSteps(branch.steps ?? []) }),
+        ...(branch.next !== undefined && { next: branch.next }),
+    };
+}
 function renderTryStep(step) {
     let retry;
     if (typeof step.retryPolicy === 'undefined') {
@@ -640,8 +212,777 @@ function renderTryStep(step) {
         ...(except && { except }),
     };
 }
-function renderSteps(steps) {
-    return steps.map((x) => {
-        return { [x.name]: renderStep(x.step) };
+/**
+ * Convert a IR subworkflow to WorkflowSteps.
+ *
+ * This function also assigns step labels.
+ */
+export function toStepSubworkflow(ast, generateLabel) {
+    const steps = fixJumpLabels(statementListToSteps(generateLabel, {}, ast.statements));
+    return new Subworkflow(ast.name, steps, ast.params);
+}
+const statementListToSteps = R.curry(function (generateLabel, ctx, statements) {
+    return mergeNextStep(statements.flatMap((s) => statementToSteps(generateLabel, ctx, s)));
+});
+function statementToSteps(generateLabel, ctx, statement) {
+    switch (statement.tag) {
+        case 'assign':
+            return [
+                {
+                    tag: statement.tag,
+                    label: generateLabel(statement.tag),
+                    assignments: statement.assignments,
+                },
+            ];
+        case 'break':
+            return [breakStep(generateLabel, ctx, statement)];
+        case 'continue':
+            return [continueStep(generateLabel, ctx, statement)];
+        case 'do-while':
+            return doWhileSteps(generateLabel, ctx, statement);
+        case 'for':
+            return [forStep(generateLabel, ctx, statement)];
+        case 'for-range':
+            return [forRangeStep(generateLabel, ctx, statement)];
+        case 'function-invocation':
+            return [callStep(generateLabel, statement)];
+        case 'if':
+            return [ifStep(generateLabel, ctx, statement)];
+        case 'label':
+            return labelledSteps(generateLabel, ctx, statement);
+        case 'parallel-for':
+            return [parallelIterationStep(generateLabel, ctx, statement)];
+        case 'parallel':
+            return [parallelStep(generateLabel, ctx, statement)];
+        case 'raise':
+            return [
+                {
+                    tag: statement.tag,
+                    label: generateLabel(statement.tag),
+                    value: statement.value,
+                },
+            ];
+        case 'return':
+            return [returnStep(generateLabel, ctx, statement)];
+        case 'switch':
+            return switchSteps(generateLabel, ctx, statement);
+        case 'try':
+            return trySteps(generateLabel, ctx, statement);
+        case 'while':
+            return whileSteps(generateLabel, ctx, statement);
+    }
+}
+function callStep(generateLabel, statement) {
+    const labelPrefix = 'call_' + statement.callee.replaceAll(/[^a-zA-Z0-9]/g, '_') + '_';
+    return {
+        tag: 'call',
+        label: generateLabel(labelPrefix),
+        call: statement.callee,
+        args: statement.args,
+        result: statement.result,
+    };
+}
+function breakStep(generateLabel, ctx, statement) {
+    if (ctx.finalizerTargets) {
+        // TODO: would need to detect if this breaks out of the try or catch block,
+        // execute the finally block first and then do the break.
+        throw new InternalTranspilingError('break is not supported inside a try-finally block');
+    }
+    return {
+        tag: 'next',
+        label: generateLabel('next'),
+        next: statement.label ?? ctx.breakTarget ?? 'break',
+    };
+}
+function continueStep(generateLabel, ctx, statement) {
+    if (ctx.finalizerTargets) {
+        // TODO: would need to detect if continue breaks out of the try or catch block,
+        // execute the finally block first and then do the continue.
+        throw new InternalTranspilingError('continue is not supported inside a try-finally block');
+    }
+    return {
+        tag: 'next',
+        label: generateLabel('next'),
+        next: statement.label ?? ctx.continueTarget ?? 'continue',
+    };
+}
+function doWhileSteps(generateLabel, ctx, statement) {
+    const startOfLoopLabel = generatePlaceholderLabel();
+    const endOfLoopLabel = generatePlaceholderLabel();
+    const ctx2 = Object.assign({}, ctx, {
+        continueTarget: startOfLoopLabel,
+        breakTarget: endOfLoopLabel,
+    });
+    const toSteps = statementListToSteps(generateLabel, ctx2);
+    return [
+        {
+            tag: 'jump-target',
+            label: startOfLoopLabel,
+        },
+        ...toSteps(statement.body),
+        {
+            tag: 'switch',
+            label: generateLabel('switch'),
+            branches: [
+                {
+                    condition: statement.condition,
+                    steps: [],
+                    next: startOfLoopLabel,
+                },
+            ],
+        },
+        {
+            tag: 'jump-target',
+            label: endOfLoopLabel,
+        },
+    ];
+}
+function whileSteps(generateLabel, ctx, statement) {
+    const startOfLoopLabel = generateLabel('switch');
+    const endOfLoopLabel = generatePlaceholderLabel();
+    const ctx2 = Object.assign({}, ctx, {
+        continueTarget: startOfLoopLabel,
+        breakTarget: endOfLoopLabel,
+    });
+    const toSteps = statementListToSteps(generateLabel, ctx2);
+    const steps = appendNextStep(generateLabel, toSteps(statement.body), startOfLoopLabel);
+    const body = {
+        condition: statement.condition,
+        steps,
+    };
+    return [
+        {
+            tag: 'switch',
+            label: startOfLoopLabel,
+            branches: [body],
+        },
+        {
+            tag: 'jump-target',
+            label: endOfLoopLabel,
+        },
+    ];
+}
+function forStep(generateLabel, ctx, statement) {
+    const label = generateLabel('for');
+    const bodyCtx = Object.assign({}, ctx, {
+        continueTarget: undefined,
+        breakTarget: undefined,
+    });
+    const toSteps = statementListToSteps(generateLabel, bodyCtx);
+    return {
+        tag: 'for',
+        label,
+        steps: toSteps(statement.body),
+        loopVariableName: statement.loopVariableName,
+        listExpression: statement.listExpression,
+    };
+}
+function forRangeStep(generateLabel, ctx, statement) {
+    const label = generateLabel('for');
+    const bodyCtx = Object.assign({}, ctx, {
+        continueTarget: undefined,
+        breakTarget: undefined,
+    });
+    const toSteps = statementListToSteps(generateLabel, bodyCtx);
+    return {
+        tag: 'for',
+        label,
+        steps: toSteps(statement.body),
+        loopVariableName: statement.loopVariableName,
+        rangeStart: statement.rangeStart,
+        rangeEnd: statement.rangeEnd,
+    };
+}
+function ifStep(generateLabel, ctx, statement) {
+    const label = generateLabel('switch');
+    const toSteps = statementListToSteps(generateLabel, ctx);
+    const branches = statement.branches.map((branch) => {
+        if ('body' in branch) {
+            // Use the shorter "next" form on break and continue statements
+            if (branch.body.length === 1 && branch.body[0].tag === 'break') {
+                return {
+                    condition: branch.condition,
+                    next: breakStep(generateLabel, ctx, branch.body[0]).next,
+                };
+            }
+            else if (branch.body.length === 1 &&
+                branch.body[0].tag === 'continue') {
+                return {
+                    condition: branch.condition,
+                    next: continueStep(generateLabel, ctx, branch.body[0]).next,
+                };
+            }
+            else {
+                return {
+                    condition: branch.condition,
+                    steps: toSteps(branch.body),
+                };
+            }
+        }
+        else {
+            return {
+                condition: branch.condition,
+                next: branch.next,
+            };
+        }
     });
+    return {
+        tag: 'switch',
+        label,
+        branches,
+    };
+}
+function labelledSteps(generateLabel, ctx, statement) {
+    const toSteps = statementListToSteps(generateLabel, ctx);
+    const steps = toSteps(statement.statements);
+    if (steps.length >= 1) {
+        // FIXME: do not first generate a label and then immediately overwrite it here
+        steps[0].label = statement.label;
+    }
+    return steps;
+}
+function parallelStep(generateLabel, ctx, statement) {
+    const label = generateLabel('parallel');
+    const toSteps = statementListToSteps(generateLabel, ctx);
+    const branches = statement.branches.map((branch) => ({
+        name: branch.name,
+        steps: toSteps(branch.body),
+    }));
+    return {
+        tag: 'parallel',
+        label,
+        branches,
+        shared: statement.shared,
+        concurrencyLimit: statement.concurrencyLimit,
+        exceptionPolicy: statement.exceptionPolicy,
+    };
+}
+function parallelIterationStep(generateLabel, ctx, statement) {
+    const label = generateLabel('parallel');
+    const innerStep = statement.forStep.tag === 'for'
+        ? forStep(generateLabel, ctx, statement.forStep)
+        : forRangeStep(generateLabel, ctx, statement.forStep);
+    return {
+        tag: 'parallel-for',
+        label,
+        forStep: innerStep,
+        shared: statement.shared,
+        concurrencyLimit: statement.concurrencyLimit,
+        exceptionPolicy: statement.exceptionPolicy,
+    };
+}
+function returnStep(generateLabel, ctx, statement) {
+    if (ctx.finalizerTargets && ctx.finalizerTargets.length > 0) {
+        // If we are in try statement with a finally block, return statements are
+        // replaced by a jump to finally back with a captured return value.
+        return delayedReturnAndJumpToFinalizer(generateLabel, ctx, statement.value);
+    }
+    else {
+        return {
+            tag: 'return',
+            label: generateLabel('return'),
+            value: statement.value,
+        };
+    }
+}
+function delayedReturnAndJumpToFinalizer(generateLabel, ctx, value) {
+    const finalizerTarget = ctx.finalizerTargets && ctx.finalizerTargets.length > 0
+        ? ctx.finalizerTargets[ctx.finalizerTargets.length - 1]
+        : undefined;
+    const [conditionVariable, valueVariable] = finalizerVariables(ctx);
+    return {
+        tag: 'assign',
+        label: generateLabel('assign'),
+        assignments: [
+            {
+                name: variableReferenceEx(conditionVariable),
+                value: stringEx('return'),
+            },
+            {
+                name: variableReferenceEx(valueVariable),
+                value: value ?? nullEx,
+            },
+        ],
+        next: finalizerTarget,
+    };
+}
+function switchSteps(generateLabel, ctx, statement) {
+    const label = generateLabel('switch');
+    const endOfSwitchLabel = generatePlaceholderLabel();
+    const switchCtx = Object.assign({}, ctx, { breakTarget: endOfSwitchLabel });
+    const toSteps = statementListToSteps(generateLabel, switchCtx);
+    const steps = [];
+    const branches = [];
+    // prepare steps for each branch so that we will have jump targets ready even for
+    // fall-through branches that need to jump to the next branch
+    const branchSteps = statement.branches.map((branch) => toSteps(branch.body));
+    steps.push(...branchSteps.flat());
+    statement.branches.forEach((branch, i) => {
+        // search forward until the next non-fall-through branch (= a branch that has
+        // non-empty steps)
+        const jumpTarget = branchSteps.slice(i).find((s) => s.length > 0);
+        const next = jumpTarget?.[0]?.label ?? endOfSwitchLabel;
+        branches.push({
+            condition: branch.condition,
+            next,
+        });
+    });
+    steps.unshift({
+        tag: 'switch',
+        label,
+        branches,
+    });
+    steps.push({
+        tag: 'jump-target',
+        label: endOfSwitchLabel,
+    });
+    return steps;
+}
+function trySteps(generateLabel, ctx, statement) {
+    if (!statement.finalizerBody) {
+        // Basic try-catch without a finally block
+        return [tryCatchRetrySteps(generateLabel, ctx, statement)];
+    }
+    else {
+        // Try-finally is translated to two nested try blocks. The innermost try is
+        // the actual try body with control flow statements (return, in the future
+        // also break/continue) replaced by jumps to the finally block.
+        //
+        // The outer try's catch block saves the exception and continues to the
+        // finally block.
+        //
+        // The nested try blocks are followed by the finally block and a switch for
+        // checking if we need to perform a delayed return/raise.
+        const startOfFinalizer = {
+            tag: 'jump-target',
+            label: generatePlaceholderLabel(),
+        };
+        const targets = ctx.finalizerTargets ?? [];
+        targets.push(startOfFinalizer.label);
+        ctx = Object.assign({}, ctx, { finalizerTargets: targets });
+        const [conditionVariable, valueVariable] = finalizerVariables(ctx);
+        const initStatement = finalizerInitializer(generateLabel, conditionVariable, valueVariable);
+        const outerLabel = generateLabel('try');
+        const innerTry = tryCatchRetrySteps(generateLabel, ctx, statement);
+        const outerTry = {
+            tag: 'try',
+            label: outerLabel,
+            trySteps: [innerTry],
+            exceptSteps: finalizerDelayedException(generateLabel, '__fin_exc', conditionVariable, valueVariable),
+            errorMap: '__fin_exc',
+        };
+        // Reset ctx before parsing the finally block because we don't want to
+        // transform returns in finally block in to delayed returns
+        if (ctx.finalizerTargets && ctx.finalizerTargets.length <= 1) {
+            delete ctx.finalizerTargets;
+        }
+        else {
+            ctx.finalizerTargets?.pop();
+        }
+        const toSteps = statementListToSteps(generateLabel, ctx);
+        const finallyBlock = toSteps(statement.finalizerBody);
+        return [
+            initStatement,
+            outerTry,
+            startOfFinalizer,
+            ...finallyBlock,
+            finalizerFooter(generateLabel, conditionVariable, valueVariable),
+        ];
+    }
+}
+function tryCatchRetrySteps(generateLabel, ctx, statement) {
+    const toSteps = statementListToSteps(generateLabel, ctx);
+    return {
+        tag: 'try',
+        label: generateLabel('try'),
+        trySteps: toSteps(statement.tryBody),
+        exceptSteps: statement.exceptBody
+            ? toSteps(statement.exceptBody)
+            : undefined,
+        retryPolicy: statement.retryPolicy,
+        errorMap: statement.errorMap,
+    };
+}
+function finalizerVariables(ctx) {
+    const targets = ctx.finalizerTargets ?? [];
+    const nestingLevel = targets.length > 0 ? `${targets.length}` : '';
+    const conditionVariable = `__t2w_finally_condition${nestingLevel}`;
+    const valueVariable = `__t2w_finally_value${nestingLevel}`;
+    return [conditionVariable, valueVariable];
+}
+/**
+ * The shared header for try-finally for initializing the temp variables
+ */
+function finalizerInitializer(generateLabel, conditionVariable, valueVariable) {
+    return {
+        tag: 'assign',
+        label: generateLabel('assign'),
+        assignments: [
+            {
+                name: variableReferenceEx(conditionVariable),
+                value: nullEx,
+            },
+            {
+                name: variableReferenceEx(valueVariable),
+                value: nullEx,
+            },
+        ],
+    };
+}
+/**
+ * The shared footer of a finally block that re-throws the exception or
+ * returns the value returned by the try body.
+ *
+ * The footer code in TypeScript:
+ *
+ * if (__t2w_finally_condition == "return") {
+ *   return __t2w_finally_value
+ * } elseif (__t2w_finally_condition == "raise") {
+ *   throw __t2w_finally_value
+ * }
+ */
+function finalizerFooter(generateLabel, conditionVariable, valueVariable) {
+    const variable = variableReferenceEx(conditionVariable);
+    const val = variableReferenceEx(valueVariable);
+    const returnString = stringEx('return');
+    const raiseString = stringEx('raise');
+    return {
+        tag: 'switch',
+        label: generateLabel('switch'),
+        branches: [
+            {
+                condition: binaryEx(variable, '==', returnString),
+                steps: [{ tag: 'return', label: generateLabel('return'), value: val }],
+            },
+            {
+                condition: binaryEx(variable, '==', raiseString),
+                steps: [{ tag: 'raise', label: generateLabel('raise'), value: val }],
+            },
+        ],
+    };
+}
+function finalizerDelayedException(generateLabel, exceptionVariableName, conditionVariableName, valueVariableName) {
+    return [
+        {
+            tag: 'assign',
+            label: generateLabel('assign'),
+            assignments: [
+                {
+                    name: variableReferenceEx(conditionVariableName),
+                    value: stringEx('raise'),
+                },
+                {
+                    name: variableReferenceEx(valueVariableName),
+                    value: variableReferenceEx(exceptionVariableName),
+                },
+            ],
+        },
+    ];
+}
+function generatePlaceholderLabel() {
+    return `jumptarget_${Math.floor(Math.random() * 2 ** 32).toString(16)}`;
+}
+/**
+ * Merge a next step to the previous step.
+ *
+ * For example, transforms this:
+ *
+ * - assign1:
+ *     assign:
+ *       - a: 1
+ * - next1:
+ *     next: target1
+ *
+ * into this:
+ *
+ * - assign1:
+ *     assign:
+ *       - a: 1
+ *     next: target1
+ */
+function mergeNextStep(steps) {
+    return steps.reduce((acc, step) => {
+        const prev = acc.at(-1);
+        if (step.tag === 'next' && prev?.tag === 'assign') {
+            // TODO: This will delete the "next" step that already had a label. The
+            // output will have a hole in label number. How to avoid that?
+            acc.pop();
+            acc.push({ ...prev, next: step.next });
+        }
+        else {
+            acc.push(step);
+        }
+        return acc;
+    }, []);
+}
+function appendNextStep(generateLabel, steps, nextLabel) {
+    const last = steps.at(-1);
+    if (last?.tag === 'assign') {
+        steps.pop();
+        steps.push({ ...last, next: nextLabel });
+    }
+    else {
+        steps.push({
+            tag: 'next',
+            label: generateLabel('next'),
+            next: nextLabel,
+        });
+    }
+    return steps;
+}
+function fixJumpLabels(steps) {
+    const jumpTargetLabels = collectActualJumpTargets(steps);
+    const stepsWithoutJumpTargetNodes = removeJumpTargetSteps(steps);
+    const relabeledSteps = relabelNextLabels(stepsWithoutJumpTargetNodes, jumpTargetLabels);
+    return relabeledSteps;
+}
+/**
+ * Find a mapping from jump target labels to step names.
+ *
+ * Iterate over all steps in the workflow. For JumpTargetAST nodes, find the
+ * next node that is not a JumpTargetAST, save its name as the real jump taget
+ * name.
+ */
+function collectActualJumpTargets(steps) {
+    const replacements = new Map();
+    // The processing is done iteratively with an explicit stack because
+    // nextNonJumpTargetNode() needs the stack. Note the order of steps on the
+    // stack: the first step is the last element of the stack.
+    const stack = [];
+    stack.push(...stepsToJumpStackElements(steps, 0));
+    while (stack.length > 0) {
+        // Do not yet pop in case nextNonJumpTargetNode needs to search the stack
+        const { step, nestingLevel } = stack[stack.length - 1];
+        if (step.tag === 'jump-target') {
+            const currentLabel = step.label;
+            const target = nextNonJumpTargetNode(stack);
+            const targetName = target ? target.label : 'end';
+            replacements.set(currentLabel, targetName);
+        }
+        // Now nextNonJumpTargetNode has been executed and it's safe to pop the
+        // current element from the stack.
+        stack.pop();
+        const children = nestedSteps(step).map((x) => stepsToJumpStackElements(x, nestingLevel + 1));
+        children.reverse();
+        children.forEach((nestedChildren) => {
+            stack.push(...nestedChildren);
+        });
+    }
+    return replacements;
+}
+function stepsToJumpStackElements(steps, nestingLevel) {
+    const block = steps.map((step, i) => ({
+        step,
+        nestingLevel,
+        isLastInBlock: i === steps.length - 1,
+    }));
+    block.reverse();
+    return block;
+}
+function nextNonJumpTargetNode(stack) {
+    let nestingLevel = stack[stack.length - 1]?.nestingLevel ?? -1;
+    while (nestingLevel >= 0) {
+        // Consider only the steps in the current code block (= the same nesting
+        // level, taking steps until isLastInBlock)
+        const endOfBlockIndex = stack.findLastIndex((x) => x.nestingLevel === nestingLevel && x.isLastInBlock);
+        if (endOfBlockIndex < 0) {
+            // should not be reached
+            throw new InternalTranspilingError('Failed to find end of block in nextNonJumpTargetNode');
+        }
+        const firstNonJumpTarget = stack
+            .slice(endOfBlockIndex)
+            .findLast((x) => x.nestingLevel === nestingLevel && x.step.tag !== 'jump-target');
+        if (firstNonJumpTarget) {
+            return firstNonJumpTarget.step;
+        }
+        nestingLevel--;
+    }
+    return undefined;
+}
+function nestedSteps(step) {
+    switch (step.tag) {
+        case 'assign':
+        case 'call':
+        case 'next':
+        case 'raise':
+        case 'return':
+        case 'jump-target':
+            return [];
+        case 'for':
+            return [step.steps];
+        case 'parallel':
+            return step.branches.map((x) => x.steps);
+        case 'parallel-for':
+            return [step.forStep.steps];
+        case 'switch':
+            return step.branches.map((x) => x.steps ?? []);
+        case 'try':
+            return nestedStepsTry(step);
+    }
+}
+function nestedStepsTry(step) {
+    const nested = [];
+    if (step.trySteps.length > 0) {
+        nested.push(step.trySteps);
+    }
+    if (step.exceptSteps) {
+        nested.push(step.exceptSteps);
+    }
+    return nested;
+}
+function removeJumpTargetSteps(steps) {
+    return steps
+        .filter((x) => x.tag !== 'jump-target')
+        .map(removeJumpTargetRecurse);
+}
+function removeJumpTargetRecurse(step) {
+    switch (step.tag) {
+        case 'assign':
+        case 'call':
+        case 'next':
+        case 'raise':
+        case 'return':
+        case 'jump-target':
+            return step;
+        case 'for':
+            return removeJumpTargetsFor(step);
+        case 'parallel':
+            return removeJumpTargetsParallel(step);
+        case 'parallel-for':
+            return removeJumpTargetsParallelIteration(step);
+        case 'switch':
+            return removeJumpTargetsSwitch(step);
+        case 'try':
+            return removeJumpTargetTry(step);
+    }
+}
+function removeJumpTargetsFor(step) {
+    return {
+        ...step,
+        steps: removeJumpTargetSteps(step.steps),
+    };
+}
+function removeJumpTargetsParallel(step) {
+    const branches = step.branches.map(({ name, steps: nestedSteps }) => ({
+        name,
+        steps: removeJumpTargetSteps(nestedSteps),
+    }));
+    return {
+        ...step,
+        branches,
+    };
+}
+function removeJumpTargetsParallelIteration(step) {
+    return {
+        ...step,
+        forStep: removeJumpTargetsFor(step.forStep),
+    };
+}
+function removeJumpTargetsSwitch(step) {
+    const transformedBranches = step.branches.map((branch) => {
+        return {
+            condition: branch.condition,
+            steps: branch.steps !== undefined
+                ? removeJumpTargetSteps(branch.steps)
+                : undefined,
+            next: branch.next,
+        };
+    });
+    return {
+        ...step,
+        branches: transformedBranches,
+    };
+}
+function removeJumpTargetTry(step) {
+    return {
+        ...step,
+        trySteps: removeJumpTargetSteps(step.trySteps),
+        exceptSteps: step.exceptSteps !== undefined
+            ? removeJumpTargetSteps(step.exceptSteps)
+            : undefined,
+    };
+}
+function relabelNextLabels(steps, replacements) {
+    return steps.map((step) => renameJumpTargets(step, replacements));
+}
+function renameJumpTargets(step, replaceLabels) {
+    switch (step.tag) {
+        case 'call':
+        case 'raise':
+        case 'return':
+        case 'jump-target':
+            return step;
+        case 'assign':
+            return renameJumpTargetsAssign(step, replaceLabels);
+        case 'for':
+            return renameJumpTargetsFor(step, replaceLabels);
+        case 'next':
+            return renameJumpTargetsNext(step, replaceLabels);
+        case 'parallel':
+            return renameJumpTargetsParallel(step, replaceLabels);
+        case 'parallel-for':
+            return renameJumpTargetsParallelIteration(step, replaceLabels);
+        case 'switch':
+            return renameJumpTargetsSwitch(step, replaceLabels);
+        case 'try':
+            return renameJumpTargetsTry(step, replaceLabels);
+    }
+}
+function renameJumpTargetsAssign(step, replaceLabels) {
+    if (step.next) {
+        const newLabel = replaceLabels.get(step.next);
+        if (newLabel) {
+            return { ...step, next: newLabel };
+        }
+    }
+    return step;
+}
+function renameJumpTargetsFor(step, replaceLabels) {
+    const transformedSteps = step.steps.map((s) => renameJumpTargets(s, replaceLabels));
+    return { ...step, steps: transformedSteps };
+}
+function renameJumpTargetsNext(step, replaceLabels) {
+    const newLabel = replaceLabels.get(step.next) ?? step.next;
+    return { ...step, next: newLabel };
+}
+function renameJumpTargetsParallel(step, replaceLabels) {
+    const branches = step.branches.map(({ name, steps }) => ({
+        name,
+        steps: steps.map((s) => renameJumpTargets(s, replaceLabels)),
+    }));
+    return { ...step, branches };
+}
+function renameJumpTargetsParallelIteration(step, replaceLabels) {
+    return { ...step, forStep: renameJumpTargetsFor(step.forStep, replaceLabels) };
+}
+function renameJumpTargetsSwitch(step, replaceLabels) {
+    const updatedNext = step.next
+        ? (replaceLabels.get(step.next) ?? step.next)
+        : undefined;
+    const updatedBranches = step.branches.map((cond) => {
+        const updatedCondNext = cond.next
+            ? (replaceLabels.get(cond.next) ?? cond.next)
+            : undefined;
+        const updatedCondSteps = cond.steps?.map((nested) => renameJumpTargets(nested, replaceLabels));
+        return {
+            condition: cond.condition,
+            steps: updatedCondSteps,
+            next: updatedCondNext,
+        };
+    });
+    return {
+        tag: 'switch',
+        label: step.label,
+        branches: updatedBranches,
+        next: updatedNext,
+    };
+}
+function renameJumpTargetsTry(step, replaceLabels) {
+    const transformedTrySteps = step.trySteps.map((nested) => renameJumpTargets(nested, replaceLabels));
+    const transformedExceptSteps = step.exceptSteps?.map((nested) => renameJumpTargets(nested, replaceLabels));
+    return {
+        ...step,
+        trySteps: transformedTrySteps,
+        exceptSteps: transformedExceptSteps,
+    };
 }