@eagleoutice/flowr 1.5.2 → 2.0.0

package/dataflow/graph/diff.js

@@ -1,27 +1,44 @@
 "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("../environments");
-const assert_1 = require("../../util/assert");
+exports.diffEdges = exports.diffVertices = exports.diffFunctionArguments = exports.equalFunctionArguments = exports.diffOfDataflowGraphs = exports.DataflowDifferenceReport = void 0;
+const graph_1 = require("./graph");
 const diff_1 = require("../../util/diff");
 const json_1 = require("../../util/json");
+const arrays_1 = require("../../util/arrays");
+const edge_1 = require("./edge");
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const diff_2 = require("../environments/diff");
+const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 class DataflowDifferenceReport {
     _comments = undefined;
-    addComment(comment) {
+    _problematic = undefined;
+    addComment(comment, ...related) {
         if (this._comments === undefined) {
             this._comments = [comment];
         }
         else {
             this._comments.push(comment);
         }
+        if (related.length > 0) {
+            if (this._problematic === undefined) {
+                this._problematic = [...related];
+            }
+            else {
+                this._problematic.push(...related);
+            }
+        }
     }
     comments() {
         return this._comments;
     }
+    problematic() {
+        return this._problematic;
+    }
     isEqual() {
         return this._comments === undefined;
     }
 }
+exports.DataflowDifferenceReport = DataflowDifferenceReport;
 function initDiffContext(left, right) {
     return {
         left: left.graph,
@@ -39,14 +56,20 @@ function diff(ctx) {
     return true;
 }
 function diffOutgoingEdges(ctx) {
-    const lEdges = new Map(ctx.left.edges());
-    const rEdges = new Map(ctx.right.edges());
+    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}`);
+        ctx.report.addComment(`Detected different number of edges! ${ctx.leftname} has ${lEdges.size} (${JSON.stringify(lEdges, json_1.jsonReplacer)}). ${ctx.rightname} has ${rEdges.size} ${JSON.stringify(rEdges, json_1.jsonReplacer)}`);
     }
     for (const [id, edge] of lEdges) {
         diffEdges(ctx, id, edge, rEdges.get(id));
     }
+    // just to make it both ways in case the length differs
+    for (const [id, edge] of rEdges) {
+        if (!lEdges.has(id)) {
+            diffEdges(ctx, id, undefined, edge);
+        }
+    }
 }
 function diffRootVertices(ctx) {
     (0, diff_1.setDifference)(ctx.left.rootIds(), ctx.right.rootIds(), { ...ctx, position: `${ctx.position}Root vertices differ in graphs. ` });
@@ -60,146 +83,163 @@ function diffOfDataflowGraphs(left, right) {
     return ctx.report;
 }
 exports.diffOfDataflowGraphs = diffOfDataflowGraphs;
-function diffFunctionArgumentsReferences(a, b, ctx) {
+function diffFunctionArgumentsReferences(fn, 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)}`);
+            ctx.report.addComment(`${ctx.position}${ctx.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`, { tag: 'vertex', id: fn });
         }
         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;
+    (0, diff_2.diffIdentifierReferences)(a, b, ctx);
 }
-exports.equalExitPoints = equalExitPoints;
-function equalFunctionArguments(a, b) {
+function equalFunctionArguments(fn, a, b) {
     const ctx = {
         report: new DataflowDifferenceReport(),
         leftname: 'left',
         rightname: 'right',
         position: ''
     };
-    diffFunctionArguments(a, b, ctx);
+    diffFunctionArguments(fn, a, b, ctx);
     return ctx.report.isEqual();
 }
 exports.equalFunctionArguments = equalFunctionArguments;
-function diffFunctionArguments(a, b, ctx) {
+function diffFunctionArguments(fn, 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)}`);
+            ctx.report.addComment(`${ctx.position}${ctx.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`, { tag: 'vertex', id: fn });
         }
         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)}`);
+        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)}`, { tag: 'vertex', id: fn });
         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]}.`);
