@eagleoutice/flowr 1.5.1 → 2.0.0

package/dataflow/graph/graph.d.ts

@@ -1,29 +1,38 @@
-import type { NodeId, NoInfo, RNodeWithParent } from '../../r-bridge';
-import type { IdentifierDefinition, IdentifierReference } from '../environments';
-import type { BiMap } from '../../util/bimap';
-import type { DataflowGraphEdge, DataflowGraphEdgeAttribute } from './edge';
+import type { DataflowGraphEdge } from './edge';
 import { EdgeType } from './edge';
-import type { DataflowInformation } from '../internal/info';
+import type { DataflowInformation } from '../info';
+import type { DataflowDifferenceReport } from './diff';
 import type { DataflowGraphVertexArgument, DataflowGraphVertexInfo } from './vertex';
-import type { DifferenceReport } from '../../util/diff';
-/** Used to get an entry point for every id, after that it allows reference-chasing of the graph */
-export type DataflowMap<OtherInfo = NoInfo> = BiMap<NodeId, RNodeWithParent<OtherInfo>>;
-export type DataflowFunctionFlowInformation = Omit<DataflowInformation, 'graph'> & {
+import { EmptyArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { IdentifierDefinition, IdentifierReference } from '../environments/identifier';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+export type DataflowFunctionFlowInformation = Omit<DataflowInformation, 'graph' | 'exitPoints'> & {
     graph: Set<NodeId>;
 };
-export type NamedFunctionArgument = [string, IdentifierReference | '<value>'];
-export type PositionalFunctionArgument = IdentifierReference | '<value>';
-export type FunctionArgument = NamedFunctionArgument | PositionalFunctionArgument | 'empty';
-type ReferenceForEdge = Pick<IdentifierReference, 'nodeId' | 'used'> | IdentifierDefinition;
+export interface NamedFunctionArgument extends IdentifierReference {
+    readonly name: string;
+}
+export interface PositionalFunctionArgument extends Omit<IdentifierReference, 'name'> {
+    readonly name?: undefined;
+}
+export type FunctionArgument = NamedFunctionArgument | PositionalFunctionArgument | typeof EmptyArgument;
+export declare function isPositionalArgument(arg: FunctionArgument): arg is PositionalFunctionArgument;
+export declare function isNamedArgument(arg: FunctionArgument): arg is NamedFunctionArgument;
+export declare function getReferenceOfArgument(arg: FunctionArgument): NodeId | undefined;
+type ReferenceForEdge = Pick<IdentifierReference, 'nodeId' | 'controlDependencies'> | IdentifierDefinition;
 /**
  * Maps the edges target to the edge information
  */
-export type OutgoingEdges = Map<NodeId, DataflowGraphEdge>;
+export type OutgoingEdges<Edge extends DataflowGraphEdge = DataflowGraphEdge> = Map<NodeId, Edge>;
 /**
  * Similar to {@link OutgoingEdges}, but inverted regarding the edge direction.
  * In other words, it maps the source to the edge information.
  */
-export type IngoingEdges = Map<NodeId, DataflowGraphEdge>;
+export type IngoingEdges<Edge extends DataflowGraphEdge = DataflowGraphEdge> = Map<NodeId, Edge>;
+type EdgeData<Edge extends DataflowGraphEdge> = Omit<Edge, 'from' | 'to' | 'types' | 'attribute'> & {
+    type: EdgeType;
+};
 /**
  * The dataflow graph holds the dataflow information found within the given AST.
  * We differentiate the directed edges in {@link EdgeType} and the vertices indicated by {@link DataflowGraphVertexArgument}
@@ -35,8 +44,10 @@ export type IngoingEdges = Map<NodeId, DataflowGraphEdge>;
  *
  * All methods return the modified graph to allow for chaining.
  */
-export declare class DataflowGraph {
+export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = DataflowGraphVertexInfo, Edge extends DataflowGraphEdge = DataflowGraphEdge> {
     private static DEFAULT_ENVIRONMENT;
+    readonly idMap: AstIdMap | undefined;
+    constructor(idMap: AstIdMap | undefined);
     /** Contains the vertices of the root level graph (i.e., included those vertices from the complete graph, that are nested within function definitions) */
     private rootVertices;
     /** All vertices in the complete graph (including those nested in function definition) */
@@ -49,8 +60,20 @@ export declare class DataflowGraph {
      * @param id                      - The id of the node to get
      * @param includeDefinedFunctions - If true this will search function definitions as well and not just the toplevel
      * @returns the node info for the given id (if it exists)
+     *
+     * @see #getVertex
+     */
+    get(id: NodeId, includeDefinedFunctions?: boolean): [Vertex, OutgoingEdges] | undefined;
+    /**
+     * Get the {@link DataflowGraphVertexInfo} attached to a vertex.
+     *
+     * @param id                      - The id of the node to get
+     * @param includeDefinedFunctions - If true this will search function definitions as well and not just the toplevel
+     * @returns the node info for the given id (if it exists)
+     *
+     * @see #get
      */
-    get(id: NodeId, includeDefinedFunctions?: boolean): [DataflowGraphVertexInfo, OutgoingEdges] | undefined;
+    getVertex(id: NodeId, includeDefinedFunctions?: boolean): Vertex | undefined;
     outgoingEdges(id: NodeId): OutgoingEdges | undefined;
     ingoingEdges(id: NodeId): IngoingEdges | undefined;
     /**
@@ -59,7 +82,7 @@ export declare class DataflowGraph {
      *
      * @see #edges
    */
-    vertices(includeDefinedFunctions: boolean): IterableIterator<[NodeId, DataflowGraphVertexInfo]>;
+    vertices(includeDefinedFunctions: boolean): IterableIterator<[NodeId, Vertex]>;
     /**
      * @returns the ids of all edges in the graph together with their edge information
      *
@@ -72,7 +95,7 @@ export declare class DataflowGraph {
      * @param id                      - The id to check for
      * @param includeDefinedFunctions - If true this will check function definitions as well and not just the toplevel
      */
-    hasNode(id: NodeId, includeDefinedFunctions: boolean): boolean;
+    hasVertex(id: NodeId, includeDefinedFunctions: boolean): boolean;
     /**
      * Returns true if the root level of the graph contains a node with the given id.
      */
@@ -82,19 +105,20 @@ export declare class DataflowGraph {
    * Adds a new vertex to the graph, for ease of use, some arguments are optional and filled automatically.
    *
      * @param vertex - The vertex to add
-     * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds | root vertices} of the graph.
+     * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds|root vertices} of the graph.
      *                 This is probably only of use, when you construct dataflow graphs for tests.
      *
    * @see DataflowGraphVertexInfo
    * @see DataflowGraphVertexArgument
    */
-    addVertex(vertex: DataflowGraphVertexArgument, asRoot?: boolean): this;
-    /** Basically only exists for creations in tests, within the dataflow-extraction, this 3-argument variant will determine `attribute` automatically */
-    addEdge(from: NodeId, to: NodeId, type: EdgeType, attribute: DataflowGraphEdgeAttribute): this;
+    addVertex(vertex: DataflowGraphVertexArgument & Omit<Vertex, keyof DataflowGraphVertexArgument>, asRoot?: boolean): this;
+    /** {@inheritDoc} */
+    addEdge(from: NodeId, to: NodeId, edgeInfo: EdgeData<Edge>): this;
     /** {@inheritDoc} */
-    addEdge(from: ReferenceForEdge, to: ReferenceForEdge, type: EdgeType): this;
+    addEdge(from: ReferenceForEdge, to: ReferenceForEdge, edgeInfo: EdgeData<Edge>): this;
     /** {@inheritDoc} */
-    addEdge(from: NodeId | ReferenceForEdge, to: NodeId | ReferenceForEdge, type: EdgeType, attribute?: DataflowGraphEdgeAttribute, promote?: boolean): this;
+    addEdge(from: NodeId | ReferenceForEdge, to: NodeId | ReferenceForEdge, edgeInfo: EdgeData<Edge>): this;
+    private installEdge;
     /**
      * Merges the other graph into *this* one (in-place). The return value is only for convenience.
      *
@@ -102,13 +126,13 @@ export declare class DataflowGraph {
      * @param mergeRootVertices - If false, this will only merge the vertices and edges but exclude the root vertices this is probably only of use
      * 													  in the context of function definitions
      */
-    mergeWith(otherGraph: DataflowGraph | undefined, mergeRootVertices?: boolean): this;
+    mergeWith(otherGraph: DataflowGraph<Vertex, Edge> | undefined, mergeRootVertices?: boolean): this;
     private mergeEdges;
-    equals(other: DataflowGraph, diff: true, names?: {
+    equals(other: DataflowGraph<Vertex, Edge>, diff: true, names?: {
         left: string;
         right: string;
-    }): DifferenceReport;
-    equals(other: DataflowGraph, diff?: false, names?: {
+    }): DataflowDifferenceReport;
+    equals(other: DataflowGraph<Vertex, Edge>, diff?: false, names?: {
         left: string;
         right: string;
     }): boolean;

package/dataflow/graph/graph.js

@@ -1,11 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataflowGraph = void 0;
+exports.DataflowGraph = exports.getReferenceOfArgument = exports.isNamedArgument = exports.isPositionalArgument = void 0;
 const assert_1 = require("../../util/assert");
-const environments_1 = require("../environments");
-const log_1 = require("../../util/log");
-const edge_1 = require("./edge");
 const diff_1 = require("./diff");
+const arrays_1 = require("../../util/arrays");
+const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const environment_1 = require("../environments/environment");
+const clone_1 = require("../environments/clone");
+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;
+    return { fromId, toId };
+}
 /**
  * The dataflow graph holds the dataflow information found within the given AST.
  * We differentiate the directed edges in {@link EdgeType} and the vertices indicated by {@link DataflowGraphVertexArgument}
@@ -18,7 +39,12 @@ const diff_1 = require("./diff");
  * All methods return the modified graph to allow for chaining.
  */
 class DataflowGraph {
-    static DEFAULT_ENVIRONMENT = (0, environments_1.initializeCleanEnvironments)();
+    static DEFAULT_ENVIRONMENT = undefined;
+    idMap;
+    constructor(idMap) {
+        DataflowGraph.DEFAULT_ENVIRONMENT ??= (0, environment_1.initializeCleanEnvironments)();
+        this.idMap = idMap;
+    }
     /** Contains the vertices of the root level graph (i.e., included those vertices from the complete graph, that are nested within function definitions) */
     rootVertices = new Set();
     /** All vertices in the complete graph (including those nested in function definition) */
@@ -31,12 +57,26 @@ class DataflowGraph {
      * @param id                      - The id of the node to get
      * @param includeDefinedFunctions - If true this will search function definitions as well and not just the toplevel
      * @returns the node info for the given id (if it exists)
+     *
+     * @see #getVertex
      */
     get(id, includeDefinedFunctions = true) {
         // if we do not want to include function definitions, only retrieve the value if the id is part of the root vertices
-        const vertex = includeDefinedFunctions || this.rootVertices.has(id) ? this.vertexInformation.get(id) : undefined;
+        const vertex = this.getVertex(id, includeDefinedFunctions);
         return vertex === undefined ? undefined : [vertex, this.outgoingEdges(id) ?? new Map()];
     }
+    /**
+     * Get the {@link DataflowGraphVertexInfo} attached to a vertex.
+     *
+     * @param id                      - The id of the node to get
+     * @param includeDefinedFunctions - If true this will search function definitions as well and not just the toplevel
+     * @returns the node info for the given id (if it exists)
+     *
+     * @see #get
+     */
+    getVertex(id, includeDefinedFunctions = true) {
+        return includeDefinedFunctions || this.rootVertices.has(id) ? this.vertexInformation.get(id) : undefined;
+    }
     outgoingEdges(id) {
         return this.edgeInformation.get(id);
     }
@@ -79,7 +119,7 @@ class DataflowGraph {
      * @param id                      - The id to check for
      * @param includeDefinedFunctions - If true this will check function definitions as well and not just the toplevel
      */
-    hasNode(id, includeDefinedFunctions) {
+    hasVertex(id, includeDefinedFunctions) {
         return includeDefinedFunctions ? this.vertexInformation.has(id) : this.rootVertices.has(id);
     }
     /**
@@ -95,7 +135,7 @@ class DataflowGraph {
    * Adds a new vertex to the graph, for ease of use, some arguments are optional and filled automatically.
    *
      * @param vertex - The vertex to add
-     * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds | root vertices} of the graph.
+     * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds|root vertices} of the graph.
      *                 This is probably only of use, when you construct dataflow graphs for tests.
      *
    * @see DataflowGraphVertexInfo
@@ -104,14 +144,13 @@ class DataflowGraph {
     addVertex(vertex, asRoot = true) {
         const oldVertex = this.vertexInformation.get(vertex.id);
         if (oldVertex !== undefined) {
-            (0, assert_1.guard)(oldVertex.name === vertex.name, 'vertex names must match for the same id if added');
             return this;
         }
         // keep a clone of the original environment
-        const environment = vertex.environment === undefined ? DataflowGraph.DEFAULT_ENVIRONMENT : (0, environments_1.cloneEnvironments)(vertex.environment);
+        const environment = vertex.environment === undefined ? DataflowGraph.DEFAULT_ENVIRONMENT : (0, clone_1.cloneEnvironmentInformation)(vertex.environment);
         this.vertexInformation.set(vertex.id, {
             ...vertex,
-            when: vertex.when ?? 'always',
+            when: vertex.controlDependencies ?? 'always',
             environment
         });
         if (asRoot) {
@@ -123,37 +162,15 @@ class DataflowGraph {
    * Will insert a new edge into the graph,
    * if the direction of the edge is of no importance (`same-read-read` or `same-def-def`), source
    * and target will be sorted so that `from` has the lower, and `to` the higher id (default ordering).
-   * <p>
-   * If you omit the last argument but set promote, this will make the edge `maybe` if at least one of the {@link IdentifierReference | references} or {@link DataflowGraphVertexInfo | nodes} has a used flag of `maybe`.
-   * Promote will probably only be used internally and not by tests etc.
    */
-    addEdge(from, to, type, attribute, promote = false) {
-        const fromId = typeof from === 'object' ? from.nodeId : from;
-        const toId = typeof to === 'object' ? to.nodeId : to;
+    addEdge(from, to, edgeInfo) {
+        const { fromId, toId } = extractEdgeIds(from, to);
+        const { type, ...rest } = edgeInfo;
         if (fromId === toId) {
-            log_1.log.trace(`ignoring self-edge from ${fromId} to ${toId} (${type}, ${attribute ?? '?'}, ${promote ? 'y' : 'n'})`);
             return this;
         }
-        if (promote) {
-            attribute ??= from.used === 'maybe' ? 'maybe' : to.used;
-            // reduce the load on attribute checks
-            if (attribute !== 'maybe') {
-                const fromInfo = this.get(fromId, true);
-                if (fromInfo?.[0].when === 'maybe') {
-                    log_1.log.trace(`automatically promoting edge from ${fromId} to ${toId} as maybe because at least one of the nodes is maybe`);
-                    attribute = 'maybe';
-                }
-                else {
-                    const toInfo = this.get(toId, true);
-                    if (toInfo?.[0].when === 'maybe') {
-                        log_1.log.trace(`automatically promoting edge from ${fromId} to ${toId} as maybe because at least one of the nodes is maybe`);
-                        attribute = 'maybe';
-                    }
-                }
-            }
-        }
-        (0, assert_1.guard)(attribute !== undefined, 'attribute must be set');
-        const edge = { types: new Set([type]), attribute };
+        /* we now that we pass all required arguments */
+        const edge = { types: type, ...rest };
         const existingFrom = this.edgeInformation.get(fromId);
         const edgeInFrom = existingFrom?.get(toId);
         if (edgeInFrom === undefined) {
@@ -163,41 +180,28 @@ class DataflowGraph {
             else {
                 existingFrom.set(toId, edge);
             }
-            // sort (on id so that sorting is the same, independent of the attribute)
-            const bidirectional = type === 'same-read-read' || type === 'same-def-def' || type === 'relates';
-            if (bidirectional) {
-                const existingTo = this.edgeInformation.get(toId);
-                if (existingTo === undefined) {
-                    this.edgeInformation.set(toId, new Map([[fromId, edge]]));
-                }
-                else {
-                    existingTo.set(fromId, edge);
-                }
-            }
-            else if (type === 'defines-on-call') {
-                const otherEdge = { ...edge,
-                    types: new Set([edge_1.EdgeType.DefinedByOnCall])
-                };
-                const existingTo = this.edgeInformation.get(toId);
-                if (existingTo === undefined) {
-                    this.edgeInformation.set(toId, new Map([[fromId, otherEdge]]));
-                }
-                else {
-                    existingTo.set(fromId, otherEdge);
-                }
-            }
+            this.installEdge(type, toId, fromId, edge);
         }
         else {
-            if (attribute === 'maybe') {
-                // as the data is shared, we can just set it for one direction
-                edgeInFrom.attribute = 'maybe';
+            // adding the type
+            edgeInFrom.types |= type;
+        }
+        return this;
+    }
+    installEdge(type, toId, fromId, edge) {
+        if (type === 16 /* EdgeType.DefinesOnCall */) {
+            const otherEdge = {
+                ...edge,
+                types: 32 /* EdgeType.DefinedByOnCall */
+            };
+            const existingTo = this.edgeInformation.get(toId);
+            if (existingTo === undefined) {
+                this.edgeInformation.set(toId, new Map([[fromId, otherEdge]]));
             }
-            if (!edgeInFrom.types.has(type)) {
-                // adding the type
-                edgeInFrom.types.add(type);
+            else {
+                existingTo.set(fromId, otherEdge);
             }
         }
-        return this;
     }
     /**
      * Merges the other graph into *this* one (in-place). The return value is only for convenience.
@@ -236,10 +240,7 @@ class DataflowGraph {
                         existing.set(target, edge);
                     }
                     else {
-                        get.types = new Set([...get.types, ...edge.types]);
-                        if (edge.attribute === 'maybe') {
-                            get.attribute = 'maybe';
-                        }
+                        get.types = get.types | edge.types;
                     }
                 }
             }
@@ -259,38 +260,32 @@ class DataflowGraph {
      * @param reference - The reference to the vertex to mark as definition
      */
     setDefinitionOfVertex(reference) {
-        const got = this.get(reference.nodeId, true);
-        (0, assert_1.guard)(got !== undefined, () => `node must be defined for ${JSON.stringify(reference)} to set definition scope to ${reference.scope}`);
-        const [node] = got;
-        if (node.tag === 'function-definition' || node.tag === 'variable-definition') {
-            (0, assert_1.guard)(node.scope === reference.scope, () => `node ${JSON.stringify(node)} must not be previously defined at position or have same scope for ${JSON.stringify(reference)}`);
-            (0, assert_1.guard)(node.when === reference.used || node.when === 'maybe' || reference.used === 'maybe', () => `node ${JSON.stringify(node)} must not be previously defined at position or have same scope for ${JSON.stringify(reference)}`);
-            node.scope = reference.scope;
-            node.when = reference.used === 'maybe' ? 'maybe' : node.when;
+        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 */) {
+            (0, assert_1.guard)(vertex.controlDependencies !== undefined
+                || reference.controlDependencies !== undefined
+                || (0, arrays_1.arrayEqual)(vertex.controlDependencies, reference.controlDependencies), () => `node ${JSON.stringify(vertex)} must not be previously defined at position or have same scope for ${JSON.stringify(reference)}`);
+            vertex.controlDependencies = reference.controlDependencies;
         }
         else {
-            this.vertexInformation.set(reference.nodeId, {
-                ...node,
-                tag: 'variable-definition',
-                scope: reference.scope,
-            });
+            this.vertexInformation.set(reference.nodeId, { ...vertex, tag: 'variable-definition' });
         }
     }
 }
 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.name === next.name, () => `nodes to be joined for the same id must have the same name, 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') {
         (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') {
-        (0, assert_1.guard)((0, diff_1.equalFunctionArguments)(current.args, next.args), 'nodes to be joined for the same id must have the same function call information');
+    else if (current.tag === "function-call" /* 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') {
         (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, diff_1.equalExitPoints)(current.exitPoints, next.exitPoints), 'nodes to be joined must have same exist points');
+        (0, assert_1.guard)((0, arrays_1.arrayEqual)(current.exitPoints, next.exitPoints), 'nodes to be joined must have same exist points');
     }
     // make a copy
     return { ...current };

package/dataflow/graph/quads.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.df2quads = void 0;
 const quads_1 = require("../../util/quads");
+const edge_1 = require("./edge");
 /**
  * @see cfg2quads
  * @see serialize2quads
@@ -18,8 +19,7 @@ function df2quads(graph, config) {
         edges: [...graph.edges()].flatMap(([fromId, targets]) => [...targets].map(([toId, info]) => ({
             from: fromId,
             to: toId,
-            type: [...info.types],
-            when: info.attribute
+            type: [...(0, edge_1.edgeTypesToNames)(info.types)],
         })))
     }, config);
 }

package/dataflow/graph/vertex.d.ts

@@ -1,9 +1,15 @@
 import type { MergeableRecord } from '../../util/objects';
-import type { NodeId } from '../../r-bridge';
-import type { DataflowScopeName, REnvironmentInformation } from '../environments';
-import type { DataflowGraphEdgeAttribute } from './edge';
 import type { DataflowFunctionFlowInformation, FunctionArgument } from './graph';
-export type DataflowGraphVertices = Map<NodeId, DataflowGraphVertexInfo>;
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { REnvironmentInformation } from '../environments/environment';
+export type DataflowGraphVertices<Vertex extends DataflowGraphVertexInfo = DataflowGraphVertexInfo> = Map<NodeId, Vertex>;
+export declare const enum VertexType {
+    Value = "value",
+    Use = "use",
+    FunctionCall = "function-call",
+    VariableDefinition = "variable-definition",
+    FunctionDefinition = "function-definition"
+}
 /**
  * Arguments required to construct a vertex in the dataflow graph.
  *
@@ -15,61 +21,57 @@ interface DataflowGraphVertexBase extends MergeableRecord {
     /**
      * Used to identify and separate different types of vertices.
      */
-    readonly tag: string;
+    readonly tag: VertexType;
     /**
      * The id of the node (the id assigned by the {@link ParentInformation} decoration)
      */
     id: NodeId;
     /**
-     * The name of the node, usually the variable name
-     */
-    name: string;
-    /**
-     * The environment in which the node is defined.
-     * If you do not provide an explicit environment, this will use the same clean one (with {@link initializeCleanEnvironments}).
+     * The environment in which the vertex is set.
      */
-    environment?: REnvironmentInformation;
+    environment?: REnvironmentInformation | undefined;
     /**
-     * Is this node part of every local execution trace or only in some.
-     * If you do not provide an explicit value, this will default to `always`.
+     * See {@link IdentifierReference}
      */
-    when?: DataflowGraphEdgeAttribute;
+    controlDependencies: NodeId[] | undefined;
 }
-/**
- * Arguments required to construct a vertex which represents the usage of a variable in the dataflow graph.
- */
-export interface DataflowGraphExitPoint extends DataflowGraphVertexBase {
-    readonly tag: 'exit-point';
+export interface DataflowGraphValue extends DataflowGraphVertexBase {
+    readonly tag: VertexType.Value;
+    readonly environment?: undefined;
 }
 /**
  * Arguments required to construct a vertex which represents the usage of a variable in the dataflow graph.
  */
 export interface DataflowGraphVertexUse extends DataflowGraphVertexBase {
-    readonly tag: 'use';
+    readonly tag: VertexType.Use;
+    readonly environment?: undefined;
 }
 /**
  * Arguments required to construct a vertex which represents the usage of a variable in the dataflow graph.
  */
 export interface DataflowGraphVertexFunctionCall extends DataflowGraphVertexBase {
-    readonly tag: 'function-call';
+    readonly tag: VertexType.FunctionCall;
+    /**
+     * Effective name of the function call,
+     * Please be aware that this name can differ from the lexeme.
+     * For example, if the function is a replacement function, in this case, the actually called fn will
+     * have the compound name (e.g., `[<-`).
+     */
+    readonly name: string;
     args: FunctionArgument[];
+    /** a performance flag to indicate that the respective call is _only_ calling a builtin function without any df graph attached */
+    onlyBuiltin: boolean;
+    readonly environment: REnvironmentInformation;
 }
 /**
  * Arguments required to construct a vertex which represents the definition of a variable in the dataflow graph.
  */
 export interface DataflowGraphVertexVariableDefinition extends DataflowGraphVertexBase {
-    readonly tag: 'variable-definition';
-    /**
-     * The scope in which the vertex is defined (can be global or local to the current environment).
-     */
-    scope: DataflowScopeName;
+    readonly tag: VertexType.VariableDefinition;
+    readonly environment?: undefined;
 }
 export interface DataflowGraphVertexFunctionDefinition extends DataflowGraphVertexBase {
-    readonly tag: 'function-definition';
-    /**
-     * The scope in which the vertex is defined (can be global or local to the current environment).
-     */
-    scope: DataflowScopeName;
+    readonly tag: VertexType.FunctionDefinition;
     /**
      * 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.
@@ -79,8 +81,9 @@ export interface DataflowGraphVertexFunctionDefinition extends DataflowGraphVert
      * All exist points of the function definitions.
      * In other words: last expressions/return calls
      */
-    exitPoints: NodeId[];
+    exitPoints: readonly NodeId[];
+    environment?: REnvironmentInformation;
 }
-export type DataflowGraphVertexArgument = DataflowGraphVertexUse | DataflowGraphExitPoint | DataflowGraphVertexVariableDefinition | DataflowGraphVertexFunctionDefinition | DataflowGraphVertexFunctionCall;
+export type DataflowGraphVertexArgument = DataflowGraphVertexUse | DataflowGraphVertexVariableDefinition | DataflowGraphVertexFunctionDefinition | DataflowGraphVertexFunctionCall | DataflowGraphValue;
 export type DataflowGraphVertexInfo = Required<DataflowGraphVertexArgument>;
 export {};

package/dataflow/info.d.ts

@@ -0,0 +1,49 @@
+import type { DataflowProcessorInformation } from './processor';
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { IdentifierReference } from './environments/identifier';
+import type { REnvironmentInformation } from './environments/environment';
+import { DataflowGraph } from './graph/graph';
+export declare const enum ExitPointType {
+    Default = 0,
+    Return = 1,
+    Break = 2,
+    Next = 3
+}
+export interface ExitPoint {
+    readonly type: ExitPointType;
+    readonly nodeId: NodeId;
+    readonly controlDependencies: NodeId[] | undefined;
+}
+export declare function addNonDefaultExitPoints(existing: ExitPoint[], add: readonly ExitPoint[]): void;
+/**
+ * The control flow information for the current {@link DataflowInformation}.
+ */
+export interface DataflowCfgInformation {
+    /**
+     * The entry node into the subgraph
+     */
+    entryPoint: NodeId;
+    /**
+     * All already identified exit points (active 'return'/'break'/'next'-likes) of the respective structure.
+     */
+    exitPoints: readonly ExitPoint[];
+}
+/**
+ * The dataflow information is continuously updated during the dataflow analysis
+ * and holds its current state for the respective subtree processed.
+ */
+export interface DataflowInformation extends DataflowCfgInformation {
+    /** References that have not been identified as read or write and will be so on higher */
+    unknownReferences: readonly IdentifierReference[];
+    /** References which are read */
+    in: readonly IdentifierReference[];
+    /** References which are written to */
+    out: readonly IdentifierReference[];
+    /** Current environments used for name resolution, probably updated on the next expression-list processing */
+    environment: REnvironmentInformation;
+    /** The current constructed dataflow graph */
+    graph: DataflowGraph;
+}
+export declare function initializeCleanDataflowInformation<T>(entryPoint: NodeId, data: Pick<DataflowProcessorInformation<T>, 'environment' | 'completeAst'>): DataflowInformation;
+export declare function alwaysExits(data: DataflowInformation): boolean;
+export declare function filterOutLoopExitPoints(exitPoints: readonly ExitPoint[]): readonly ExitPoint[];

package/dataflow/info.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterOutLoopExitPoints = exports.alwaysExits = exports.initializeCleanDataflowInformation = exports.addNonDefaultExitPoints = void 0;
+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: [],
+        in: [],
+        out: [],
+        environment: data.environment,
+        graph: new graph_1.DataflowGraph(data.completeAst.idMap),
+        entryPoint,
+        exitPoints: [{ nodeId: entryPoint, type: 0 /* ExitPointType.Default */, controlDependencies: undefined }]
+    };
+}
+exports.initializeCleanDataflowInformation = initializeCleanDataflowInformation;
+function alwaysExits(data) {
+    return data.exitPoints?.some(e => e.type !== 0 /* ExitPointType.Default */ && e.controlDependencies === undefined) ?? false;
+}
+exports.alwaysExits = alwaysExits;
+function filterOutLoopExitPoints(exitPoints) {
+    return exitPoints.filter(({ type }) => type === 1 /* ExitPointType.Return */ || type === 0 /* ExitPointType.Default */);
+}
+exports.filterOutLoopExitPoints = filterOutLoopExitPoints;
+//# sourceMappingURL=info.js.map