@eagleoutice/flowr 1.3.11

package/dataflow/internal/process/operators/assignment.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAssignment = void 0;
+const r_bridge_1 = require("../../../../r-bridge");
+const processor_1 = require("../../../processor");
+const graph_1 = require("../../../graph");
+const environments_1 = require("../../../environments");
+const log_1 = require("../../../../util/log");
+const index_1 = require("../../../index");
+const scopes_1 = require("../../../environments/scopes");
+function processAssignment(op, data) {
+    index_1.dataflowLogger.trace(`Processing assignment with id ${op.info.id}`);
+    const lhs = (0, processor_1.processDataflowFor)(op.lhs, data);
+    const rhs = (0, processor_1.processDataflowFor)(op.rhs, data);
+    const { readTargets, newWriteNodes, writeTargets, environments, swap } = processReadAndWriteForAssignmentBasedOnOp(op, lhs, rhs, data);
+    const nextGraph = lhs.graph.mergeWith(rhs.graph);
+    // deal with special cases based on the source node and the determined read targets
+    const isFunctionSide = swap ? op.lhs : op.rhs;
+    const isFunction = isFunctionSide.type === "RFunctionDefinition" /* RType.FunctionDefinition */;
+    for (const write of newWriteNodes) {
+        nextGraph.setDefinitionOfVertex(write);
+        if (isFunction) {
+            nextGraph.addEdge(write, isFunctionSide.info.id, graph_1.EdgeType.DefinedBy, 'always', true);
+        }
+        else {
+            const impactReadTargets = determineImpactOfSource(swap ? op.lhs : op.rhs, readTargets);
+            for (const read of impactReadTargets) {
+                nextGraph.addEdge(write, read, graph_1.EdgeType.DefinedBy, undefined, true);
+            }
+        }
+    }
+    return {
+        unknownReferences: [],
+        in: readTargets,
+        out: writeTargets,
+        graph: nextGraph,
+        environments,
+        scope: data.activeScope
+    };
+}
+exports.processAssignment = processAssignment;
+function identifySourceAndTarget(op, lhs, rhs) {
+    let source;
+    let target;
+    let global = false;
+    let swap = false;
+    switch (op.lexeme) {
+        case '<-':
+        case '=':
+        case ':=':
+            [target, source] = [lhs, rhs];
+            break;
+        case '<<-':
+            [target, source, global] = [lhs, rhs, true];
+            break;
+        case '->':
+            [target, source, swap] = [rhs, lhs, true];
+            break;
+        case '->>':
+            [target, source, global, swap] = [rhs, lhs, true, true];
+            break;
+        default:
+            throw new Error(`Unknown assignment operator ${JSON.stringify(op)}`);
+    }
+    return { source, target, global, swap };
+}
+function produceWrittenNodes(op, target, global, data, functionTypeCheck) {
+    const writeNodes = [];
+    const isFunctionDef = functionTypeCheck.type === "RFunctionDefinition" /* RType.FunctionDefinition */;
+    for (const active of target.unknownReferences) {
+        writeNodes.push({
+            ...active,
+            scope: global ? scopes_1.GlobalScope : data.activeScope,
+            kind: isFunctionDef ? 'function' : 'variable',
+            definedAt: op.info.id
+        });
+    }
+    return writeNodes;
+}
+function processReadAndWriteForAssignmentBasedOnOp(op, lhs, rhs, data) {
+    // what is written/read additionally is based on lhs/rhs - assignments read written variables as well
+    const read = [...lhs.in, ...rhs.in];
+    const { source, target, global, swap } = identifySourceAndTarget(op, lhs, rhs);
+    const funcTypeCheck = swap ? op.lhs : op.rhs;
+    const writeNodes = produceWrittenNodes(op, target, global, data, funcTypeCheck);
+    if (writeNodes.length !== 1) {
+        log_1.log.warn(`Unexpected write number in assignment: ${JSON.stringify(writeNodes)}`);
+    }
+    const readFromSourceWritten = source.out;
+    let environments = (0, environments_1.overwriteEnvironments)(source.environments, target.environments);
+    // install assigned variables in environment
+    for (const write of writeNodes) {
+        environments = (0, environments_1.define)(write, global ? scopes_1.GlobalScope : scopes_1.LocalScope, environments);
+    }
+    return {
+        readTargets: [...source.unknownReferences, ...read, ...readFromSourceWritten],
+        writeTargets: [...writeNodes, ...target.out, ...readFromSourceWritten],
+        environments: environments,
+        newWriteNodes: writeNodes,
+        swap
+    };
+}
+/**
+ * Some R-constructs like loops are known to return values completely independent of their input (loops return an invisible `NULL`).
+ * This returns only those of `readTargets` that actually impact the target.
+ */
+function determineImpactOfSource(source, readTargets) {
+    // collect all ids from the source but stop at Loops, function calls, definitions and everything which links its own return
+    // for loops this is necessary as they *always* return an invisible null, for function calls we do not know if they do
+    // yet, we need to keep the ids of these elements
+    const keepEndIds = [];
+    const allIds = new Set((0, r_bridge_1.collectAllIds)(source, n => {
+        if (n.type === "RFunctionCall" /* RType.FunctionCall */ || n.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
+            keepEndIds.push(n.info.id);
+            return true;
+        }
+        return n.type === "RForLoop" /* RType.ForLoop */ || n.type === "RWhileLoop" /* RType.WhileLoop */ || n.type === "RRepeatLoop" /* RType.RepeatLoop */;
+    }));
+    for (const id of keepEndIds) {
+        allIds.add(id);
+    }
+    if (allIds.size === 0) {
+        return new Set();
+    }
+    else {
+        return new Set(readTargets.filter(ref => allIds.has(ref.nodeId)));
+    }
+}
+//# sourceMappingURL=assignment.js.map