+        if (aArg === r_function_call_1.EmptyArgument || bArg === r_function_call_1.EmptyArgument) {
+            if (aArg !== bArg) {
+                ctx.report.addComment(`${ctx.position}In argument #${i} (of ${ctx.leftname}, empty) the argument differs: ${JSON.stringify(aArg)} vs ${JSON.stringify(bArg)}.`);
+            }
+        }
+        else if ((0, graph_1.isNamedArgument)(aArg) && (0, graph_1.isNamedArgument)(bArg)) {
+            // must have the same name
+            if (aArg.name !== bArg.name) {
+                ctx.report.addComment(`${ctx.position}In argument #${i} (of ${ctx.leftname}, named) the name differs: ${aArg.name} vs ${bArg.name}.`);
                 continue;
             }
-            diffFunctionArgumentsReferences(aArg[1], bArg[1], {
+            diffFunctionArgumentsReferences(fn, aArg, bArg, {
                 ...ctx,
-                position: `${ctx.position} In the ${i}th argument (of ${ctx.leftname}, named). `
+                position: `${ctx.position} In argument #${i} (of ${ctx.leftname}, named). `
             });
         }
         else {
-            diffFunctionArgumentsReferences(aArg, bArg, { ...ctx, position: `${ctx.position} In the ${i}th argument (of ${ctx.leftname}, unnamed).` });
+            if (aArg.name !== bArg.name) {
+                ctx.report.addComment(`${ctx.position}In argument #${i} (of ${ctx.leftname}, unnamed) the name differs: ${aArg.name} vs ${bArg.name}.`);
+            }
+            if (!(0, arrays_1.arrayEqual)(aArg.controlDependencies, bArg.controlDependencies)) {
+                ctx.report.addComment(`${ctx.position}In argument #${i} (of ${ctx.leftname}, unnamed) the control dependency differs: ${JSON.stringify(aArg.controlDependencies)} vs ${JSON.stringify(bArg.controlDependencies)}.`, { tag: 'vertex', id: fn });
+            }
         }
     }
 }
 exports.diffFunctionArguments = diffFunctionArguments;
 function diffVertices(ctx) {
     // collect vertices from both sides
-    const lVert = [...ctx.left.vertices(true)];
-    const rVert = [...ctx.right.vertices(true)];
+    const lVert = [...ctx.left.vertices(true)].map(([id, info]) => [id, info]);
+    const rVert = [...ctx.right.vertices(true)].map(([id, info]) => [id, info]);
     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}`);
+            ctx.report.addComment(`Vertex ${id} is not present in ${ctx.rightname}`, { tag: 'vertex', id });
             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}`);
+            ctx.report.addComment(`Vertex ${id} differs in tags. ${ctx.leftname}: ${lInfo.tag} vs. ${ctx.rightname}: ${rInfo.tag}`, { tag: 'vertex', id });
+        }
+        /* as names are optional, we have to recover the other name if at least one of them is no longer available */
+        if (lInfo.name !== undefined || rInfo.name !== undefined) {
+            const lname = lInfo.name ?? (0, node_id_1.recoverName)(id, ctx.left.idMap) ?? '??';
+            const rname = rInfo.name ?? (0, node_id_1.recoverName)(id, ctx.right.idMap) ?? '??';
+            if (lname !== rname) {
+                // eslint-disable-next-line @typescript-eslint/no-base-to-string,@typescript-eslint/restrict-template-expressions
+                ctx.report.addComment(`Vertex ${id} differs in names. ${ctx.leftname}: ${lname} vs ${ctx.rightname}: ${rname}`, {
+                    tag: 'vertex',
+                    id
+                });
             }
         }
