@eagleoutice/flowr 1.3.11

package/dataflow/graph/graph.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataflowGraph = 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");
+/**
+ * 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}
+ *
+ * The vertices of the graph are organized in a hierarchical fashion, with a function-definition node containing the node ids of its subgraph.
+ * However, all *edges* are hoisted at the top level in the form of an (attributed) adjacency list.
+ * After the dataflow analysis, all sources and targets of the edges *must* be part of the vertices.
+ * However, this does not have to hold during the construction as edges may point from or to vertices which are yet to be constructed.
+ *
+ * All methods return the modified graph to allow for chaining.
+ */
+class DataflowGraph {
+    static DEFAULT_ENVIRONMENT = (0, environments_1.initializeCleanEnvironments)();
+    /** 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) */
+    vertexInformation = new Map();
+    /** All edges in the complete graph (including those nested in function definition) */
+    edgeInformation = new Map();
+    /**
+     * Get the {@link DataflowGraphVertexInfo} attached to a node as well as all outgoing edges.
+     *
+     * @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)
+     */
+    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;
+        return vertex === undefined ? undefined : [vertex, this.outgoingEdges(id) ?? new Map()];
+    }
+    outgoingEdges(id) {
+        return this.edgeInformation.get(id);
+    }
+    ingoingEdges(id) {
+        const edges = new Map();
+        for (const [source, outgoing] of this.edgeInformation.entries()) {
+            if (outgoing.has(id)) {
+                edges.set(source, outgoing.get(id));
+            }
+        }
+        return edges;
+    }
+    /**
+   * @param includeDefinedFunctions - If true this will iterate over function definitions as well and not just the toplevel
+   * @returns the ids of all toplevel vertices in the graph together with their vertex information
+     *
+     * @see #edges
+   */
+    *vertices(includeDefinedFunctions) {
+        if (includeDefinedFunctions) {
+            yield* this.vertexInformation.entries();
+        }
+        else {
+            for (const id of this.rootVertices) {
+                yield [id, this.vertexInformation.get(id)];
+            }
+        }
+    }
+    /**
+     * @returns the ids of all edges in the graph together with their edge information
+     *
+     * @see #vertices
+     */
+    *edges() {
+        yield* this.edgeInformation.entries();
+    }
+    /**
+     * Returns true if the graph contains a node with the given id.
+     *
+     * @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) {
+        return includeDefinedFunctions ? this.vertexInformation.has(id) : this.rootVertices.has(id);
+    }
+    /**
+     * Returns true if the root level of the graph contains a node with the given id.
+     */
+    isRoot(id) {
+        return this.rootVertices.has(id);
+    }
+    rootIds() {
+        return this.rootVertices;
+    }
+    /**
+   * 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.
+     *                 This is probably only of use, when you construct dataflow graphs for tests.
+     *
+   * @see DataflowGraphVertexInfo
+   * @see DataflowGraphVertexArgument
+   */
+    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);
+        this.vertexInformation.set(vertex.id, {
+            ...vertex,
+            when: vertex.when ?? 'always',
+            environment
+        });
+        if (asRoot) {
+            this.rootVertices.add(vertex.id);
+        }
+        return this;
+    }
+    /**
+   * 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;
+        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 };
+        const existingFrom = this.edgeInformation.get(fromId);
+        const edgeInFrom = existingFrom?.get(toId);
+        if (edgeInFrom === undefined) {
+            if (existingFrom === undefined) {
+                this.edgeInformation.set(fromId, new Map([[toId, edge]]));
+            }
+            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);
+                }
+            }
+        }
+        else {
+            if (attribute === 'maybe') {
+                // as the data is shared, we can just set it for one direction
+                edgeInFrom.attribute = 'maybe';
+            }
+            if (!edgeInFrom.types.has(type)) {
+                // adding the type
+                edgeInFrom.types.add(type);
+            }
+        }
+        return this;
+    }
+    /**
+     * Merges the other graph into *this* one (in-place). The return value is only for convenience.
+     *
+     * @param otherGraph        - The graph to merge into this one
+     * @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, mergeRootVertices = true) {
+        if (otherGraph === undefined) {
+            return this;
+        }
+        // merge root ids
+        if (mergeRootVertices) {
+            for (const root of otherGraph.rootVertices) {
+                this.rootVertices.add(root);
+            }
+        }
+        for (const [id, info] of otherGraph.vertexInformation) {
+            const currentInfo = this.vertexInformation.get(id);
+            this.vertexInformation.set(id, currentInfo === undefined ? info : mergeNodeInfos(currentInfo, info));
+        }
+        this.mergeEdges(otherGraph);
+        return this;
+    }
+    mergeEdges(otherGraph) {
+        for (const [id, edges] of otherGraph.edgeInformation.entries()) {
+            for (const [target, edge] of edges) {
+                const existing = this.edgeInformation.get(id);
+                if (existing === undefined) {
+                    this.edgeInformation.set(id, new Map([[target, edge]]));
+                }
+                else {
+                    const get = existing.get(target);
+                    if (get === undefined) {
+                        existing.set(target, edge);
+                    }
+                    else {
+                        get.types = new Set([...get.types, ...edge.types]);
+                        if (edge.attribute === 'maybe') {
+                            get.attribute = 'maybe';
+                        }
+                    }
+                }
+            }
+        }
+    }
+    equals(other, diff = false, names = { left: 'left', right: 'right' }) {
+        const report = (0, diff_1.diffOfDataflowGraphs)({ name: names.left, graph: this }, { name: names.right, graph: other });
+        if (diff) {
+            return report;
+        }
+        else {
+            return report.isEqual();
+        }
+    }
+    /**
+     * Marks a vertex in the graph to be a definition
+     * @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;
+        }
+        else {
+            this.vertexInformation.set(reference.nodeId, {
+                ...node,
+                tag: 'variable-definition',
+                scope: reference.scope,
+            });
+        }
+    }
+}
+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-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');
+    }
+    // make a copy
+    return { ...current };
+}
+//# sourceMappingURL=graph.js.map

package/dataflow/graph/index.d.ts

@@ -0,0 +1,4 @@
+export * from './graph';
+export * from './edge';
+export * from './vertex';
+export * from './diff';

package/dataflow/graph/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./graph"), exports);
+__exportStar(require("./edge"), exports);
+__exportStar(require("./vertex"), exports);
+__exportStar(require("./diff"), exports);
+//# sourceMappingURL=index.js.map

package/dataflow/graph/quads.d.ts

@@ -0,0 +1,8 @@
+import { QuadSerializationConfiguration } from '../../util/quads';
+import { DataflowGraph } from './graph';
+/**
+ * @see cfg2quads
+ * @see serialize2quads
+ * @see graph2quads
+ */
+export declare function df2quads(graph: DataflowGraph, config: QuadSerializationConfiguration): string;

