ts2workflows 0.7.0 → 0.9.0

package/dist/transpiler/transformations.d.ts

@@ -1,10 +1,4 @@
 import { WorkflowStepAST } from '../ast/steps.js';
-/**
- * Performs various transformations on the AST.
- *
- * This flat list of steps and does not recurse into nested steps. This gets
- * called on each nesting level separately.
- */
 export declare function transformAST(steps: WorkflowStepAST[]): WorkflowStepAST[];
 /**
  * Merge a next step to the previous step.

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,EASL,eAAe,EAChB,MAAM,iBAAiB,CAAA;AAqBxB;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAQxE;AAiCD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,eAAe,EAAE,GACvB,eAAe,EAAE,CAqBnB"}
+{"version":3,"file":"transformations.d.ts","sourceRoot":"","sources":["../../src/transpiler/transformations.ts"],"names":[],"mappings":"AACA,OAAO,EAQL,eAAe,EAChB,MAAM,iBAAiB,CAAA;AA6BxB,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAExE;AAiCD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,eAAe,EAAE,GACvB,eAAe,EAAE,CAqBnB"}

package/dist/transpiler/transformations.js

@@ -1,17 +1,15 @@
+import * as R from 'ramda';
 import { AssignStepAST, CallStepAST, ForStepAST, RaiseStepAST, ReturnStepAST, SwitchStepAST, } from '../ast/steps.js';
 import { InternalTranspilingError } from '../errors.js';
-import { isRecord, mapRecordValues } from '../utils.js';
-import { BinaryExpression, FunctionInvocationExpression, MemberExpression, PrimitiveExpression, UnaryExpression, VariableReferenceExpression, isExpression, isLiteral, } from '../ast/expressions.js';
+import { isRecord } from '../utils.js';
+import { BinaryExpression, FunctionInvocationExpression, MemberExpression, PrimitiveExpression, UnaryExpression, VariableReferenceExpression, asExpression, isExpression, isLiteral, } from '../ast/expressions.js';
 import { blockingFunctions } from './generated/functionMetadata.js';
-const Unmodified = Symbol();
 /**
  * Performs various transformations on the AST.
- *
- * This flat list of steps and does not recurse into nested steps. This gets
- * called on each nesting level separately.
  */
+const transformPipe = R.pipe(mapLiteralsAsAssignSteps, mergeAssignSteps, flattenPlainNextConditions, intrinsicFunctionImplementation, blockingCallsAsCallSteps);
 export function transformAST(steps) {
-    return blockingCallsAsCallSteps(runtimeFunctionImplementation(flattenPlainNextConditions(mergeAssignSteps(mapLiteralsAsAssignSteps(steps)))));
+    return transformPipe(steps.map((x) => x.applyNestedSteps(transformAST)));
 }
 /**
  * Merge consecutive assign steps into one assign step
@@ -113,57 +111,40 @@ function flattenNextToCondition(step) {
  *     return: ${__temp0}
  */
 function blockingCallsAsCallSteps(steps) {
-    const transformer = (ex) => {
-        const generateTemporaryVariableName = createTempVariableGenerator();
-        const { transformedExpression, callSteps } = replaceBlockingCalls(ex, generateTemporaryVariableName);
-        return [callSteps, transformedExpression];
-    };
-    return steps.reduce((acc, current) => {
-        const transformedSteps = transformStepExpressions(current, transformer);
-        acc.push(...transformedSteps);
-        return acc;
-    }, []);
+    const transform = transformStepExpressions(replaceBlockingCalls);
+    return R.chain(transform, steps);
 }
 function createTempVariableGenerator() {
     let i = 0;
-    const generator = () => `__temp${i++}`;
-    return generator;
+    return () => `__temp${i++}`;
 }