-        if (lInfo.when !== rInfo.when) {
-            ctx.report.addComment(`Vertex ${id} has different when. ${ctx.leftname}: ${lInfo.when} vs ${ctx.rightname}: ${rInfo.when}`);
+        if (!(0, arrays_1.arrayEqual)(lInfo.controlDependencies, rInfo.controlDependencies)) {
+            ctx.report.addComment(`Vertex ${id} differs in controlDependency. ${ctx.leftname}: ${JSON.stringify(lInfo.controlDependencies)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.controlDependencies)}`, { tag: 'vertex', id });
         }
-        (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. ` });
+        (0, diff_2.diffEnvironmentInformation)(lInfo.environment, rInfo.environment, { ...ctx, position: `${ctx.position}Vertex ${id} differs in environment. ` });
+        if (lInfo.tag === "function-call" /* VertexType.FunctionCall */) {
+            if (rInfo.tag !== "function-call" /* VertexType.FunctionCall */) {
+                ctx.report.addComment(`Vertex ${id} differs in tags. ${ctx.leftname}: ${lInfo.tag} vs. ${ctx.rightname}: ${rInfo.tag}`);
+            }
+            else {
+                if (lInfo.onlyBuiltin !== rInfo.onlyBuiltin) {
+                    ctx.report.addComment(`Vertex ${id} differs in onlyBuiltin. ${ctx.leftname}: ${lInfo.onlyBuiltin} vs ${ctx.rightname}: ${rInfo.onlyBuiltin}`, { tag: 'vertex', id });
+                }
+                diffFunctionArguments(lInfo.id, 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 (rInfo.tag !== 'function-definition') {
+                ctx.report.addComment(`Vertex ${id} differs in tags. ${ctx.leftname}: ${lInfo.tag} vs. ${ctx.rightname}: ${rInfo.tag}`, { tag: 'vertex', id });
             }
-            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)}`);
+            else {
+                if (!(0, arrays_1.arrayEqual)(lInfo.exitPoints, rInfo.exitPoints)) {
+                    ctx.report.addComment(`Vertex ${id} differs in exit points. ${ctx.leftname}: ${JSON.stringify(lInfo.exitPoints, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.exitPoints, json_1.jsonReplacer)}`, { tag: 'vertex', id });
+                }
+                (0, diff_2.diffEnvironmentInformation)(lInfo.subflow.environment, rInfo.subflow.environment, {
+                    ...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. `
+                });
             }
-            (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 diffEdge(edge, otherEdge, ctx, id, target) {
+    const edgeTypes = (0, edge_1.splitEdgeTypes)(edge.types);
+    const otherEdgeTypes = (0, edge_1.splitEdgeTypes)(otherEdge.types);
+    if (edgeTypes.length !== otherEdgeTypes.length) {
+        ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} differs in number of edge types: ${JSON.stringify([...edgeTypes])} vs ${JSON.stringify([...otherEdgeTypes])}`, { tag: 'edge', from: id, to: target });
+    }
+    if (edge.types !== otherEdge.types) {
+        ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} differs in edge types: ${JSON.stringify([...(0, edge_1.edgeTypesToNames)(edge.types)])} vs ${JSON.stringify([...(0, edge_1.edgeTypesToNames)(otherEdge.types)])}`, { tag: 'edge', from: id, to: target });
+    }
+}
 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)}`);
+            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)}`, { tag: 'vertex', id });
         }
         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)}`);
+        ctx.report.addComment(`Vertex ${id} differs in number of outgoing edges. ${ctx.leftname}: [${[...lEdges.keys()].join(',')}] vs ${ctx.rightname}: [${[...rEdges.keys()].join(',')}] `, { tag: 'vertex', id });
     }
     // 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}`);
+            ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} is not present in ${ctx.rightname}`, { tag: 'edge', from: id, to: target });
             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)}`);
-        }
+        diffEdge(edge, otherEdge, ctx, id, target);
     }
 }
 exports.diffEdges = diffEdges;

package/dataflow/graph/edge.d.ts

@@ -1,37 +1,83 @@
 /**
- * An edge consist of the target node (i.e., the variable or processing node),
- * a type (if it is read or used in the context), and an attribute (if this edge exists for every program execution or
- * if it is only one possible execution path).
+ * An edge consist of:
+ * - the target node (i.e., the variable or processing node),
+ * - a type (if it is read or used in the context), and
+ * - an attribute (if this edge exists for every program execution or if it is only one possible execution path).
  */
 export interface DataflowGraphEdge {
-    types: Set<EdgeType>;
-    attribute: DataflowGraphEdgeAttribute;
+    types: EdgeTypeBits;
 }