package/dataflow/graph/quads.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.df2quads = void 0;
+const quads_1 = require("../../util/quads");
+/**
+ * @see cfg2quads
+ * @see serialize2quads
+ * @see graph2quads
+ */
+function df2quads(graph, config) {
+    return (0, quads_1.graph2quads)({
+        rootIds: [...graph.rootIds()],
+        vertices: [...graph.vertices(true)]
+            .map(([id, v]) => ({
+            ...v,
+            id
+        })),
+        edges: [...graph.edges()].flatMap(([fromId, targets]) => [...targets].map(([toId, info]) => ({
+            from: fromId,
+            to: toId,
+            type: [...info.types],
+            when: info.attribute
+        })))
+    }, config);
+}
+exports.df2quads = df2quads;
+//# sourceMappingURL=quads.js.map

package/dataflow/graph/vertex.d.ts

@@ -0,0 +1,86 @@
+import { MergeableRecord } from '../../util/objects';
+import { NodeId } from '../../r-bridge';
+import { DataflowScopeName, REnvironmentInformation } from '../environments';
+import { DataflowGraphEdgeAttribute } from './edge';
+import { DataflowFunctionFlowInformation, FunctionArgument } from './graph';
+export type DataflowGraphVertices = Map<NodeId, DataflowGraphVertexInfo>;
+/**
+ * Arguments required to construct a vertex in the dataflow graph.
+ *
+ * @see DataflowGraphVertexUse
+ * @see DataflowGraphVertexVariableDefinition
+ * @see DataflowGraphVertexFunctionDefinition
+ */
+interface DataflowGraphVertexBase extends MergeableRecord {
+    /**
+     * Used to identify and separate different types of vertices.
+     */
+    readonly tag: string;
+    /**
+     * 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}).
+     */
+    environment?: REnvironmentInformation;
+    /**
+     * 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`.
+     */
+    when?: DataflowGraphEdgeAttribute;
+}
+/**
+ * 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';
+}
+/**
+ * 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';
+}
+/**
+ * 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';
+    args: FunctionArgument[];
+}
+/**
+ * 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;
+}
+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;
+    /**
+     * 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.
+     */
+    subflow: DataflowFunctionFlowInformation;
+    /**
+     * All exist points of the function definitions.
+     * In other words: last expressions/return calls
+     */
+    exitPoints: NodeId[];
+}
+export type DataflowGraphVertexArgument = DataflowGraphVertexUse | DataflowGraphExitPoint | DataflowGraphVertexVariableDefinition | DataflowGraphVertexFunctionDefinition | DataflowGraphVertexFunctionCall;
+export type DataflowGraphVertexInfo = Required<DataflowGraphVertexArgument>;
+export {};

package/dataflow/graph/vertex.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=vertex.js.map

package/dataflow/index.d.ts

@@ -0,0 +1,5 @@
+export declare const dataflowLogger: import("tslog").Logger<import("tslog").ILogObj>;
+export * from './graph';
+export * from './extractor';
+export * from './environments/environment';
+export * from '../util/mermaid/dfg';

