@eagleoutice/flowr 2.0.25 → 2.1.0

package/dataflow/graph/graph.js

@@ -1,29 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataflowGraph = exports.getReferenceOfArgument = exports.isNamedArgument = exports.isPositionalArgument = void 0;
+exports.DataflowGraph = void 0;
+exports.isPositionalArgument = isPositionalArgument;
+exports.isNamedArgument = isNamedArgument;
+exports.getReferenceOfArgument = getReferenceOfArgument;
 const assert_1 = require("../../util/assert");
+const edge_1 = require("./edge");
 const diff_1 = require("./diff");
+const vertex_1 = require("./vertex");
 const arrays_1 = require("../../util/arrays");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const environment_1 = require("../environments/environment");
 const clone_1 = require("../environments/clone");
+const json_1 = require("../../util/json");
 const built_in_1 = require("../environments/built-in");
+const logger_1 = require("../logger");
 function isPositionalArgument(arg) {
     return arg !== r_function_call_1.EmptyArgument && arg.name === undefined;
 }
-exports.isPositionalArgument = isPositionalArgument;
 function isNamedArgument(arg) {
     return arg !== r_function_call_1.EmptyArgument && arg.name !== undefined;
 }
-exports.isNamedArgument = isNamedArgument;
 function getReferenceOfArgument(arg) {
     if (arg !== r_function_call_1.EmptyArgument) {
         return arg.nodeId;
     }
     return undefined;
 }