package/dataflow/internal/process/operators/non-assignment-binary-op.d.ts

@@ -0,0 +1,4 @@
+import { DataflowInformation } from '../../info';
+import { DataflowProcessorInformation } from '../../../processor';
+import { ParentInformation, RBinaryOp } from '../../../../r-bridge';
+export declare function processNonAssignmentBinaryOp<OtherInfo>(op: RBinaryOp<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/operators/non-assignment-binary-op.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processNonAssignmentBinaryOp = void 0;
+const processor_1 = require("../../../processor");
+const linker_1 = require("../../linker");
+const environments_1 = require("../../../environments");
+function processNonAssignmentBinaryOp(op, data) {
+    const lhs = (0, processor_1.processDataflowFor)(op.lhs, data);
+    const rhs = (0, processor_1.processDataflowFor)(op.rhs, data);
+    const ingoing = [...lhs.in, ...rhs.in, ...lhs.unknownReferences, ...rhs.unknownReferences];
+    const nextGraph = lhs.graph.mergeWith(rhs.graph);
+    (0, linker_1.linkIngoingVariablesInSameScope)(nextGraph, ingoing);
+    // logical operations may not execute the right hand side (e.g., `FALSE && (x <- TRUE)`)
+    const merger = op.flavor === 'logical' ? environments_1.appendEnvironments : environments_1.overwriteEnvironments;
+    return {
+        unknownReferences: [], // binary ops require reads as without assignments there is no definition
+        in: ingoing,
+        out: [...lhs.out, ...rhs.out],
+        environments: merger(lhs.environments, rhs.environments),
+        graph: nextGraph,
+        scope: data.activeScope,
+    };
+}
+exports.processNonAssignmentBinaryOp = processNonAssignmentBinaryOp;
+//# sourceMappingURL=non-assignment-binary-op.js.map

package/dataflow/internal/process/operators/pipe.d.ts

@@ -0,0 +1,4 @@
+import { DataflowInformation } from '../../info';
+import { DataflowProcessorInformation } from '../../../processor';
+import { ParentInformation, RPipe } from '../../../../r-bridge';
+export declare function processPipeOperation<OtherInfo>(op: RPipe<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/operators/pipe.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processPipeOperation = void 0;
+const processor_1 = require("../../../processor");
+const linker_1 = require("../../linker");
+const environments_1 = require("../../../environments");
+const index_1 = require("../../../index");
+const assert_1 = require("../../../../util/assert");
+const argument_1 = require("../functions/argument");
+function processPipeOperation(op, data) {
+    const lhs = (0, processor_1.processDataflowFor)(op.lhs, data);
+    const rhs = (0, processor_1.processDataflowFor)(op.rhs, data);
+    // in-and outgoing are similar to that of a binary operation, we only 1) expect the rhs to be a function call and 2) modify the arguments.
+    const ingoing = [...lhs.in, ...rhs.in, ...lhs.unknownReferences, ...rhs.unknownReferences];
+    const nextGraph = lhs.graph.mergeWith(rhs.graph);
+    (0, linker_1.linkIngoingVariablesInSameScope)(nextGraph, ingoing);
+    if (op.rhs.type !== "RFunctionCall" /* RType.FunctionCall */) {
+        index_1.dataflowLogger.warn(`Expected rhs of pipe to be a function call, but got ${op.rhs.type} instead.`);
+    }
+    else {
+        const maybeFunctionCallNode = nextGraph.get(op.rhs.info.id, true);
+        (0, assert_1.guard)(maybeFunctionCallNode !== undefined, () => `Expected function call node with id ${op.rhs.info.id} to be present in graph, but got undefined instead (graph: ${(0, index_1.graphToMermaidUrl)(nextGraph, data.completeAst.idMap)}).`);
+        const functionCallNode = maybeFunctionCallNode[0];
+        (0, assert_1.guard)(functionCallNode.tag === 'function-call', () => `Expected function call node with id ${op.rhs.info.id} to be a function call node, but got ${functionCallNode.tag} instead.`);
+        // make the lhs an argument node:
+        const argId = op.lhs.info.id;
+        index_1.dataflowLogger.trace(`Linking pipe arg ${argId} as first argument of ${op.rhs.info.id}`);
+        functionCallNode.args.unshift({
+            nodeId: argId,
+            name: `${argument_1.UnnamedArgumentPrefix}${argId}`,
+            scope: data.activeScope,
+            used: 'always'
+        });
+        nextGraph.addEdge(functionCallNode.id, argId, index_1.EdgeType.Argument, 'always');
+    }
+    return {
+        unknownReferences: [],
+        in: ingoing,
+        out: [...lhs.out, ...rhs.out],
+        environments: (0, environments_1.overwriteEnvironments)(lhs.environments, rhs.environments),
+        graph: nextGraph,
+        scope: data.activeScope,
+    };
+}
+exports.processPipeOperation = processPipeOperation;
+//# sourceMappingURL=pipe.js.map

package/dataflow/internal/process/operators/unary-op.d.ts

@@ -0,0 +1,4 @@
+import { DataflowInformation } from '../../info';
+import { DataflowProcessorInformation } from '../../../processor';
+import { ParentInformation, RUnaryOp } from '../../../../r-bridge';
+export declare function processUnaryOp<OtherInfo>(op: RUnaryOp<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/operators/unary-op.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processUnaryOp = void 0;
+const processor_1 = require("../../../processor");
+function processUnaryOp(op, data) {
+    /* nothing has to happen to our knowledge */
+    return (0, processor_1.processDataflowFor)(op.operand, data);
+}
+exports.processUnaryOp = processUnaryOp;
+//# sourceMappingURL=unary-op.js.map

package/dataflow/internal/process/symbol.d.ts

@@ -0,0 +1,4 @@
+import { ParentInformation, RSymbol } from '../../../r-bridge';
+import { DataflowInformation } from '../info';
+import { DataflowProcessorInformation } from '../../processor';
+export declare function processSymbol<OtherInfo>(symbol: RSymbol<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo>): DataflowInformation;

package/dataflow/internal/process/symbol.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSymbol = void 0;
+const r_bridge_1 = require("../../../r-bridge");
+const graph_1 = require("../../graph");
+const info_1 = require("../info");
+function processSymbol(symbol, data) {
+    if (symbol.content === r_bridge_1.RNull || symbol.content === r_bridge_1.RNa) {
+        return (0, info_1.initializeCleanInfo)(data);
+    }
+    return {
+        unknownReferences: [{ nodeId: symbol.info.id, scope: data.activeScope, name: symbol.content, used: 'always' }],
+        in: [],
+        out: [],
+        environments: data.environments,
+        scope: data.activeScope,
+        graph: new graph_1.DataflowGraph().addVertex({ tag: 'use', id: symbol.info.id, name: symbol.content, environment: data.environments })
+    };
+}
+exports.processSymbol = processSymbol;
+//# sourceMappingURL=symbol.js.map

package/dataflow/internal/process/uninteresting-leaf.d.ts

@@ -0,0 +1,3 @@
+import { DataflowInformation } from '../info';
+import { DataflowProcessorInformation } from '../../processor';
+export declare function processUninterestingLeaf<OtherInfo>(_leaf: unknown, info: DataflowProcessorInformation<OtherInfo>): DataflowInformation;

package/dataflow/internal/process/uninteresting-leaf.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processUninterestingLeaf = void 0;
+const info_1 = require("../info");
+function processUninterestingLeaf(_leaf, info) {
+    return (0, info_1.initializeCleanInfo)(info);
+}
+exports.processUninterestingLeaf = processUninterestingLeaf;
+//# sourceMappingURL=uninteresting-leaf.js.map

package/dataflow/processor.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Based on a two-way fold, this processor will automatically supply scope information
+ */
+import { NormalizedAst, ParentInformation, RNode, RNodeWithParent } from '../r-bridge';
+import { DataflowInformation } from './internal/info';
+import { DataflowScopeName, REnvironmentInformation } from './environments';
+export interface DataflowProcessorInformation<OtherInfo> {
+    /**
+   * Initial and frozen ast-information
+   */
+    readonly completeAst: NormalizedAst<OtherInfo>;
+    /**
+   * Correctly contains pushed local scopes introduced by `function` scopes.
+   * Will by default *not* contain any symbol-bindings introduces along the way, they have to be decorated when moving up the tree.
+   */
+    readonly environments: REnvironmentInformation;
+    /**
+   * Name of the currently active scope, (hopefully) always {@link LocalScope | Local}
+   */
+    readonly activeScope: DataflowScopeName;
+    /**
+   * Other processors to be called by the given functions
+   */
+    readonly processors: DataflowProcessors<OtherInfo>;
+}
+export type DataflowProcessor<OtherInfo, NodeType extends RNodeWithParent<OtherInfo>> = (node: NodeType, data: DataflowProcessorInformation<OtherInfo>) => DataflowInformation;
+type NodeWithKey<OtherInfo, Node extends RNode<OtherInfo & ParentInformation>, TypeKey> = Node['type'] extends TypeKey ? Node : never;
+/**
+ * This way, a processor mapped to a {@link RType#Symbol} require a {@link RSymbol} as first parameter and so on.
+ */
+export type DataflowProcessors<OtherInfo> = {
+    [key in RNode['type']]: DataflowProcessor<OtherInfo, NodeWithKey<OtherInfo, RNodeWithParent<OtherInfo>, key>>;
+};
+/**
+ * Originally, dataflow processor was written as a two-way fold, but this produced problems when trying to resolve function calls
+ * which require information regarding the calling *and* definition context. While this only is a problem for late bindings as they happen
+ * with functions (and probably quote'd R-expressions) it is still a problem that must be dealt with.
+ * Therefore, the dataflow processor has no complete control over the traversal and merge strategy of the graph, with each processor being in
+ * the position to call the other processors as needed for its children.
+ * <p>
+ * Now this method can be called recursively within the other processors to parse the dataflow for nodes that you can not narrow down.
+ *
+ * @param current - The current node to start processing from
+ * @param data    - The initial information to be passed down
+ */
+export declare function processDataflowFor<OtherInfo>(current: RNodeWithParent<OtherInfo>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export {};

package/dataflow/processor.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processDataflowFor = void 0;
+/**
+ * Originally, dataflow processor was written as a two-way fold, but this produced problems when trying to resolve function calls
+ * which require information regarding the calling *and* definition context. While this only is a problem for late bindings as they happen
+ * with functions (and probably quote'd R-expressions) it is still a problem that must be dealt with.
+ * Therefore, the dataflow processor has no complete control over the traversal and merge strategy of the graph, with each processor being in
+ * the position to call the other processors as needed for its children.
+ * <p>
+ * Now this method can be called recursively within the other processors to parse the dataflow for nodes that you can not narrow down.
+ *
+ * @param current - The current node to start processing from
+ * @param data    - The initial information to be passed down
+ */
+function processDataflowFor(current, data) {
+    return data.processors[current.type](current, data);
+}
+exports.processDataflowFor = processDataflowFor;
+//# sourceMappingURL=processor.js.map

package/dataflow/v1/extractor.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processBinaryOp = exports.produceDataFlowGraph = void 0;
+const processor_1 = require("./processor");
+const uninteresting_leaf_1 = require("./internal/process/uninteresting-leaf");
+const symbol_1 = require("./internal/process/symbol");
+const non_assignment_binary_op_1 = require("./internal/process/operators/non-assignment-binary-op");
+const unary_op_1 = require("./internal/process/operators/unary-op");
+const expression_list_1 = require("./internal/process/expression-list");
+const repeat_loop_1 = require("./internal/process/loops/repeat-loop");
+const for_loop_1 = require("./internal/process/loops/for-loop");
+const while_loop_1 = require("./internal/process/loops/while-loop");
+const if_then_else_1 = require("./internal/process/if-then-else");
+const function_call_1 = require("./internal/process/functions/function-call");
+const function_definition_1 = require("./internal/process/functions/function-definition");
+const parameter_1 = require("./internal/process/functions/parameter");
+const environments_1 = require("../common/environments");
+const argument_1 = require("./internal/process/functions/argument");
+const assignment_1 = require("./internal/process/operators/assignment");
+const access_1 = require("./internal/process/access");
+const pipe_1 = require("./internal/process/operators/pipe");
+const scopes_1 = require("../common/environments/scopes");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- allows type adaption without re-creation
+const processors = {
+    ["RNumber" /* RType.Number */]: uninteresting_leaf_1.processUninterestingLeaf,
+    ["RString" /* RType.String */]: uninteresting_leaf_1.processUninterestingLeaf,
+    ["RLogical" /* RType.Logical */]: uninteresting_leaf_1.processUninterestingLeaf,
+    ["RAccess" /* RType.Access */]: access_1.processAccess,
+    ["RSymbol" /* RType.Symbol */]: symbol_1.processSymbol,
+    ["RBinaryOp" /* RType.BinaryOp */]: processBinaryOp,
+    ["RPipe" /* RType.Pipe */]: pipe_1.processPipeOperation,
+    ["RUnaryOp" /* RType.UnaryOp */]: unary_op_1.processUnaryOp,
+    ["RForLoop" /* RType.ForLoop */]: for_loop_1.processForLoop,
+    ["RWhileLoop" /* RType.WhileLoop */]: while_loop_1.processWhileLoop,
+    ["RRepeatLoop" /* RType.RepeatLoop */]: repeat_loop_1.processRepeatLoop,
+    ["RIfThenElse" /* RType.IfThenElse */]: if_then_else_1.processIfThenElse,
+    ["RBreak" /* RType.Break */]: uninteresting_leaf_1.processUninterestingLeaf,
+    ["RNext" /* RType.Next */]: uninteresting_leaf_1.processUninterestingLeaf,
+    ["RComment" /* RType.Comment */]: uninteresting_leaf_1.processUninterestingLeaf,
+    ["RLineDirective" /* RType.LineDirective */]: uninteresting_leaf_1.processUninterestingLeaf,
+    ["RFunctionCall" /* RType.FunctionCall */]: function_call_1.processFunctionCall,
+    ["RFunctionDefinition" /* RType.FunctionDefinition */]: function_definition_1.processFunctionDefinition,
+    ["RParameter" /* RType.Parameter */]: parameter_1.processFunctionParameter,
+    ["RArgument" /* RType.Argument */]: argument_1.processFunctionArgument,
+    ["RExpressionList" /* RType.ExpressionList */]: expression_list_1.processExpressionList,
+};
+function produceDataFlowGraph(ast, initialScope = scopes_1.LocalScope) {
+    return (0, processor_1.processDataflowFor)(ast.ast, { completeAst: ast, activeScope: initialScope, environments: (0, environments_1.initializeCleanEnvironments)(), processors: processors });
+}
+exports.produceDataFlowGraph = produceDataFlowGraph;
+function processBinaryOp(node, data) {
+    if (node.flavor === 'assignment') {
+        return (0, assignment_1.processAssignment)(node, data);
+    }
+    else {
+        return (0, non_assignment_binary_op_1.processNonAssignmentBinaryOp)(node, data);
+    }
+}
+exports.processBinaryOp = processBinaryOp;
+//# sourceMappingURL=extractor.js.map

package/dataflow/v1/graph/diff.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffEdges = exports.diffVertices = exports.diffFunctionArguments = exports.equalFunctionArguments = exports.equalExitPoints = exports.diffOfDataflowGraphs = void 0;
+const environments_1 = require("../../common/environments");
+const assert_1 = require("../../../util/assert");
+const diff_1 = require("../../../util/diff");
+const json_1 = require("../../../util/json");
+class DataflowDifferenceReport {
+    _comments = undefined;
+    addComment(comment) {
+        if (this._comments === undefined) {
+            this._comments = [comment];
+        }
+        else {
+            this._comments.push(comment);
+        }
+    }
+    comments() {
+        return this._comments;
+    }
+    isEqual() {
+        return this._comments === undefined;
+    }
+}
+function initDiffContext(left, right) {
+    return {
+        left: left.graph,
+        leftname: left.name,
+        right: right.graph,
+        rightname: right.name,
+        report: new DataflowDifferenceReport(),
+        position: ''
+    };
+}
+function diff(ctx) {
+    diffRootVertices(ctx);
+    diffVertices(ctx);
+    diffOutgoingEdges(ctx);
+    return true;
+}
+function diffOutgoingEdges(ctx) {
+    const lEdges = new Map(ctx.left.edges());
+    const rEdges = new Map(ctx.right.edges());
+    if (lEdges.size !== rEdges.size) {
+        ctx.report.addComment(`Detected different number of edges! ${ctx.leftname} has ${lEdges.size}, ${ctx.rightname} has ${rEdges.size}`);
+    }
+    for (const [id, edge] of lEdges) {
+        diffEdges(ctx, id, edge, rEdges.get(id));
+    }
+}
+function diffRootVertices(ctx) {
+    (0, diff_1.setDifference)(ctx.left.rootIds(), ctx.right.rootIds(), { ...ctx, position: `${ctx.position}Root vertices differ in graphs. ` });
+}
+function diffOfDataflowGraphs(left, right) {
+    if (left.graph === right.graph) {
+        return new DataflowDifferenceReport();
+    }
+    const ctx = initDiffContext(left, right);
+    diff(ctx);
+    return ctx.report;
+}
+exports.diffOfDataflowGraphs = diffOfDataflowGraphs;
+function diffFunctionArgumentsReferences(a, b, ctx) {
+    if (a === '<value>' || b === '<value>') {
+        if (a !== b) {
+            ctx.report.addComment(`${ctx.position}${ctx.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`);
+        }
+        return;
+    }
+    (0, environments_1.diffIdentifierReferences)(a, b, ctx);
+}
+function equalExitPoints(a, b) {
+    if (a === undefined || b === undefined) {
+        return a === b;
+    }
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; ++i) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.equalExitPoints = equalExitPoints;
+function equalFunctionArguments(a, b) {
+    const ctx = {
+        report: new DataflowDifferenceReport(),
+        leftname: 'left',
+        rightname: 'right',
+        position: ''
+    };
+    diffFunctionArguments(a, b, ctx);
+    return ctx.report.isEqual();
+}
+exports.equalFunctionArguments = equalFunctionArguments;
+function diffFunctionArguments(a, b, ctx) {
+    if (a === false || b === false) {
+        if (a !== b) {
+            ctx.report.addComment(`${ctx.position}${ctx.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`);
+        }
+        return;
+    }
+    else if (a.length !== b.length) {
+        ctx.report.addComment(`${ctx.position}Differs in number of arguments. ${ctx.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`);
+        return;
+    }
+    for (let i = 0; i < a.length; ++i) {
+        const aArg = a[i];
+        const bArg = b[i];
+        if (Array.isArray(aArg) && Array.isArray(bArg)) {
+            // must have same name
+            if (aArg[0] !== bArg[0]) {
+                ctx.report.addComment(`${ctx.position}In the ${i}th argument (of ${ctx.leftname}, named) the name differs: ${aArg[0]} vs ${bArg[0]}.`);
+                continue;
+            }
+            diffFunctionArgumentsReferences(aArg[1], bArg[1], {
+                ...ctx,
+                position: `${ctx.position} In the ${i}th argument (of ${ctx.leftname}, named). `
+            });
+        }
+        else {
+            diffFunctionArgumentsReferences(aArg, bArg, { ...ctx, position: `${ctx.position} In the ${i}th argument (of ${ctx.leftname}, unnamed).` });
+        }
+    }
+}
+exports.diffFunctionArguments = diffFunctionArguments;
+function diffVertices(ctx) {
+    // collect vertices from both sides
+    const lVert = [...ctx.left.vertices(true)];
+    const rVert = [...ctx.right.vertices(true)];
+    if (lVert.length !== rVert.length) {
+        ctx.report.addComment(`Detected different number of vertices! ${ctx.leftname} has ${lVert.length}, ${ctx.rightname} has ${rVert.length}`);
+    }
+    for (const [id, lInfo] of lVert) {
+        const rInfoMay = ctx.right.get(id);
+        if (rInfoMay === undefined) {
+            ctx.report.addComment(`Vertex ${id} is not present in ${ctx.rightname}`);
+            continue;
+        }
+        const [rInfo] = rInfoMay;
+        if (lInfo.tag !== rInfo.tag) {
+            ctx.report.addComment(`Vertex ${id} has different tags. ${ctx.leftname}: ${lInfo.tag} vs. ${ctx.rightname}: ${rInfo.tag}`);
+        }
+        if (lInfo.name !== rInfo.name) {
+            ctx.report.addComment(`Vertex ${id} has different names. ${ctx.leftname}: ${lInfo.name} vs ${ctx.rightname}: ${rInfo.name}`);
+        }
+        if (lInfo.tag === 'variable-definition' || lInfo.tag === 'function-definition') {
+            (0, assert_1.guard)(lInfo.tag === rInfo.tag, () => `node ${id} does not match on tag (${lInfo.tag} vs ${rInfo.tag})`);
+            if (lInfo.scope !== rInfo.scope) {
+                ctx.report.addComment(`Vertex ${id} has different scopes. ${ctx.leftname}: ${lInfo.scope} vs ${ctx.rightname}: ${rInfo.scope}`);
+            }
+        }
+        if (lInfo.when !== rInfo.when) {
+            ctx.report.addComment(`Vertex ${id} has different when. ${ctx.leftname}: ${lInfo.when} vs ${ctx.rightname}: ${rInfo.when}`);
+        }
+        (0, environments_1.diffEnvironments)(lInfo.environment, rInfo.environment, { ...ctx, position: `${ctx.position}Vertex ${id} differs in environments. ` });
+        if (lInfo.tag === 'function-call') {
+            (0, assert_1.guard)(rInfo.tag === 'function-call', 'otherInfo must be a function call as well');
+            diffFunctionArguments(lInfo.args, rInfo.args, { ...ctx, position: `${ctx.position}Vertex ${id} (function call) differs in arguments. ` });
+        }
+        if (lInfo.tag === 'function-definition') {
+            (0, assert_1.guard)(rInfo.tag === 'function-definition', 'otherInfo must be a function definition as well');
+            if (!equalExitPoints(lInfo.exitPoints, rInfo.exitPoints)) {
+                ctx.report.addComment(`Vertex ${id} has different exit points. ${ctx.leftname}: ${JSON.stringify(lInfo.exitPoints, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.exitPoints, json_1.jsonReplacer)}`);
+            }
+            if (lInfo.subflow.scope !== rInfo.subflow.scope) {
+                ctx.report.addComment(`Vertex ${id} has different subflow scope. ${ctx.leftname}: ${JSON.stringify(lInfo.subflow, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.subflow, json_1.jsonReplacer)}`);
+            }
+            (0, environments_1.diffEnvironments)(lInfo.subflow.environments, rInfo.subflow.environments, { ...ctx, position: `${ctx.position}Vertex ${id} (function definition) differs in subflow environments. ` });
+            (0, diff_1.setDifference)(lInfo.subflow.graph, rInfo.subflow.graph, { ...ctx, position: `${ctx.position}Vertex ${id} differs in subflow graph. ` });
+        }
+    }
+}
+exports.diffVertices = diffVertices;
+function diffEdges(ctx, id, lEdges, rEdges) {
+    if (lEdges === undefined || rEdges === undefined) {
+        if (lEdges !== rEdges) {
+            ctx.report.addComment(`Vertex ${id} has undefined outgoing edges. ${ctx.leftname}: ${JSON.stringify(lEdges, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rEdges, json_1.jsonReplacer)}`);
+        }
+        return;
+    }
+    if (lEdges.size !== rEdges.size) {
+        ctx.report.addComment(`Vertex ${id} has different number of outgoing edges. ${ctx.leftname}: ${JSON.stringify(lEdges, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rEdges, json_1.jsonReplacer)}`);
+    }
+    // order independent compare
+    for (const [target, edge] of lEdges) {
+        const otherEdge = rEdges.get(target);
+        if (otherEdge === undefined) {
+            ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} is not present in ${ctx.rightname}`);
+            continue;
+        }
+        if (edge.types.size !== otherEdge.types.size) {
+            ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} has different number of edge types: ${JSON.stringify([...edge.types])} vs ${JSON.stringify([...otherEdge.types])}`);
+        }
+        if ([...edge.types].some(e => !otherEdge.types.has(e))) {
+            ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} has different edge types: ${JSON.stringify([...edge.types])} vs ${JSON.stringify([...otherEdge.types])}`);
+        }
+        if (edge.attribute !== otherEdge.attribute) {
+            ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} has different attributes: ${JSON.stringify(edge.attribute)} vs ${JSON.stringify(otherEdge.attribute)}`);
+        }
+    }
+}
+exports.diffEdges = diffEdges;
+//# sourceMappingURL=diff.js.map