package/dataflow/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataflowLogger = void 0;
+const log_1 = require("../util/log");
+exports.dataflowLogger = log_1.log.getSubLogger({ name: 'dataflow' });
+__exportStar(require("./graph"), exports);
+__exportStar(require("./extractor"), exports);
+__exportStar(require("./environments/environment"), exports);
+__exportStar(require("../util/mermaid/dfg"), exports);
+//# sourceMappingURL=index.js.map

package/dataflow/internal/info.d.ts

@@ -0,0 +1,21 @@
+import { DataflowGraph } from '../graph';
+import { REnvironmentInformation, IdentifierReference, DataflowScopeName } from '../environments';
+import { DataflowProcessorInformation } from '../processor';
+/**
+ * Continuously updated during the dataflow analysis to hold the current state.
+ */
+export interface DataflowInformation {
+    /** Nodes that have not been identified as read or write and will be so on higher */
+    unknownReferences: IdentifierReference[];
+    /** Nodes which are read */
+    in: IdentifierReference[];
+    /** Nodes which are written to */
+    out: IdentifierReference[];
+    /** The current scope during the fold */
+    scope: DataflowScopeName;
+    /** Current environments used for name resolution, probably updated on the next expression-list processing */
+    environments: REnvironmentInformation;
+    /** The current constructed dataflow graph */
+    graph: DataflowGraph;
+}
+export declare function initializeCleanInfo<T>(data: DataflowProcessorInformation<T>): DataflowInformation;

package/dataflow/internal/info.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeCleanInfo = void 0;
+const graph_1 = require("../graph");
+function initializeCleanInfo(data) {
+    return {
+        unknownReferences: [],
+        in: [],
+        out: [],
+        scope: data.activeScope,
+        environments: data.environments,
+        graph: new graph_1.DataflowGraph()
+    };
+}
+exports.initializeCleanInfo = initializeCleanInfo;
+//# sourceMappingURL=info.js.map

package/dataflow/internal/linker.d.ts

@@ -0,0 +1,41 @@
+import { DataflowGraph, DataflowGraphVertexInfo, FunctionArgument } from '../graph';
+import { DataflowScopeName, IdentifierReference, REnvironmentInformation } from '../environments';
+import { DefaultMap } from '../../util/defaultmap';
+import { DecoratedAstMap, NodeId, ParentInformation, RParameter } from '../../r-bridge';
+export declare function linkIngoingVariablesInSameScope(graph: DataflowGraph, references: IdentifierReference[]): void;
+export type NameIdMap = DefaultMap<string, IdentifierReference[]>;
+export declare function produceNameSharedIdMap(references: IdentifierReference[]): NameIdMap;
+export declare function linkReadVariablesInSameScopeWithNames(graph: DataflowGraph, nameIdShares: DefaultMap<string, IdentifierReference[]>): void;
+export declare function linkArgumentsOnCall(args: FunctionArgument[], params: RParameter<ParentInformation>[], graph: DataflowGraph): void;
+/**
+ * Returns the called functions within the current graph, which can be used to merge the environments with the call.
+ * Furthermore, it links the corresponding arguments.
+ */
+export declare function linkFunctionCalls(graph: DataflowGraph, idMap: DecoratedAstMap, functionCalls: [NodeId, DataflowGraphVertexInfo][], thisGraph: DataflowGraph): {
+    functionCall: NodeId;
+    called: DataflowGraphVertexInfo[];
+}[];
+export declare function getAllLinkedFunctionDefinitions(functionDefinitionReadIds: Set<NodeId>, dataflowGraph: DataflowGraph): Map<NodeId, DataflowGraphVertexInfo>;
+/**
+ * This method links a set of read variables to definitions in an environment.
+ *
+ * @param referencesToLinkAgainstEnvironment - The set of references to link against the environment
+ * @param scope                              - The scope in which the linking shall happen (probably the active scope of {@link DataflowProcessorInformation})
+ * @param environmentInformation             - The environment information to link against
+ * @param givenInputs                        - The existing list of inputs that might be extended
+ * @param graph                              - The graph to enter the found links
+ * @param maybeForRemaining                  - Each input that can not be linked, will be added to `givenInputs`. If this flag is `true`, it will be marked as `maybe`.
+ *
+ * @returns the given inputs, possibly extended with the remaining inputs (those of `referencesToLinkAgainstEnvironment` that could not be linked against the environment)
+ */
+export declare function linkInputs(referencesToLinkAgainstEnvironment: IdentifierReference[], scope: DataflowScopeName, environmentInformation: REnvironmentInformation, givenInputs: IdentifierReference[], graph: DataflowGraph, maybeForRemaining: boolean): IdentifierReference[];
+/** all loops variables which are open read (not already bound by a redefinition within the loop) get a maybe read marker to their last definition within the loop
+ * e.g. with:
+ * ```R
+ * for(i in 1:10) {
+ *  x_1 <- x_2 + 1
+ * }
+ * ```
+ * `x_2` must get a read marker to `x_1` as `x_1` is the active redefinition in the second loop iteration.
+ */
+export declare function linkCircularRedefinitionsWithinALoop(graph: DataflowGraph, openIns: NameIdMap, outgoing: IdentifierReference[]): void;