-export type DataflowGraphEdgeAttribute = 'always' | 'maybe';
 /**
  * Represents the relationship between the source and the target vertex in the dataflow graph.
+ * The actual value is represented as a bitmask so use {@link edgeTypesToNames} to get something more human-readable.
+ * Similarly, you can access {@link EdgeTypeName} to access the name counterpart.
  */
-export declare enum EdgeType {
+export declare const enum EdgeType {
     /** The edge determines that source reads target */
-    Reads = "reads",
+    Reads = 1,
     /** The edge determines that source is defined by target */
-    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) */
-    SameReadRead = "same-read-read",
-    /** Similar to `same-read-read` but for def-def constructs without a read in-between */
-    SameDefDef = "same-def-def",
+    DefinedBy = 2,
     /** The edge determines that the source calls the target */
-    Calls = "calls",
+    Calls = 4,
     /** The source returns target on call */
-    Returns = "returns",
+    Returns = 8,
     /** The edge determines that source (probably argument) defines the target (probably parameter), currently automatically created by `addEdge` */
-    DefinesOnCall = "defines-on-call",
+    DefinesOnCall = 16,
     /** Inverse of `defines-on-call` currently only needed to get better results when slicing complex function calls */
-    DefinedByOnCall = "defined-by-on-call",
+    DefinedByOnCall = 32,
     /** Formal used as argument to a function call */
-    Argument = "argument",
+    Argument = 64,
     /** The edge determines that the source is a side effect that happens when the target is called */
+    SideEffectOnCall = 128,
+    /** The Edge determines that the reference is affected by a non-standard evaluation (e.g., a for-loop body or a quotation) */
+    NonStandardEvaluation = 256
+}
+/**
+ * See {@link EdgeType} for the basis.
+ */
+export declare const enum EdgeTypeName {
+    Reads = "reads",
+    DefinedBy = "defined-by",
+    Calls = "calls",
+    Returns = "returns",
+    DefinesOnCall = "defined-by-on-call",
+    DefinedByOnCall = "defines-on-call",
+    Argument = "argument",
     SideEffectOnCall = "side-effect-on-call",
-    /** The source and edge relate to each other bidirectionally */
-    Relates = "relates"
+    NonStandardEvaluation = "non-standard-evaluation"
+}
+export type EdgeTypeBits = number;
+/**
+ * Only use this function to retrieve a human-readable name if you know that it is a single bitmask.
+ * Otherwise, use {@link edgeTypesToNames} which handles these cases.
+ */
+export declare function edgeTypeToName(type: EdgeType): string;
+export declare function splitEdgeTypes(types: EdgeTypeBits): EdgeType[];
+export declare function edgeTypesToNames(bits: EdgeTypeBits): Set<EdgeTypeName>;
+export declare const enum TraverseEdge {
+    /** Do not traverse this edge */
+    Never = 0,
+    /** Traverse the edge as a side effect */
+    SideEffect = 1,
+    /** Traverse this edge if the definition is relevant */
+    DefinedByOnCall = 2,
+    /** Always traverse this edge */
+    Always = 3
 }
+/**
+ * Check if the given-edge type has any of the given types.
+ * @example
+ *
+ * ```typescript
+ * hasAnyTypeOf(EdgeType.Reads, EdgeType.Reads | EdgeType.DefinedBy) // true
+ *```
+ *
+ * Counterpart of {@link edgeDoesNotIncludeType}.
+ */
+export declare function edgeIncludesType(type: EdgeTypeBits, types: EdgeTypeBits): boolean;
+/**
+ * Check if the given-edge type does not include the given type.
+ * Counterpart of {@link edgeIncludesType}.
+ */
+export declare function edgeDoesNotIncludeType(type: EdgeTypeBits, types: EdgeTypeBits): boolean;
+export declare function shouldTraverseEdge(types: EdgeTypeBits): TraverseEdge;

package/dataflow/graph/edge.js