-function replaceBlockingCalls(expression, generateName) {
+function replaceBlockingCalls(expression) {
     function replaceBlockingFunctionInvocations(ex) {
-        if (ex.expressionType === 'functionInvocation') {
-            const callStepsForArguments = [];
-            const replacedArguments = ex.arguments.map((ex) => {
-                const replaced = replaceBlockingCalls(ex, generateName);
-                callStepsForArguments.push(...replaced.callSteps);
-                return replaced.transformedExpression;
-            });
-            const blockingCallArgumentNames = blockingFunctions.get(ex.functionName);
-            if (blockingCallArgumentNames) {
-                if (replacedArguments.length > blockingCallArgumentNames.length) {
-                    throw new InternalTranspilingError('FunctionInvocationTerm has more arguments than metadata allows!');
-                }
-                const nameAndValue = replacedArguments.map((val, i) => [blockingCallArgumentNames[i], val]);
-                const args = Object.fromEntries(nameAndValue);
-                const tempCallResultVariable = generateName();
-                callSteps.push(...callStepsForArguments);
-                callSteps.push(new CallStepAST(ex.functionName, args, tempCallResultVariable));
-                // replace function invocation with a reference to the temporary variable
-                return new VariableReferenceExpression(tempCallResultVariable);
-            }
-            else {
-                return Unmodified;
+        if (ex.expressionType !== 'functionInvocation') {
+            return ex;
+        }
+        const blockingCallArgumentNames = blockingFunctions.get(ex.functionName);
+        if (blockingCallArgumentNames) {
+            if (ex.arguments.length > blockingCallArgumentNames.length) {
+                throw new InternalTranspilingError('FunctionInvocationTerm has more arguments than metadata allows!');
             }
+            const nameAndValue = R.zip(blockingCallArgumentNames, ex.arguments);
+            const callArgs = R.fromPairs(nameAndValue);
+            const tempCallResultVariable = generateName();
+            callSteps.push(new CallStepAST(ex.functionName, callArgs, tempCallResultVariable));
+            // replace function invocation with a reference to the temporary variable
+            return new VariableReferenceExpression(tempCallResultVariable);
         }
         else {
-            return Unmodified;
+            return ex;
         }
     }
+    const generateName = createTempVariableGenerator();
     const callSteps = [];
-    return {
-        transformedExpression: transformExpression(expression, replaceBlockingFunctionInvocations),
+    return [
         callSteps,
-    };
+        transformExpression(replaceBlockingFunctionInvocations, expression),
+    ];
 }
 /**
  * Transform expressions in a step by applying transform.
@@ -172,20 +153,21 @@ function replaceBlockingCalls(expression, generateName) {
  * additional steps constructed during the transformation. For example, a
  * transformation might extract blocking call expressions into call steps.
  */
-function transformStepExpressions(step, transform) {
+const transformStepExpressions = R.curry(function (transform, step) {
     switch (step.tag) {
         case 'assign':
-            return transformExpressionsAssign(step, transform);
+            return transformExpressionsAssign(transform, step);
         case 'call':
-            return transformExpressionsCall(step, transform);
+            return transformExpressionsCall(transform, step);
         case 'for':
-            return transformExpressionsFor(step, transform);
+            return transformExpressionsFor(transform, step);
         case 'raise':
-            return transformExpressionsRaise(step, transform);
+            return transformExpressionsRaise(transform, step);
         case 'return':
-            return transformExpressionsReturn(step, transform);
+            return transformExpressionsReturn(transform, step);
         case 'switch':
-            return transformExpressionsSwitch(step, transform);
+            return transformExpressionsSwitch(transform, step);
+        case 'forrange':
         case 'next':
         case 'parallel':
         case 'steps':
@@ -193,8 +175,8 @@ function transformStepExpressions(step, transform) {
         case 'jumptarget':
             return [step];
     }
-}
-function transformExpressionsAssign(step, transform) {
+});
+function transformExpressionsAssign(transform, step) {
     if (step.assignments) {
         const newSteps = [];
         const newAssignments = step.assignments.map(([name, ex]) => {
@@ -209,14 +191,14 @@ function transformExpressionsAssign(step, transform) {
         return [step];
     }
 }
-function transformExpressionsCall(step, transform) {
+function transformExpressionsCall(transform, step) {
     if (step.args) {
         const newSteps = [];
-        const newArgs = mapRecordValues(step.args, (ex) => {
+        const newArgs = R.map((ex) => {
             const [steps2, ex2] = transform(ex);
             newSteps.push(...steps2);
             return ex2;
-        });
+        }, step.args);
         newSteps.push(new CallStepAST(step.call, newArgs, step.result, step.label));
         return newSteps;
     }
@@ -224,17 +206,17 @@ function transformExpressionsCall(step, transform) {
         return [step];
     }
 }
-function transformExpressionsFor(step, transform) {
+function transformExpressionsFor(transform, step) {
     if (step.listExpression) {
         const [newSteps, newListExpression] = transform(step.listExpression);
-        newSteps.push(new ForStepAST(step.steps, step.loopVariableName, newListExpression, step.indexVariableName, step.rangeStart, step.rangeEnd, step.label));
+        newSteps.push(new ForStepAST(step.steps, step.loopVariableName, newListExpression, step.indexVariableName, step.label));
         return newSteps;
     }
     else {
         return [step];
     }
 }
-function transformExpressionsRaise(step, transform) {
+function transformExpressionsRaise(transform, step) {
     if (step.value) {
         const [newSteps, newEx] = transform(step.value);
         newSteps.push(new RaiseStepAST(newEx, step.label));
@@ -244,7 +226,7 @@ function transformExpressionsRaise(step, transform) {
         return [step];
     }
 }
-function transformExpressionsReturn(step, transform) {
+function transformExpressionsReturn(transform, step) {
     if (step.value) {
         const [newSteps, newEx] = transform(step.value);
         newSteps.push(new ReturnStepAST(newEx, step.label));
@@ -254,7 +236,7 @@ function transformExpressionsReturn(step, transform) {
         return [step];
     }
 }
-function transformExpressionsSwitch(step, transform) {
+function transformExpressionsSwitch(transform, step) {
     const newSteps = [];
     const newBranches = step.branches.map((cond) => {
         const [steps2, ex2] = transform(cond.condition);
@@ -268,87 +250,50 @@ function transformExpressionsSwitch(step, transform) {
     newSteps.push(new SwitchStepAST(newBranches, step.label));
     return newSteps;
 }
-function transformExpression(ex, transform) {
-    const transformed = transform(ex);
-    if (transformed !== Unmodified) {
-        // Use the transformed version of this term
-        return transformed;
-    }
-    else {
-        // Otherwise, recurse into the nested expression
-        switch (ex.expressionType) {
-            case 'primitive':
-                if (isLiteral(ex)) {
-                    return ex;
-                }
-                else {
-                    const newPrimitive = transformPrimitive(ex.value, transform);
-                    return newPrimitive === ex.value
-                        ? ex
-                        : new PrimitiveExpression(newPrimitive);
-                }
-            case 'binary':
-                return transformBinaryExpression(ex, transform);
-            case 'functionInvocation':
-                return transformFunctionInvocationExpression(ex, transform);
-            case 'member':
-                return transformMemberExpression(ex, transform);
-            case 'unary':
-                return transformUnaryExpression(ex, transform);
-            case 'variableReference':
+/**
+ * Apply transform to expressions recursively.
+ * Transform leaf expresionssins first.
+ */
+function transformExpression(transform, ex) {
+    return transform(transformNestedExpressions(transform, ex));
+}
+function transformNestedExpressions(transform, ex) {
+    const tr = (y) => transformExpression(transform, y);
+    switch (ex.expressionType) {
+        case 'primitive':
+            if (isLiteral(ex)) {
                 return ex;
-        }
+            }
+            else {
+                const newPrimitive = transformPrimitive(transform, ex.value);
+                return newPrimitive === ex.value
+                    ? ex
+                    : new PrimitiveExpression(newPrimitive);
+            }
+        case 'binary':
+            return new BinaryExpression(tr(ex.left), ex.binaryOperator, tr(ex.right));
+        case 'variableReference':
+            return ex;
+        case 'functionInvocation':
+            return new FunctionInvocationExpression(ex.functionName, ex.arguments.map(tr));
+        case 'member':
+            return new MemberExpression(tr(ex.object), tr(ex.property), ex.computed);
+        case 'unary':
+            return new UnaryExpression(ex.operator, tr(ex.value));
     }
 }
-function transformPrimitive(val, transform) {
+function transformPrimitive(transform, val) {
+    const tranformVal = R.ifElse(isExpression, (x) => transformExpression(transform, x), (x) => transformPrimitive(transform, x));
     if (Array.isArray(val)) {
-        return val.map((x) => isExpression(x)
-            ? transformExpression(x, transform)
-            : transformPrimitive(x, transform));
+        return R.map(tranformVal, val);
     }
     else if (isRecord(val)) {
-        return mapRecordValues(val, (x) => isExpression(x)
-            ? transformExpression(x, transform)
-            : transformPrimitive(x, transform));
+        return R.map(tranformVal, val);
     }
     else {
         return val;
     }
 }
-function transformBinaryExpression(ex, transform) {
-    // Transform left first to keep the correct order of execution of sub-expressions
-    const newLeft = transformExpression(ex.left, transform);
-    const newRight = transformExpression(ex.right, transform);
-    if (newLeft === ex.left && newRight === ex.right) {
-        return ex;
-    }
-    else {
-        return new BinaryExpression(newLeft, ex.binaryOperator, newRight);
-    }
-}
-function transformFunctionInvocationExpression(ex, transform) {
-    const newArguments = ex.arguments.map((x) => transformExpression(x, transform));
-    if (newArguments.every((x, i) => x === ex.arguments[i])) {
-        return ex;
-    }
-    else {
-        return new FunctionInvocationExpression(ex.functionName, newArguments);
-    }
-}
-function transformMemberExpression(ex, transform) {
-    const newObject = transformExpression(ex.object, transform);
-    const newProperty = transformExpression(ex.property, transform);
-    if (newObject === ex.object && newProperty === ex.property) {
-        return ex;
-    }
-    else {
-        return new MemberExpression(newObject, newProperty, ex.computed);
-    }
-}
-function transformUnaryExpression(ex, transform) {
-    const newValue = transformExpression(ex.value, transform);
-    return newValue === ex.value ? ex : new UnaryExpression(ex.operator, newValue);
-}
 /**
  * Search for map literals in expressions and replace them with assign step + variable.
  *
@@ -369,7 +314,8 @@ function transformUnaryExpression(ex, transform) {
  *     return: ${__temp0.value}
  */
 function mapLiteralsAsAssignSteps(steps) {
-    return steps.flatMap((step) => transformStepExpressions(step, transformNestedMaps));
+    const transformNestedMapsInExpressions = transformStepExpressions(transformNestedMaps);
+    return R.chain(transformNestedMapsInExpressions, steps);
 }
 function transformNestedMaps(ex) {
     const generateTemporaryVariableName = createTempVariableGenerator();
@@ -395,11 +341,8 @@ function extractNestedMaps(ex, generateName, nestingLevel) {
 }
 function extractNestedMapPrimitive(primitiveEx, generateName, nestingLevel) {
     const { transformed, tempVariables } = extractNestedMapPrimitiveRecursive(primitiveEx, generateName, nestingLevel);
-    const ex = isExpression(transformed)
-        ? transformed
-        : new PrimitiveExpression(transformed);
     return {
-        transformedExpression: ex,
+        transformedExpression: asExpression(transformed),
         tempVariables,
     };
 }
@@ -511,15 +454,12 @@ function extractNestedMapUnary(ex, generateName, nestingLevel) {
 /**
  * Replace `Array.isArray(x)` with `get_type(x) == "list"`
  */
-function runtimeFunctionImplementation(steps) {
-    return steps.reduce((acc, current) => {
-        const transformedSteps = transformStepExpressions(current, (ex) => [
-            [],
-            transformExpression(ex, replaceIsArray),
-        ]);
-        acc.push(...transformedSteps);
-        return acc;
-    }, []);
+function intrinsicFunctionImplementation(steps) {
+    const tr = transformStepExpressions((ex) => [
+        [],
+        transformExpression(replaceIsArray, ex),
+    ]);
+    return R.chain(tr, steps);
 }
 function replaceIsArray(ex) {
     if (ex.expressionType === 'functionInvocation' &&
@@ -527,6 +467,6 @@ function replaceIsArray(ex) {
         return new BinaryExpression(new FunctionInvocationExpression('get_type', ex.arguments), '==', new PrimitiveExpression('list'));
     }
     else {
-        return Unmodified;
+        return ex;
     }
 }

package/dist/utils.d.ts

@@ -1,13 +1,9 @@
 export declare function isRecord(object: unknown): object is Record<keyof never, unknown>;
-/**
- * Apply f to values of obj and return the result
- */
-export declare function mapRecordValues<T, U>(obj: Record<string, T>, f: (t: T) => U): Record<string, U>;
 /**
  * Like arr.flatMap() but the callback takes two consecutive array elements.
  *
  * During the last execution of the callback, the second argument (which would
  * be element after the last array element) will be undefined.
  */
-export declare function flatMapPair<T, U>(arr: T[], callback: (val: T, next: T | undefined) => U[]): U[];
+export declare function chainPairs<T, U>(callback: (val: T, next: T | undefined) => U[], arr: readonly T[]): U[];
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CACtB,MAAM,EAAE,OAAO,GACd,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,EAAE,OAAO,CAAC,CAExC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAClC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EACtB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GACb,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAEnB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAC9B,GAAG,EAAE,CAAC,EAAE,EACR,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,KAAK,CAAC,EAAE,GAC7C,CAAC,EAAE,CAaL"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,wBAAgB,QAAQ,CACtB,MAAM,EAAE,OAAO,GACd,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,EAAE,OAAO,CAAC,CAExC;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,KAAK,CAAC,EAAE,EAC9C,GAAG,EAAE,SAAS,CAAC,EAAE,GAChB,CAAC,EAAE,CAKL"}

package/dist/utils.js

@@ -1,26 +1,13 @@
+import * as R from 'ramda';
 export function isRecord(object) {
     return object instanceof Object && object.constructor === Object;
 }
-/**
- * Apply f to values of obj and return the result
- */
-export function mapRecordValues(obj, f) {
-    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, f(v)]));
-}
 /**
  * Like arr.flatMap() but the callback takes two consecutive array elements.
  *
  * During the last execution of the callback, the second argument (which would
  * be element after the last array element) will be undefined.
  */
-export function flatMapPair(arr, callback) {
-    if (arr.length <= 0) {
-        return [];
-    }
-    const mapped = [];
-    for (let i = 0; i < arr.length - 1; i++) {
-        mapped.push(...callback(arr[i], arr[i + 1]));
-    }
-    mapped.push(...callback(arr[arr.length - 1], undefined));
-    return mapped;
+export function chainPairs(callback, arr) {
+    return R.chain(R.apply(callback), R.zip(arr, R.append(undefined, R.tail(arr))));
 }