@eagleoutice/flowr 2.9.9 → 2.9.11

package/dataflow/graph/graph.js

@@ -61,7 +61,7 @@ exports.FunctionArgument = {
     },
     /**
      * Checks whether the given argument is not an empty argument.
-     * @see {@link isEmpty}
+     * @see {@link FunctionArgument.isEmpty}
      */
     isNotEmpty(arg) {
         return arg !== r_function_call_1.EmptyArgument;
@@ -267,25 +267,24 @@ class DataflowGraph {
      * @see DataflowGraphVertexArgument
      */
     addVertex(vertex, fallbackEnv, asRoot = true, overwrite = false) {
-        const oldVertex = this.vertexInformation.get(vertex.id);
+        const vid = vertex.id;
+        const oldVertex = this.vertexInformation.get(vid);
         if (oldVertex !== undefined && !overwrite) {
             return this;
         }
-        const fallback = vertex.tag === vertex_1.VertexType.FunctionDefinition || (vertex.tag === vertex_1.VertexType.FunctionCall && !vertex.onlyBuiltin) ? fallbackEnv : undefined;
-        this.vertexInformation.set(vertex.id, {
-            ...vertex,
-            // keep a clone of the original environment
-            environment: vertex.environment ? (0, clone_1.cloneEnvironmentInformation)(vertex.environment) : fallback
-        });
+        const vtag = vertex.tag;
+        // keep a clone of the original environment
+        vertex.environment = vertex.environment ? (0, clone_1.cloneEnvironmentInformation)(vertex.environment) : (vtag === vertex_1.VertexType.FunctionDefinition || (vtag === vertex_1.VertexType.FunctionCall && !vertex.onlyBuiltin) ? fallbackEnv : undefined);
+        this.vertexInformation.set(vid, vertex);
         const has = this.types.get(vertex.tag);
         if (has) {
-            has.push(vertex.id);
+            has.push(vid);
         }
         else {
-            this.types.set(vertex.tag, [vertex.id]);
+            this.types.set(vertex.tag, [vid]);
         }
         if (asRoot) {
-            this.rootVertices.add(vertex.id);
+            this.rootVertices.add(vid);
         }
         return this;
     }
@@ -293,11 +292,10 @@ class DataflowGraph {
         if (fromId === toId) {
             return this;
         }
-        /* we now that we pass all required arguments */
-        const edge = { types: type };
         const existingFrom = this.edgeInformation.get(fromId);
         const edgeInFrom = existingFrom?.get(toId);
         if (edgeInFrom === undefined) {
+            const edge = { types: type };
             if (existingFrom === undefined) {
                 this.edgeInformation.set(fromId, new Map([[toId, edge]]));
             }
@@ -374,8 +372,9 @@ class DataflowGraph {
             vertex.cds = reference.cds;
         }
         else {
-            this.vertexInformation.set(reference.nodeId, { ...vertex, tag: vertex_1.VertexType.VariableDefinition });
-            this.types.set(vertex.tag, (this.types.get(vertex.tag) ?? []).filter(id => id !== reference.nodeId));
+            const oldTag = vertex.tag;
+            vertex.tag = vertex_1.VertexType.VariableDefinition;
+            this.types.set(oldTag, (this.types.get(oldTag) ?? []).filter(id => id !== reference.nodeId));
             this.types.set(vertex_1.VertexType.VariableDefinition, (this.types.get(vertex_1.VertexType.VariableDefinition) ?? []).concat([reference.nodeId]));
         }
     }
@@ -384,43 +383,48 @@ class DataflowGraph {
      * @param info - The information about the new function call node
      */
     updateToFunctionCall(info) {
-        const vertex = this.getVertex(info.id);
+        const infoId = info.id;
+        const vertex = this.getVertex(infoId);
         (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}`);
         const previousTag = vertex.tag;
-        this.vertexInformation.set(info.id, { ...vertex, ...info, tag: vertex_1.VertexType.FunctionCall });
-        this.types.set(previousTag, (this.types.get(previousTag) ?? []).filter(id => id !== info.id));
-        this.types.set(vertex_1.VertexType.FunctionCall, (this.types.get(vertex_1.VertexType.FunctionCall) ?? []).concat([info.id]));
+        this.vertexInformation.set(infoId, { ...vertex, ...info, tag: vertex_1.VertexType.FunctionCall });
+        this.types.set(previousTag, (this.types.get(previousTag) ?? []).filter(id => id !== infoId));
+        const g = this.types.get(vertex_1.VertexType.FunctionCall);
+        if (g) {
+            g.push(infoId);
+        }
+        else {
+            this.types.set(vertex_1.VertexType.FunctionCall, [infoId]);
+        }
     }
     /** If you do not pass the `to` node, this will just mark the node as maybe */
     addControlDependency(from, to, when) {
-        to = to ? (0, node_id_1.normalizeIdToNumberIfPossible)(to) : undefined;
+        to = node_id_1.NodeId.normalize(to);
         const vertex = this.getVertex(from);
         (0, assert_1.guard)(vertex !== undefined, () => `node must be defined for ${from} to add control dependency`);
         vertex.cds ??= [];
-        if (to) {
-            let hasControlDependency = false;
-            for (const { id, when: cond } of vertex.cds) {
-                if (id === to && when !== cond) {
-                    hasControlDependency = true;
-                    break;
-                }
-            }
-            if (!hasControlDependency) {
-                vertex.cds.push({ id: to, when });
+        let hasControlDependency = false;
+        for (const { id, when: cond } of vertex.cds) {
+            if (id === to && when !== cond) {
+                hasControlDependency = true;
+                break;
             }
         }
+        if (!hasControlDependency) {
+            vertex.cds.push({ id: to, when });
+        }
         return this;
     }
     /** Marks the given node as having unknown side effects */
     markIdForUnknownSideEffects(id, target) {
         if (target) {
             this._unknownSideEffects.add({
-                id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
+                id: node_id_1.NodeId.normalize(id),
                 linkTo: typeof target.callName === 'string' ? { ...target, callName: new RegExp(target.callName) } : target
             });
             return this;
         }
-        this._unknownSideEffects.add((0, node_id_1.normalizeIdToNumberIfPossible)(id));
+        this._unknownSideEffects.add(node_id_1.NodeId.normalize(id));
         return this;
     }
     /**

package/dataflow/graph/unknown-side-effect.js

@@ -16,6 +16,8 @@ function onUnknownSideEffect(handler) {
  */
 function handleUnknownSideEffect(graph, env, id, target) {
     graph.markIdForUnknownSideEffects(id, target);
-    handlers.forEach(handler => handler(graph, env, id, target));
+    for (const handler of handlers) {
+        handler(graph, env, id, target);
+    }
 }
 //# sourceMappingURL=unknown-side-effect.js.map

package/dataflow/info.d.ts

@@ -19,6 +19,10 @@ export interface ControlDependency {
     readonly when?: boolean;
     /** whether this control dependency was created due to iteration (e.g., a loop) */
     readonly byIteration?: boolean;
+    /**
+     * any file-exist assumptions made
+     */
+    readonly file?: string;
 }
 /**
  * Negates the given control dependency (i.e., flips the `when` flag).

package/dataflow/info.js

@@ -66,7 +66,7 @@ function initializeCleanDataflowInformation(entryPoint, data) {
         in: [],
         out: [],
         environment: data.environment,
-        graph: new graph_1.DataflowGraph(data.completeAst.idMap),
+        graph: new graph_1.DataflowGraph(undefined),
         entryPoint,
         exitPoints: [{ nodeId: entryPoint, type: 0 /* ExitPointType.Default */ }],
         hooks: []
@@ -138,7 +138,7 @@ function diffControlDependency(a, b, info) {
         info.report.addComment(`${info.position}Different control dependency ids. ${info.leftname}: ${JSON.stringify(a.id)} vs. ${info.rightname}: ${JSON.stringify(b.id)}`);
     }
     if (a.when !== b.when) {
-        info.report.addComment(`${info.position}Different control dependency when. ${info.leftname}: ${a.when} vs. ${info.rightname}: ${b.when}`);
+        info.report.addComment(`${info.position}Different control dependency when (id: ${JSON.stringify(a.id)}). ${info.leftname}: ${a.when} vs. ${info.rightname}: ${b.when}`);
     }
 }
 /**

package/dataflow/internal/linker.d.ts

@@ -1,18 +1,18 @@
 import { DefaultMap } from '../../util/collections/defaultmap';
-import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { BuiltIn } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { Identifier, type IdentifierReference } from '../environments/identifier';
 import { type DataflowGraph, FunctionArgument } from '../graph/graph';
 import type { RParameter } from '../../r-bridge/lang-4.x/ast/model/nodes/r-parameter';
 import type { AstIdMap, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { type DataflowGraphVertexFunctionCall, type DataflowGraphVertexFunctionDefinition, type DataflowGraphVertexInfo } from '../graph/vertex';
-import { type BuiltIn } from '../environments/built-in';
 import type { REnvironmentInformation } from '../environments/environment';
 import type { ExitPoint } from '../info';
 export type NameIdMap = DefaultMap<Identifier, IdentifierReference[]>;
 /**
  * Find all reads within the graph that do not reference a local definition in the graph.
  */
-export declare function findNonLocalReads(graph: DataflowGraph, ignore: readonly IdentifierReference[]): IdentifierReference[];
+export declare function findNonLocalReads(graph: DataflowGraph, ignores?: ReadonlySet<NodeId>): IdentifierReference[];
 /**
  * Produces a map from names to all identifier references sharing that name.
  */
@@ -101,4 +101,4 @@ export declare function linkCircularRedefinitionsWithinALoop(graph: DataflowGrap
 /**
  * Reapplies the loop exit points' control dependencies to the given identifier references.
  */
-export declare function reapplyLoopExitPoints(exits: readonly ExitPoint[], references: readonly IdentifierReference[]): void;
+export declare function reapplyLoopExitPoints(exits: readonly ExitPoint[], references: readonly IdentifierReference[], graph: DataflowGraph): void;

package/dataflow/internal/linker.js

@@ -32,27 +32,29 @@ const unnamed_call_handling_1 = require("./process/functions/call/unnamed-call-h
 /**
  * Find all reads within the graph that do not reference a local definition in the graph.
  */
-function findNonLocalReads(graph, ignore) {
-    const ignores = new Set(ignore.map(i => i.nodeId));
-    const ids = new Set(graph.vertexIdsOfType(vertex_1.VertexType.Use).concat(graph.vertexIdsOfType(vertex_1.VertexType.FunctionCall)));
+function findNonLocalReads(graph, ignores = new Set()) {
+    const defs = new Set(graph.vertexIdsOfType(vertex_1.VertexType.VariableDefinition).concat(graph.vertexIdsOfType(vertex_1.VertexType.FunctionDefinition)));
     /* find all variable use ids which do not link to a given id */
     const nonLocalReads = [];
-    for (const nodeId of ids) {
-        if (ignores.has(nodeId)) {
-            continue;
-        }
-        const outgoing = graph.outgoingEdges(nodeId);
-        const name = (0, node_id_1.recoverName)(nodeId, graph.idMap);
-        const origin = graph.getVertex(nodeId);
-        const type = origin?.tag === vertex_1.VertexType.FunctionCall ? identifier_1.ReferenceType.Function : identifier_1.ReferenceType.Variable;
-        if (outgoing === undefined) {
-            nonLocalReads.push({ name, nodeId, type });
-            continue;
-        }
-        for (const [target, e] of outgoing) {
-            if (edge_1.DfEdge.includesType(e, edge_1.EdgeType.Reads) && !ids.has(target)) {
-                nonLocalReads.push({ name, nodeId, type });
-                break;
+    for (const ids of [graph.vertexIdsOfType(vertex_1.VertexType.Use), graph.vertexIdsOfType(vertex_1.VertexType.FunctionCall)]) {
+        for (const nodeId of ids) {
+            if (ignores.has(nodeId)) {
+                continue;
+            }
+            const outgoing = graph.outgoingEdges(nodeId);
+            const origin = graph.getVertex(nodeId);
+            const name = (0, node_id_1.recoverName)(nodeId, graph.idMap);
+            const type = origin?.tag === vertex_1.VertexType.FunctionCall ? identifier_1.ReferenceType.Function : identifier_1.ReferenceType.Variable;
+            const identifierRef = { nodeId, name, type };
+            if (outgoing === undefined) {
+                nonLocalReads.push(identifierRef);
+                continue;
+            }
+            for (const [target, e] of outgoing) {
+                if (edge_1.DfEdge.includesType(e, edge_1.EdgeType.Reads) && !defs.has(target)) {
+                    nonLocalReads.push(identifierRef);
+                    break;
+                }
             }
         }
     }
@@ -64,8 +66,9 @@ function findNonLocalReads(graph, ignore) {
 function produceNameSharedIdMap(references) {
     const nameIdShares = new defaultmap_1.DefaultMap(() => []);
     for (const reference of references) {
-        if (reference.name) {
-            nameIdShares.get(reference.name).push(reference);
+        const rn = reference.name;
+        if (rn) {
+            nameIdShares.get(rn).push(reference);
         }
     }
     return nameIdShares;
@@ -232,7 +235,7 @@ function linkFunctionCallWithSingleTarget(graph, { subflow: fnSubflow, exitPoint
                 continue;
             }
             for (const { nodeId, type, value } of defs) {
-                if (!(0, built_in_1.isBuiltIn)(nodeId)) {
+                if (!node_id_1.NodeId.isBuiltIn(nodeId)) {
                     graph.addEdge(ingoing.nodeId, nodeId, edge_1.EdgeType.DefinedByOnCall);
                     graph.addEdge(id, nodeId, edge_1.EdgeType.DefinesOnCall);
                     if (type === identifier_1.ReferenceType.Function && ingoing.type === identifier_1.ReferenceType.S7MethodPrefix && Array.isArray(value)) {
@@ -288,7 +291,7 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
     }
     const functionDefinitionReadIds = new Set();
     for (const [t, e] of edges.entries()) {
-        if (!(0, built_in_1.isBuiltIn)(t) && edge_1.DfEdge.doesNotIncludeType(e, edge_1.EdgeType.Argument) && edge_1.DfEdge.includesType(e, FCallLinkReadBits)) {
+        if (!node_id_1.NodeId.isBuiltIn(t) && edge_1.DfEdge.doesNotIncludeType(e, edge_1.EdgeType.Argument) && edge_1.DfEdge.includesType(e, FCallLinkReadBits)) {
             functionDefinitionReadIds.add(t);
         }
     }
@@ -388,7 +391,7 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
     while (potential.length !== 0) {
         const cid = potential.pop();
         visited.add(cid);
-        if ((0, built_in_1.isBuiltIn)(cid)) {
+        if (node_id_1.NodeId.isBuiltIn(cid)) {
             builtIns.add(cid);
             continue;
         }
@@ -435,7 +438,6 @@ function linkInputs(referencesToLinkAgainstEnvironment, environmentInformation,
     for (const bodyInput of referencesToLinkAgainstEnvironment) {
         const probableTarget = bodyInput.name ? (0, resolve_by_name_1.resolveByName)(bodyInput.name, environmentInformation, bodyInput.type) : undefined;
         if (probableTarget === undefined) {
-            log_1.log.trace(`found no target for ${bodyInput.name ? identifier_1.Identifier.toString(bodyInput.name) : '<no-name>'}`);
             if (maybeForRemaining) {
                 bodyInput.cds ??= [];
             }
@@ -473,8 +475,9 @@ function linkCircularRedefinitionsWithinALoop(graph, openIns, outgoing) {
     // this implicitly assumes that the outgoing references are ordered
     const lastOutgoing = new Map();
     for (const out of outgoing) {
-        if (out.name) {
-            lastOutgoing.set(out.name, out);
+        const on = out.name;
+        if (on) {
+            lastOutgoing.set(on, out);
         }
     }
     for (const [name, targets] of openIns.entries()) {
@@ -490,19 +493,42 @@ function linkCircularRedefinitionsWithinALoop(graph, openIns, outgoing) {
 /**
  * Reapplies the loop exit points' control dependencies to the given identifier references.
  */
-function reapplyLoopExitPoints(exits, references) {
+function reapplyLoopExitPoints(exits, references, graph) {
     // just apply the cds of all exit points not already present
-    const exitCds = new Set(exits.flatMap(e => e.cds).filter(assert_1.isNotUndefined));
+    const exitCds = exits.flatMap(e => e.cds?.map(info_1.negateControlDependency))
+        .filter(assert_1.isNotUndefined)
+        .map(cd => ({ ...cd, byIteration: true }));
+    const seenRefs = new Set();
     for (const ref of references) {
+        if (seenRefs.has(ref.nodeId)) {
+            continue;
+        }
+        seenRefs.add(ref.nodeId);
         for (const cd of exitCds) {
-            const { id: cId, when: cWhen } = cd;
+            const { id: cId } = cd;
+            let setVertex = false;
             if (ref.cds) {
-                if (!ref.cds?.find(c => c.id === cId && c.when === cWhen)) {
-                    ref.cds.push({ ...cd, byIteration: true });
+                if (!ref.cds?.find(c => c.id === cId)) {
+                    ref.cds.push(cd);
+                    setVertex = true;
                 }
             }
             else {
-                ref.cds = [{ ...cd, byIteration: true }];
+                ref.cds = [cd];
+                setVertex = true;
+            }
+            if (setVertex) {
+                const vertex = graph.getVertex(ref.nodeId);
+                if (vertex) {
+                    if (vertex.cds) {
+                        if (!vertex.cds?.find(c => c.id === cId)) {
+                            vertex.cds.push(cd);
+                        }
+                    }
+                    else {
+                        vertex.cds = [cd];
+                    }
+                }
             }
         }
     }

package/dataflow/internal/process/functions/call/argument/make-argument.d.ts

@@ -2,6 +2,7 @@ import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model'
 import type { AstIdMap, ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { EmptyArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RUnnamedArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument';
+import { RArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument';
 /**
  * Converts a normalized node into an unnamed argument (wraps it with an argument node).
  */
@@ -9,4 +10,4 @@ export declare function toUnnamedArgument<OtherInfo>(node: RNode<OtherInfo & Par
 /**
  * Wraps the given nodes as unnamed arguments where necessary.
  */
-export declare function wrapArgumentsUnnamed<OtherInfo>(nodes: readonly (RNode<OtherInfo & ParentInformation> | typeof EmptyArgument | undefined)[], idMap: AstIdMap<OtherInfo>): ("<>" | import("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument").RArgument<OtherInfo & ParentInformation>)[];
+export declare function wrapArgumentsUnnamed<OtherInfo>(nodes: readonly (RNode<OtherInfo & ParentInformation> | typeof EmptyArgument | undefined)[], idMap: AstIdMap<OtherInfo>): ("<>" | RArgument<OtherInfo & ParentInformation>)[];

package/dataflow/internal/process/functions/call/argument/make-argument.js

@@ -4,7 +4,9 @@ exports.toUnnamedArgument = toUnnamedArgument;
 exports.wrapArgumentsUnnamed = wrapArgumentsUnnamed;
 const range_1 = require("../../../../../../util/range");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const r_argument_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const graph_1 = require("../../../../../graph/graph");
 /**
  * Converts a normalized node into an unnamed argument (wraps it with an argument node).
  */
@@ -30,6 +32,6 @@ function toUnnamedArgument(node, idMap) {
  * Wraps the given nodes as unnamed arguments where necessary.
  */
 function wrapArgumentsUnnamed(nodes, idMap) {
-    return nodes.map(n => n === r_function_call_1.EmptyArgument || n?.type === type_1.RType.Argument ? n : toUnnamedArgument(n, idMap));
+    return nodes.map(n => graph_1.FunctionArgument.isEmpty(n) || r_argument_1.RArgument.is(n) ? n : toUnnamedArgument(n, idMap));
 }
 //# sourceMappingURL=make-argument.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-access.d.ts

@@ -3,7 +3,7 @@ import type { DataflowInformation } from '../../../../../info';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
-import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ForceArguments } from '../common';
 /**
  * Processes different types of access operations.

package/dataflow/internal/process/functions/call/built-in/built-in-access.js

@@ -4,6 +4,7 @@ exports.processAccess = processAccess;
 exports.symbolArgumentsToStrings = symbolArgumentsToStrings;
 const known_call_handling_1 = require("../known-call-handling");
 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 logger_1 = require("../../../../../logger");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const edge_1 = require("../../../../../graph/edge");
@@ -94,7 +95,7 @@ function processAccess(name, args, rootId, data, config) {
 function processNumberBasedAccess(data, name, args, rootId, config, head) {
     const existing = data.environment.current.memory.get(':=');
     const outInfo = { definitionRootNodes: [] };
-    const tableAssignId = (0, built_in_1.builtInId)(':=-table');
+    const tableAssignId = node_id_1.NodeId.toBuiltIn(':=-table');
     data.environment.current.memory.set(':=', [{
             type: identifier_1.ReferenceType.BuiltInFunction,
             definedAt: tableAssignId,

package/dataflow/internal/process/functions/call/built-in/built-in-apply.js

@@ -15,6 +15,7 @@ const r_value_1 = require("../../../../../eval/values/r-value");
 const log_1 = require("../../../../../../util/log");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 const built_in_1 = require("../../../../../environments/built-in");
+const r_string_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-string");
 /**
  * Process an apply call like `vapply` or `mapply`.
  */
@@ -65,13 +66,10 @@ function processApply(name, args, rootId, data, config) {
     let functionName = undefined;
     let anonymous = false;
     const val = arg.value;
-    if (unquoteFunction && val.type === type_1.RType.String) {
+    if (unquoteFunction && r_string_1.RString.is(val)) {
         functionId = val.info.id;
         functionName = val.content.str;
-        information = {
-            ...information,
-            in: [...information.in, { type: identifier_1.ReferenceType.Function, name: functionName, cds: data.cds, nodeId: functionId }]
-        };
+        information.in = [...information.in, { type: identifier_1.ReferenceType.Function, name: functionName, cds: data.cds, nodeId: functionId }];
     }
     else if (val.type === type_1.RType.Symbol) {
         functionId = val.info.id;

package/dataflow/internal/process/functions/call/built-in/built-in-expression-list.d.ts

@@ -4,7 +4,7 @@
  */
 import type { DataflowInformation } from '../../../../../info';
 import { type DataflowProcessorInformation } from '../../../../../processor';
-import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';

package/dataflow/internal/process/functions/call/built-in/built-in-expression-list.js

@@ -7,6 +7,7 @@ const linker_1 = require("../../../../linker");
 const assert_1 = require("../../../../../../util/assert");
 const unpack_argument_1 = require("../argument/unpack-argument");
 const common_1 = require("../common");
+const node_id_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const graph_1 = require("../../../../../graph/graph");
 const identifier_1 = require("../../../../../environments/identifier");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
@@ -20,13 +21,13 @@ const log_1 = require("../../../../../../util/log");
 const reference_to_maybe_1 = require("../../../../../environments/reference-to-maybe");
 function linkReadNameToWriteIfPossible(read, environments, listEnvironments, remainingRead, nextGraph) {
     const readName = read.name && identifier_1.Identifier.isDotDotDotAccess(read.name) ? identifier_1.Identifier.dotdotdot() : read.name;
-    const readId = readName ? identifier_1.Identifier.getName(readName) : undefined;
     const probableTarget = readName ? (0, resolve_by_name_1.resolveByName)(readName, environments, read.type) : undefined;
     // record if at least one has not been defined
     if (probableTarget === undefined || probableTarget.some(t => !listEnvironments.has(t.nodeId) || !(0, info_1.happensInEveryBranch)(t.cds))) {
+        const readId = readName ? identifier_1.Identifier.getName(readName) : undefined;
         const has = remainingRead.get(readId);
         if (has) {
-            if (!has?.some(h => h.nodeId === read.nodeId && h.name === read.name && h.cds === read.cds)) {
+            if (!has.some(h => h.nodeId === read.nodeId && h.name === read.name && h.cds === read.cds)) {
                 has.push(read);
             }
         }
@@ -42,7 +43,7 @@ function linkReadNameToWriteIfPossible(read, environments, listEnvironments, rem
     const rid = read.nodeId;
     for (const target of probableTarget) {
         const tid = target.nodeId;
-        if ((read.type === identifier_1.ReferenceType.Function || read.type === identifier_1.ReferenceType.BuiltInFunction) && (0, built_in_1.isBuiltIn)(target.definedAt)) {
+        if (node_id_1.NodeId.isBuiltIn(target.definedAt) && (read.type === identifier_1.ReferenceType.Function || read.type === identifier_1.ReferenceType.BuiltInFunction)) {
             nextGraph.addEdge(rid, tid, edge_1.EdgeType.Reads | edge_1.EdgeType.Calls);
         }
         else {
@@ -66,7 +67,7 @@ function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextG
             while (!current?.builtInEnv) {
                 for (const definitions of current.memory.values()) {
                     for (const def of definitions) {
-                        if (!(0, built_in_1.isBuiltIn)(def.definedAt)) {
+                        if (!node_id_1.NodeId.isBuiltIn(def.definedAt)) {
                             hasUpdate = true;
                             nextGraph.addEdge(def.nodeId, functionCall, edge_1.EdgeType.SideEffectOnCall);
                         }
@@ -179,7 +180,7 @@ function processExpressionList(name, args, rootId, data) {
             argumentProcessResult: processedExpressions,
             origin: built_in_1.BuiltInProcName.ExpressionList
         });
-        nextGraph.addEdge(rootId, (0, built_in_1.builtInId)('{'), edge_1.EdgeType.Reads | edge_1.EdgeType.Calls);
+        nextGraph.addEdge(rootId, node_id_1.NodeId.toBuiltIn('{'), edge_1.EdgeType.Reads | edge_1.EdgeType.Calls);
         // process all exit points as potential returns:
         for (const exit of exitPoints) {
             if (exit.type === 1 /* ExitPointType.Return */ || exit.type === 0 /* ExitPointType.Default */) {

package/dataflow/internal/process/functions/call/built-in/built-in-for-loop.js

@@ -29,6 +29,8 @@ function processForLoop(name, args, rootId, data) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     const [variableArg, vectorArg, bodyArg] = args.map(e => (0, unpack_argument_1.unpackNonameArg)(e));
+    // we store the original environment here, as we merge it back lter in case the for-loop never executes
+    const origEnv = data.environment;
     (0, assert_1.guard)(variableArg !== undefined && vectorArg !== undefined && bodyArg !== undefined, () => `For-Loop ${JSON.stringify(args)} has missing arguments! Bad!`);
     const vector = (0, processor_1.processDataflowFor)(vectorArg, data);
     if ((0, info_1.alwaysExits)(vector)) {
@@ -41,23 +43,29 @@ function processForLoop(name, args, rootId, data) {
     let headEnvironments = (0, overwrite_1.overwriteEnvironment)(vector.environment, variable.environment);
     const headGraph = variable.graph.mergeWith(vector.graph);
     const writtenVariable = variable.unknownReferences.concat(variable.in);
+    const writtenIds = new Set();
     for (const write of writtenVariable) {
+        writtenIds.add(write.nodeId);
         headEnvironments = (0, define_1.define)({ ...write, definedAt: name.info.id, type: identifier_1.ReferenceType.Variable }, false, headEnvironments);
     }
-    data = { ...data, cds: [...data.cds ?? [], { id: name.info.id, when: true }], environment: headEnvironments };
+    data.environment = headEnvironments;
     const body = (0, processor_1.processDataflowFor)(bodyArg, data);
-    const nextGraph = headGraph.mergeWith(body.graph);
     const outEnvironment = (0, append_1.appendEnvironment)(headEnvironments, body.environment);
+    const cd = [{ id: name.info.id, when: true }];
+    const bodyRefs = body.in.concat(body.unknownReferences);
+    (0, reference_to_maybe_1.applyCdsToAllInGraphButConstants)(body.graph, bodyRefs, cd);
+    const nextGraph = headGraph.mergeWith(body.graph);
     // now we have to identify all reads that may be effected by a circular redefinition
     // for this, we search for all reads with a non-local read resolve!
-    const nameIdShares = (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(nextGraph, writtenVariable));
+    const nameIdShares = (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(nextGraph, writtenIds));
     for (const write of writtenVariable) {
         nextGraph.addEdge(write.nodeId, vector.entryPoint, edge_1.EdgeType.DefinedBy);
         nextGraph.setDefinitionOfVertex(write);
     }
-    const outgoing = variable.out.concat(writtenVariable, (0, reference_to_maybe_1.makeAllMaybe)(body.out, nextGraph, outEnvironment, true));
+    (0, reference_to_maybe_1.applyCdToReferences)(body.out, cd);
+    const outgoing = variable.out.concat(writtenVariable, body.out);
     (0, linker_1.linkCircularRedefinitionsWithinALoop)(nextGraph, nameIdShares, body.out);
-    (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences));
+    (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences), nextGraph);
     (0, common_1.patchFunctionCall)({
         nextGraph,
         rootId,
@@ -78,7 +86,8 @@ function processForLoop(name, args, rootId, data) {
         graph: nextGraph,
         entryPoint: name.info.id,
         exitPoints: (0, info_1.filterOutLoopExitPoints)(body.exitPoints),
-        environment: outEnvironment,
+        // if we can not be sure that the for-loop runs once, we have to merge back the original environment, as the body may never execute
+        environment: (0, append_1.appendEnvironment)(origEnv, outEnvironment),
         hooks: variable.hooks.concat(vector.hooks, body.hooks),
     };
 }

package/dataflow/internal/process/functions/call/built-in/built-in-function-definition.d.ts

@@ -3,7 +3,7 @@ import { type DataflowInformation } from '../../../../../info';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { DataflowGraph } from '../../../../../graph/graph';
 import { type REnvironmentInformation } from '../../../../../environments/environment';
 import type { ReadOnlyFlowrAnalyzerContext } from '../../../../../../project/context/flowr-analyzer-context';

package/dataflow/internal/process/functions/call/built-in/built-in-function-definition.js

@@ -11,6 +11,7 @@ const unpack_argument_1 = require("../argument/unpack-argument");
 const assert_1 = require("../../../../../../util/assert");
 const logger_1 = require("../../../../../logger");
 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 graph_1 = require("../../../../../graph/graph");
 const identifier_1 = require("../../../../../environments/identifier");
 const overwrite_1 = require("../../../../../environments/overwrite");
@@ -248,7 +249,7 @@ function updateNestedFunctionCalls(graph, outEnvironment) {
         const collectedNextMethods = new Set();
         const treatAsS3 = origin.includes(built_in_1.BuiltInProcName.S3Dispatch);
         for (const target of targets) {
-            if ((0, built_in_1.isBuiltIn)(target)) {
+            if (node_id_1.NodeId.isBuiltIn(target)) {
                 graph.addEdge(id, target, edge_1.EdgeType.Calls);
                 continue;
             }
@@ -289,7 +290,7 @@ function updateNestedFunctionCalls(graph, outEnvironment) {
                 const inId = ingoing.nodeId;
                 (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Found ${resolved.length} references to open ref ${id} in closure of function definition ${id}`);
                 for (const { nodeId } of resolved) {
-                    if (!(0, built_in_1.isBuiltIn)(nodeId)) {
+                    if (!node_id_1.NodeId.isBuiltIn(nodeId)) {
                         graph.addEdge(inId, nodeId, edge_1.EdgeType.DefinedByOnCall);
                         graph.addEdge(id, nodeId, edge_1.EdgeType.DefinesOnCall);
                     }

package/dataflow/internal/process/functions/call/built-in/built-in-if-then-else.js

@@ -14,8 +14,8 @@ const general_1 = require("../../../../../eval/values/general");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 const reference_to_maybe_1 = require("../../../../../environments/reference-to-maybe");
 const linker_1 = require("../../../../linker");
-const r_argument_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument");
 const built_in_1 = require("../../../../../environments/built-in");
+const r_argument_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument");
 function getArguments(config, args) {
     let condArg;
     let thenArg;
@@ -28,9 +28,9 @@ function getArguments(config, args) {
             '...': '...'
         };
         const argMaps = (0, linker_1.invertArgumentMap)((0, linker_1.pMatch)((0, common_1.convertFnArguments)(args), params));
-        condArg = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('cond')?.[0]));
-        thenArg = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('yes')?.[0]));
-        otherwiseArg = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('no')?.[0]));
+        condArg = (0, unpack_argument_1.unpackArg)(r_argument_1.RArgument.getWithId(args, argMaps.get('cond')?.[0]));
+        thenArg = (0, unpack_argument_1.unpackArg)(r_argument_1.RArgument.getWithId(args, argMaps.get('yes')?.[0]));
+        otherwiseArg = (0, unpack_argument_1.unpackArg)(r_argument_1.RArgument.getWithId(args, argMaps.get('no')?.[0]));
     }
     else {
         [condArg, thenArg, otherwiseArg] = args.map(e => (0, unpack_argument_1.unpackArg)(e));