@@ -1,32 +1,78 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EdgeType = void 0;
+exports.shouldTraverseEdge = exports.edgeDoesNotIncludeType = exports.edgeIncludesType = exports.edgeTypesToNames = exports.splitEdgeTypes = exports.edgeTypeToName = void 0;
+const edgeTypeToHumanReadableName = new Map([
+    [1 /* EdgeType.Reads */, "reads" /* EdgeTypeName.Reads */],
+    [2 /* EdgeType.DefinedBy */, "defined-by" /* EdgeTypeName.DefinedBy */],
+    [4 /* EdgeType.Calls */, "calls" /* EdgeTypeName.Calls */],
+    [8 /* EdgeType.Returns */, "returns" /* EdgeTypeName.Returns */],
+    [16 /* EdgeType.DefinesOnCall */, "defined-by-on-call" /* EdgeTypeName.DefinesOnCall */],
+    [32 /* EdgeType.DefinedByOnCall */, "defines-on-call" /* EdgeTypeName.DefinedByOnCall */],
+    [64 /* EdgeType.Argument */, "argument" /* EdgeTypeName.Argument */],
+    [128 /* EdgeType.SideEffectOnCall */, "side-effect-on-call" /* EdgeTypeName.SideEffectOnCall */],
+    [256 /* EdgeType.NonStandardEvaluation */, "non-standard-evaluation" /* EdgeTypeName.NonStandardEvaluation */]
+]);
 /**
- * Represents the relationship between the source and the target vertex in the dataflow graph.
+ * Only use this function to retrieve a human-readable name if you know that it is a single bitmask.
+ * Otherwise, use {@link edgeTypesToNames} which handles these cases.
  */
-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 = {}));
+function edgeTypeToName(type) {
+    return edgeTypeToHumanReadableName.get(type);
+}
+exports.edgeTypeToName = edgeTypeToName;
+function splitEdgeTypes(types) {
+    const split = [];
+    for (const bit of edgeTypeToHumanReadableName.keys()) {
+        if ((types & bit) !== 0) {
+            split.push(bit);
+        }
+    }
+    return split;
+}
+exports.splitEdgeTypes = splitEdgeTypes;
+function edgeTypesToNames(bits) {
+    const types = new Set();
+    for (const [bit, name] of edgeTypeToHumanReadableName.entries()) {
+        if ((bits & bit) !== 0) {
+            types.add(name);
+        }
+    }
+    return types;
+}
+exports.edgeTypesToNames = edgeTypesToNames;
+/**
+ * Check if the given-edge type has any of the given types.
+ * @example
+ *
+ * ```typescript
+ * hasAnyTypeOf(EdgeType.Reads, EdgeType.Reads | EdgeType.DefinedBy) // true
+ *```
+ *
+ * Counterpart of {@link edgeDoesNotIncludeType}.
+ */
+function edgeIncludesType(type, types) {
+    return (types & type) !== 0;
+}
+exports.edgeIncludesType = edgeIncludesType;
+/**
+ * Check if the given-edge type does not include the given type.
+ * Counterpart of {@link edgeIncludesType}.
+ */
+function edgeDoesNotIncludeType(type, types) {
+    return (types & type) === 0;
+}
+exports.edgeDoesNotIncludeType = edgeDoesNotIncludeType;
+function shouldTraverseEdge(types) {
+    if (edgeIncludesType(types, 1 /* EdgeType.Reads */ | 2 /* EdgeType.DefinedBy */ | 64 /* EdgeType.Argument */ | 4 /* EdgeType.Calls */ | 16 /* EdgeType.DefinesOnCall */)) {
+        return 3 /* TraverseEdge.Always */;
+    }
+    else if (edgeIncludesType(types, 32 /* EdgeType.DefinedByOnCall */)) {
+        return 2 /* TraverseEdge.DefinedByOnCall */;
+    }
+    else if (edgeIncludesType(types, 128 /* EdgeType.SideEffectOnCall */)) {
+        return 1 /* TraverseEdge.SideEffect */;
+    }
+    return 0 /* TraverseEdge.Never */;
+}
+exports.shouldTraverseEdge = shouldTraverseEdge;
 //# sourceMappingURL=edge.js.map