package/dataflow/v1/graph/edge.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeType = void 0;
+/**
+ * Represents the relationship between the source and the target vertex in the dataflow graph.
+ */
+var EdgeType;
+(function (EdgeType) {
+    /** The edge determines that source reads target */
+    EdgeType["Reads"] = "reads";
+    /** The edge determines that source is defined by target */
+    EdgeType["DefinedBy"] = "defined-by";
+    /** The edge determines that both nodes reference the same variable in a lexical/scoping sense, source and target are interchangeable (reads for at construction unbound variables) */
+    EdgeType["SameReadRead"] = "same-read-read";
+    /** Similar to `same-read-read` but for def-def constructs without a read in-between */
+    EdgeType["SameDefDef"] = "same-def-def";
+    /** The edge determines that the source calls the target */
+    EdgeType["Calls"] = "calls";
+    /** The source returns target on call */
+    EdgeType["Returns"] = "returns";
+    /** The edge determines that source (probably argument) defines the target (probably parameter), currently automatically created by `addEdge` */
+    EdgeType["DefinesOnCall"] = "defines-on-call";
+    /** Inverse of `defines-on-call` currently only needed to get better results when slicing complex function calls */
+    EdgeType["DefinedByOnCall"] = "defined-by-on-call";
+    /** Formal used as argument to a function call */
+    EdgeType["Argument"] = "argument";
+    /** The edge determines that the source is a side effect that happens when the target is called */
+    EdgeType["SideEffectOnCall"] = "side-effect-on-call";
+    /** The source and edge relate to each other bidirectionally */
+    EdgeType["Relates"] = "relates";
+})(EdgeType || (exports.EdgeType = EdgeType = {}));
+//# sourceMappingURL=edge.js.map