-exports.getReferenceOfArgument = getReferenceOfArgument;
 function extractEdgeIds(from, to) {
     const fromId = typeof from === 'object' ? from.nodeId : from;
     const toId = typeof to === 'object' ? to.nodeId : to;
@@ -164,9 +168,9 @@ class DataflowGraph {
         if (oldVertex !== undefined) {
             return this;
         }
-        const fallback = vertex.tag === "variable-definition" /* VertexType.VariableDefinition */ || vertex.tag === "use" /* VertexType.Use */ || vertex.tag === "value" /* VertexType.Value */ || (vertex.tag === "function-call" /* VertexType.FunctionCall */ && vertex.onlyBuiltin) ? undefined : DataflowGraph.DEFAULT_ENVIRONMENT;
+        const fallback = vertex.tag === vertex_1.VertexType.VariableDefinition || vertex.tag === vertex_1.VertexType.Use || vertex.tag === vertex_1.VertexType.Value || (vertex.tag === vertex_1.VertexType.FunctionCall && vertex.onlyBuiltin) ? undefined : DataflowGraph.DEFAULT_ENVIRONMENT;
         // keep a clone of the original environment
-        const environment = vertex.environment === undefined ? fallback : (0, clone_1.cloneEnvironmentInformation)(vertex.environment);
+        const environment = vertex.environment ? (0, clone_1.cloneEnvironmentInformation)(vertex.environment) : fallback;
         this.vertexInformation.set(vertex.id, {
             ...vertex,
             environment
@@ -182,14 +186,13 @@ class DataflowGraph {
      * and target will be sorted so that `from` has the lower, and `to` the higher id (default ordering).
      * Please note that this will never make edges to {@link BuiltIn} as they are not part of the graph.
      */
-    addEdge(from, to, edgeInfo) {
+    addEdge(from, to, type) {
         const { fromId, toId } = extractEdgeIds(from, to);
-        const { type, ...rest } = edgeInfo;
         if (fromId === toId || toId === built_in_1.BuiltIn) {
             return this;
         }
         /* we now that we pass all required arguments */
-        const edge = { types: type, ...rest };
+        const edge = { types: type };
         const existingFrom = this.edgeInformation.get(fromId);
         const edgeInFrom = existingFrom?.get(toId);
         if (edgeInFrom === undefined) {
@@ -208,10 +211,10 @@ class DataflowGraph {
         return this;
     }
     installEdge(type, toId, fromId, edge) {
-        if (type === 16 /* EdgeType.DefinesOnCall */) {
+        if (type === edge_1.EdgeType.DefinesOnCall) {
             const otherEdge = {
                 ...edge,
-                types: 32 /* EdgeType.DefinedByOnCall */
+                types: edge_1.EdgeType.DefinedByOnCall
             };
             const existingTo = this.edgeInformation.get(toId);
             if (existingTo === undefined) {
@@ -275,11 +278,11 @@ class DataflowGraph {
     setDefinitionOfVertex(reference) {
         const vertex = this.getVertex(reference.nodeId, true);
         (0, assert_1.guard)(vertex !== undefined, () => `node must be defined for ${JSON.stringify(reference)} to set reference`);
-        if (vertex.tag === "function-definition" /* VertexType.FunctionDefinition */ || vertex.tag === "variable-definition" /* VertexType.VariableDefinition */) {
+        if (vertex.tag === vertex_1.VertexType.FunctionDefinition || vertex.tag === vertex_1.VertexType.VariableDefinition) {
             vertex.controlDependencies = reference.controlDependencies;
         }
         else {
-            this.vertexInformation.set(reference.nodeId, { ...vertex, tag: 'variable-definition' });
+            this.vertexInformation.set(reference.nodeId, { ...vertex, tag: vertex_1.VertexType.VariableDefinition });
         }
     }
     /**
@@ -288,9 +291,8 @@ class DataflowGraph {
      */
     updateToFunctionCall(info) {
         const vertex = this.getVertex(info.id, true);
-        (0, assert_1.guard)(vertex !== undefined, () => `node must be defined for ${JSON.stringify(info.id)} to update it to a function call`);
-        (0, assert_1.guard)(vertex.tag === "use" /* VertexType.Use */, () => `node must be a use node for ${JSON.stringify(info.id)} to update it to a function call`);
-        this.vertexInformation.set(info.id, { ...vertex, ...info, tag: "function-call" /* VertexType.FunctionCall */ });
+        (0, assert_1.guard)(vertex !== undefined && (vertex.tag === vertex_1.VertexType.Use || vertex.tag === vertex_1.VertexType.Value), () => `node must be a use or value node for ${JSON.stringify(info.id)} to update it to a function call but is ${vertex?.tag}`);
+        this.vertexInformation.set(info.id, { ...vertex, ...info, tag: vertex_1.VertexType.FunctionCall });
     }
     /** If you do not pass the `to` node, this will just mark the node as maybe */
     addControlDependency(from, to, when) {
@@ -323,15 +325,17 @@ class DataflowGraph {
 }
 exports.DataflowGraph = DataflowGraph;
 function mergeNodeInfos(current, next) {
-    (0, assert_1.guard)(current.tag === next.tag, () => `nodes to be joined for the same id must have the same tag, but ${JSON.stringify(current)} vs ${JSON.stringify(next)}`);
-    (0, assert_1.guard)(current.environment === next.environment, 'nodes to be joined for the same id must have the same environment');
-    if (current.tag === 'variable-definition') {
+    if (current.tag !== next.tag) {
+        logger_1.dataflowLogger.warn(`nodes to be joined for the same id should have the same tag, but ${JSON.stringify(current, json_1.jsonReplacer)} vs. ${JSON.stringify(next, json_1.jsonReplacer)} -- we are currently not handling cases in which vertices may be either! Keeping current.`);
+        return { ...current };
+    }
+    if (current.tag === vertex_1.VertexType.VariableDefinition) {
         (0, assert_1.guard)(current.scope === next.scope, 'nodes to be joined for the same id must have the same scope');
     }
-    else if (current.tag === "function-call" /* VertexType.FunctionCall */) {
+    else if (current.tag === vertex_1.VertexType.FunctionCall) {
         (0, assert_1.guard)((0, diff_1.equalFunctionArguments)(current.id, current.args, next.args), 'nodes to be joined for the same id must have the same function call information');
     }
-    else if (current.tag === 'function-definition') {
+    else if (current.tag === vertex_1.VertexType.FunctionDefinition) {
         (0, assert_1.guard)(current.scope === next.scope, 'nodes to be joined for the same id must have the same scope');
         (0, assert_1.guard)((0, arrays_1.arrayEqual)(current.exitPoints, next.exitPoints), 'nodes to be joined must have same exist points');
     }

package/dataflow/graph/quads.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.df2quads = void 0;
+exports.df2quads = df2quads;
 const quads_1 = require("../../util/quads");
 const edge_1 = require("./edge");
 /**
@@ -23,5 +23,4 @@ function df2quads(graph, config) {
         })))
     }, config);
 }
-exports.df2quads = df2quads;
 //# sourceMappingURL=quads.js.map

package/dataflow/graph/resolve-graph.d.ts

@@ -0,0 +1,7 @@
+import { DataflowGraph } from './graph';
+import { type AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ * Resolves the dataflow graph ids from slicing criterion form to ids.
+ * This returns a **new** graph with the resolved ids.
+ */
+export declare function resolveDataflowGraph(graph: DataflowGraph, idMap?: AstIdMap): DataflowGraph;

package/dataflow/graph/resolve-graph.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDataflowGraph = resolveDataflowGraph;
+const graph_1 = require("./graph");
+const assert_1 = require("../../util/assert");
+const parse_1 = require("../../slicing/criterion/parse");
+const edge_1 = require("./edge");
+/**
+ * Resolves the dataflow graph ids from slicing criterion form to ids.
+ * This returns a **new** graph with the resolved ids.
+ */
+function resolveDataflowGraph(graph, idMap) {
+    const resolveMap = idMap ?? graph.idMap;
+    (0, assert_1.guard)(resolveMap !== undefined, 'idMap must be provided to resolve the graph');
+    const cache = new Map();
+    const resolve = (id) => {
+        const cached = cache.get(id);
+        if (cached !== undefined) {
+            return cached;
+        }
+        let resolved;
+        try {
+            resolved = (0, parse_1.slicingCriterionToId)(id, resolveMap);
+        }
+        catch (e) {
+            /* just keep it :D */
+            resolved = id;
+        }
+        cache.set(id, resolved);
+        return resolved;
+    };
+    const resultGraph = new graph_1.DataflowGraph(resolveMap);
+    const roots = graph.rootIds();
+    /* recreate vertices */
+    for (const [id, vertex] of graph.vertices(true)) {
+        resultGraph.addVertex({
+            ...vertex,
+            id: resolve(id)
+        }, roots.has(id));
+    }
+    /* recreate edges */
+    for (const [from, targets] of graph.edges()) {
+        for (const [to, info] of targets) {
+            for (const type of (0, edge_1.splitEdgeTypes)(info.types)) {
+                resultGraph.addEdge(resolve(from), resolve(to), type);
+            }
+        }
+    }
+    return resultGraph;
+}
+//# sourceMappingURL=resolve-graph.js.map

package/dataflow/graph/vertex.d.ts

@@ -4,7 +4,7 @@ import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-i
 import type { REnvironmentInformation } from '../environments/environment';
 import type { ControlDependency } from '../info';
 export type DataflowGraphVertices<Vertex extends DataflowGraphVertexInfo = DataflowGraphVertexInfo> = Map<NodeId, Vertex>;
-export declare const enum VertexType {
+export declare enum VertexType {
     Value = "value",
     Use = "use",
     FunctionCall = "function-call",
@@ -36,7 +36,10 @@ interface DataflowGraphVertexBase extends MergeableRecord {
      */
     controlDependencies: ControlDependency[] | undefined;
 }
-export interface DataflowGraphValue extends DataflowGraphVertexBase {
+/**
+ * Marker vertex for a value in the dataflow of the program.
+ */
+export interface DataflowGraphVertexValue extends DataflowGraphVertexBase {
     readonly tag: VertexType.Value;
     readonly environment?: undefined;
 }
@@ -45,6 +48,7 @@ export interface DataflowGraphValue extends DataflowGraphVertexBase {
  */
 export interface DataflowGraphVertexUse extends DataflowGraphVertexBase {
     readonly tag: VertexType.Use;
+    /** Does not require an environment to be attached. If we promote the use to a function call, we attach the environment later.  */
     readonly environment?: undefined;
 }
 /**
@@ -59,9 +63,11 @@ export interface DataflowGraphVertexFunctionCall extends DataflowGraphVertexBase
      * have the compound name (e.g., `[<-`).
      */
     readonly name: string;
+    /** The arguments of the function call, in order (as they are passed to the respective call if executed in R. */
     args: FunctionArgument[];
     /** a performance flag to indicate that the respective call is _only_ calling a builtin function without any df graph attached */
     onlyBuiltin: boolean;
+    /** The environment attached to the call (if such an attachment is necessary, e.g., because it represents the calling closure */
     environment: REnvironmentInformation | undefined;
 }
 /**
@@ -69,6 +75,7 @@ export interface DataflowGraphVertexFunctionCall extends DataflowGraphVertexBase
  */
 export interface DataflowGraphVertexVariableDefinition extends DataflowGraphVertexBase {
     readonly tag: VertexType.VariableDefinition;
+    /** Does not require an environment, those are attached to the call */
     readonly environment?: undefined;
 }
 export interface DataflowGraphVertexFunctionDefinition extends DataflowGraphVertexBase {
@@ -76,6 +83,7 @@ export interface DataflowGraphVertexFunctionDefinition extends DataflowGraphVert
     /**
      * The static subflow of the function definition, constructed within {@link processFunctionDefinition}.
      * If the vertex is (for example) a function, it can have a subgraph which is used as a template for each call.
+     * This is the `body` of the function.
      */
     subflow: DataflowFunctionFlowInformation;
     /**
@@ -85,9 +93,9 @@ export interface DataflowGraphVertexFunctionDefinition extends DataflowGraphVert
     exitPoints: readonly NodeId[];
     environment?: REnvironmentInformation;
 }
-export type DataflowGraphVertexArgument = DataflowGraphVertexUse | DataflowGraphVertexVariableDefinition | DataflowGraphVertexFunctionDefinition | DataflowGraphVertexFunctionCall | DataflowGraphValue;
+export type DataflowGraphVertexArgument = DataflowGraphVertexUse | DataflowGraphVertexVariableDefinition | DataflowGraphVertexFunctionDefinition | DataflowGraphVertexFunctionCall | DataflowGraphVertexValue;
 export type DataflowGraphVertexInfo = Required<DataflowGraphVertexArgument>;
-export declare function isValueVertex(vertex: DataflowGraphVertexBase): vertex is DataflowGraphValue;
+export declare function isValueVertex(vertex: DataflowGraphVertexBase): vertex is DataflowGraphVertexValue;
 export declare function isUseVertex(vertex: DataflowGraphVertexBase): vertex is DataflowGraphVertexUse;
 export declare function isFunctionCallVertex(vertex: DataflowGraphVertexBase): vertex is DataflowGraphVertexFunctionCall;
 export declare function isVariableDefinitionVertex(vertex: DataflowGraphVertexBase): vertex is DataflowGraphVertexVariableDefinition;

package/dataflow/graph/vertex.js

@@ -1,24 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFunctionDefinitionVertex = exports.isVariableDefinitionVertex = exports.isFunctionCallVertex = exports.isUseVertex = exports.isValueVertex = void 0;
+exports.VertexType = void 0;
+exports.isValueVertex = isValueVertex;
+exports.isUseVertex = isUseVertex;
+exports.isFunctionCallVertex = isFunctionCallVertex;
+exports.isVariableDefinitionVertex = isVariableDefinitionVertex;
+exports.isFunctionDefinitionVertex = isFunctionDefinitionVertex;
+var VertexType;
+(function (VertexType) {
+    VertexType["Value"] = "value";
+    VertexType["Use"] = "use";
+    VertexType["FunctionCall"] = "function-call";
+    VertexType["VariableDefinition"] = "variable-definition";
+    VertexType["FunctionDefinition"] = "function-definition";
+})(VertexType || (exports.VertexType = VertexType = {}));
 function isValueVertex(vertex) {
-    return vertex.tag === "value" /* VertexType.Value */;
+    return vertex.tag === VertexType.Value;
 }
-exports.isValueVertex = isValueVertex;
 function isUseVertex(vertex) {
-    return vertex.tag === "use" /* VertexType.Use */;
+    return vertex.tag === VertexType.Use;
 }
-exports.isUseVertex = isUseVertex;
 function isFunctionCallVertex(vertex) {
-    return vertex.tag === "function-call" /* VertexType.FunctionCall */;
+    return vertex.tag === VertexType.FunctionCall;
 }
-exports.isFunctionCallVertex = isFunctionCallVertex;
 function isVariableDefinitionVertex(vertex) {
-    return vertex.tag === "variable-definition" /* VertexType.VariableDefinition */;
+    return vertex.tag === VertexType.VariableDefinition;
 }
-exports.isVariableDefinitionVertex = isVariableDefinitionVertex;
 function isFunctionDefinitionVertex(vertex) {
-    return vertex.tag === "function-definition" /* VertexType.FunctionDefinition */;
+    return vertex.tag === VertexType.FunctionDefinition;
 }
-exports.isFunctionDefinitionVertex = isFunctionDefinitionVertex;
 //# sourceMappingURL=vertex.js.map

package/dataflow/info.d.ts

@@ -29,15 +29,11 @@ export interface ExitPoint {
     readonly controlDependencies: ControlDependency[] | undefined;
 }
 export declare function addNonDefaultExitPoints(existing: ExitPoint[], add: readonly ExitPoint[]): void;
-/** The control flow information for the current {@link DataflowInformation}. */
+/** The control flow information for the current DataflowInformation. */
 export interface DataflowCfgInformation {
-    /**
-     * The entry node into the subgraph
-     */
+    /** The entry node into the subgraph */
     entryPoint: NodeId;
-    /**
-     * All already identified exit points (active 'return'/'break'/'next'-likes) of the respective structure.
-     */
+    /** All already identified exit points (active 'return'/'break'/'next'-likes) of the respective structure. */
     exitPoints: readonly ExitPoint[];
 }
 /**

package/dataflow/info.js

@@ -1,11 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.diffControlDependencies = exports.diffControlDependency = exports.filterOutLoopExitPoints = exports.alwaysExits = exports.happensInEveryBranch = exports.initializeCleanDataflowInformation = exports.addNonDefaultExitPoints = void 0;
+exports.addNonDefaultExitPoints = addNonDefaultExitPoints;
+exports.initializeCleanDataflowInformation = initializeCleanDataflowInformation;
+exports.happensInEveryBranch = happensInEveryBranch;
+exports.alwaysExits = alwaysExits;
+exports.filterOutLoopExitPoints = filterOutLoopExitPoints;
+exports.diffControlDependency = diffControlDependency;
+exports.diffControlDependencies = diffControlDependencies;
 const graph_1 = require("./graph/graph");
 function addNonDefaultExitPoints(existing, add) {
     existing.push(...add.filter(({ type }) => type !== 0 /* ExitPointType.Default */));
 }
-exports.addNonDefaultExitPoints = addNonDefaultExitPoints;
 function initializeCleanDataflowInformation(entryPoint, data) {
     return {
         unknownReferences: [],
@@ -17,7 +22,6 @@ function initializeCleanDataflowInformation(entryPoint, data) {
         exitPoints: [{ nodeId: entryPoint, type: 0 /* ExitPointType.Default */, controlDependencies: undefined }]
     };
 }
-exports.initializeCleanDataflowInformation = initializeCleanDataflowInformation;
 function happensInEveryBranch(controlDependencies) {
     if (controlDependencies === undefined) {
         /* the cds are unconstrained */
@@ -39,15 +43,12 @@ function happensInEveryBranch(controlDependencies) {
     }
     return trues.every(id => falseSet.has(id));
 }
-exports.happensInEveryBranch = happensInEveryBranch;
 function alwaysExits(data) {
     return data.exitPoints?.some(e => e.type !== 0 /* ExitPointType.Default */ && happensInEveryBranch(e.controlDependencies)) ?? false;
 }
-exports.alwaysExits = alwaysExits;
 function filterOutLoopExitPoints(exitPoints) {
     return exitPoints.filter(({ type }) => type === 1 /* ExitPointType.Return */ || type === 0 /* ExitPointType.Default */);
 }
-exports.filterOutLoopExitPoints = filterOutLoopExitPoints;
 function diffControlDependency(a, b, info) {
     if (a === undefined || b === undefined) {
         if (a !== b) {
@@ -62,7 +63,6 @@ function diffControlDependency(a, b, info) {
         info.report.addComment(`${info.position}Different control dependency when. ${info.leftname}: ${a.when} vs. ${info.rightname}: ${b.when}`);
     }
 }
-exports.diffControlDependency = diffControlDependency;
 function diffControlDependencies(a, b, info) {
     if (a === undefined || b === undefined) {
         if (a !== b) {
@@ -77,5 +77,4 @@ function diffControlDependencies(a, b, info) {
         diffControlDependency(a[i], b[i], { ...info, position: `${info.position}Control dependency at index: ${i}: ` });
     }
 }
-exports.diffControlDependencies = diffControlDependencies;
 //# sourceMappingURL=info.js.map

package/dataflow/internal/linker.d.ts

@@ -7,7 +7,7 @@ import type { AstIdMap, ParentInformation } from '../../r-bridge/lang-4.x/ast/mo
 import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexInfo } from '../graph/vertex';
 import type { REnvironmentInformation } from '../environments/environment';
 export type NameIdMap = DefaultMap<string, IdentifierReference[]>;
-export declare function findNonLocalReads(graph: DataflowGraph): IdentifierReference[];
+export declare function findNonLocalReads(graph: DataflowGraph, ignore: readonly IdentifierReference[]): IdentifierReference[];
 export declare function produceNameSharedIdMap(references: IdentifierReference[]): NameIdMap;
 export declare function linkArgumentsOnCall(args: FunctionArgument[], params: RParameter<ParentInformation>[], graph: DataflowGraph): void;
 export declare function linkFunctionCallWithSingleTarget(graph: DataflowGraph, def: DataflowGraphVertexFunctionDefinition, info: DataflowGraphVertexFunctionCall, idMap: AstIdMap): void;
@@ -23,6 +23,8 @@ export declare function linkFunctionCalls(graph: DataflowGraph, idMap: AstIdMap,
     functionCall: NodeId;
     called: readonly DataflowGraphVertexInfo[];
 }[];
+/** convenience function returning all known call targets */
+export declare function getAllFunctionCallTargets(call: NodeId, graph: DataflowGraph): NodeId[];
 export declare function getAllLinkedFunctionDefinitions(functionDefinitionReadIds: ReadonlySet<NodeId>, dataflowGraph: DataflowGraph): Set<DataflowGraphVertexInfo>;
 /**
  * This method links a set of read variables to definitions in an environment.