@eagleoutice/flowr 2.9.9 → 2.9.10

package/dataflow/environments/default-builtin-config.js

@@ -112,8 +112,8 @@ exports.DefaultBuiltinConfig = [
             'pdf', 'jpeg', 'png', 'windows', 'postscript', 'xfig', 'bitmap', 'pictex', 'cairo_pdf', 'svg', 'bmp', 'tiff', 'X11', 'quartz',
             'jitter'
         ],
-        processor: built_in_1.BuiltInProcName.Default,
-        config: { readAllArguments: true },
+        processor: built_in_1.BuiltInProcName.DefaultReadAllArgs,
+        config: {},
         assumePrimitive: true
     },
     {
@@ -121,8 +121,8 @@ exports.DefaultBuiltinConfig = [
         names: [
             't', 'aperm' /* transpose function, permutation generation */
         ],
-        processor: built_in_1.BuiltInProcName.Default,
-        config: { readAllArguments: true },
+        processor: built_in_1.BuiltInProcName.DefaultReadAllArgs,
+        config: {},
         assumePrimitive: false
     },
     { type: 'function', names: ['rm'], processor: built_in_1.BuiltInProcName.Rm, config: {}, assumePrimitive: true },
@@ -371,6 +371,9 @@ function getDefaultProcessor(name) {
     }
     const fn = exports.DefaultBuiltinConfig.find(def => (def.names.includes(name) && def.type !== 'constant')
         || (def.type === 'replacement' && def.suffixes.flatMap(d => def.names.map(n => `${n}${d}`)).includes(name)));
-    return fn?.type === 'replacement' ? built_in_1.BuiltInProcName.Replacement : fn?.processor;
+    if (fn?.type === 'replacement') {
+        return built_in_1.BuiltInProcName.Replacement;
+    }
+    return fn?.processor === built_in_1.BuiltInProcName.DefaultReadAllArgs ? built_in_1.BuiltInProcName.Default : fn?.processor;
 }
 //# sourceMappingURL=default-builtin-config.js.map

package/dataflow/environments/reference-to-maybe.d.ts

@@ -11,3 +11,11 @@ export declare function makeReferenceMaybe(ref: IdentifierReference, graph: Data
  * @see {@link makeReferenceMaybe}
  */
 export declare function makeAllMaybe(references: readonly IdentifierReference[] | undefined, graph: DataflowGraph, environments: REnvironmentInformation, includeDefs: boolean, applyCds?: ControlDependency[] | undefined): IdentifierReference[];
+/**
+ * apply the given cds to all elements in the graph and also transform the given references similar to {@link makeAllMaybe}.
+ */
+export declare function applyCdsToAllInGraphButConstants(graph: DataflowGraph, references: readonly IdentifierReference[], cds: readonly ControlDependency[]): void;
+/**
+ * apply the given cds to all given references, but not to the graph. This is useful if we want to mark the references as maybe without marking all other nodes in the graph as maybe.
+ */
+export declare function applyCdToReferences(references: readonly IdentifierReference[], cds: readonly ControlDependency[]): void;

package/dataflow/environments/reference-to-maybe.js

@@ -2,16 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeReferenceMaybe = makeReferenceMaybe;
 exports.makeAllMaybe = makeAllMaybe;
+exports.applyCdsToAllInGraphButConstants = applyCdsToAllInGraphButConstants;
+exports.applyCdToReferences = applyCdToReferences;
 const identifier_1 = require("./identifier");
 const resolve_by_name_1 = require("./resolve-by-name");
+const vertex_1 = require("../graph/vertex");
 function appToCdsUnique(target, toAdd) {
     if (toAdd) {
-        target.push(...toAdd.filter(c => !target.find(tc => tc.id === c.id && tc.when === c.when)));
+        target.push(...toAdd.filter(c => !target.some(tc => tc.id === c.id && tc.when === c.when)));
     }
 }
 function concatCdsUnique(target, toAdd) {
     if (toAdd) {
-        return target.concat(toAdd.filter(c => !target.find(tc => tc.id === c.id && tc.when === c.when)));
+        return target.concat(toAdd.filter(c => !target.some(tc => tc.id === c.id && tc.when === c.when)));
     }
     else {
         return target;
@@ -58,6 +61,46 @@ function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = u
  * @see {@link makeReferenceMaybe}
  */
 function makeAllMaybe(references, graph, environments, includeDefs, applyCds = undefined) {
-    return references?.map(ref => makeReferenceMaybe(ref, graph, environments, includeDefs, applyCds)) ?? [];
+    if (references === undefined || references.length === 0) {
+        return [];
+    }
+    return references.map(ref => makeReferenceMaybe(ref, graph, environments, includeDefs, applyCds));
+}
+/**
+ * apply the given cds to all elements in the graph and also transform the given references similar to {@link makeAllMaybe}.
+ */
+function applyCdsToAllInGraphButConstants(graph, references, cds) {
+    for (const [, v] of graph.vertices(true)) {
+        if (v.tag === vertex_1.VertexType.Value) {
+            continue;
+        }
+        if (v.cds) {
+            appToCdsUnique(v.cds, cds);
+        }
+        else {
+            v.cds = Array.from(cds);
+        }
+    }
+    for (const ref of references) {
+        if (ref.cds) {
+            appToCdsUnique(ref.cds, cds);
+        }
+        else {
+            ref.cds = Array.from(cds);
+        }
+    }
+}
+/**
+ * apply the given cds to all given references, but not to the graph. This is useful if we want to mark the references as maybe without marking all other nodes in the graph as maybe.
+ */
+function applyCdToReferences(references, cds) {
+    for (const ref of references) {
+        if (ref.cds) {
+            appToCdsUnique(ref.cds, cds);
+        }
+        else {
+            ref.cds = Array.from(cds);
+        }
+    }
 }
 //# sourceMappingURL=reference-to-maybe.js.map

package/dataflow/eval/resolve/alias-tracking.d.ts

@@ -58,7 +58,7 @@ export declare function getAliases(sourceIds: readonly NodeId[], dataflow: Dataf
  * @param ctx                - Context used for clean environment
  * @param blocked            - If set, the ids that should not be considered during resolution (=>top)
  */
-export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefined, { environment, graph, idMap, full, resolve, ctx, blocked }: ResolveInfo): ResolveResult;
+export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefined, { environment, graph, idMap, full, ctx, resolve, blocked }: ResolveInfo): ResolveResult;
 /**
  * Please use {@link resolveIdToValue}
  *

package/dataflow/eval/resolve/alias-tracking.js

@@ -119,8 +119,7 @@ function getAliases(sourceIds, dataflow, environment) {
  * @param ctx                - Context used for clean environment
  * @param blocked            - If set, the ids that should not be considered during resolution (=>top)
  */
-function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve, ctx, blocked }) {
-    const variableResolve = resolve ?? ctx.config.solver.variables;
+function resolveIdToValue(id, { environment, graph, idMap, full = true, ctx, resolve = ctx.config.solver.variables, blocked }) {
     blocked ??= new Set();
     if (id === undefined) {
         return r_value_1.Top;
@@ -134,13 +133,13 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve,
     switch (node.type) {
         case type_1.RType.Argument:
             if (node.value) {
-                return resolveIdToValue(node.value.info.id, { environment, graph, idMap, full, resolve: variableResolve, ctx, blocked });
+                return resolveIdToValue(node.value.info.id, { environment, graph, idMap, full, resolve, ctx, blocked });
             }
         // eslint-disable-next-line no-fallthrough
         case type_1.RType.Symbol:
             if (full) {
                 if (environment) {
-                    return trackAliasInEnvironments(identifier_1.Identifier.toString(node.content), environment, { idMap, resolve: variableResolve, ctx, graph, blocked });
+                    return trackAliasInEnvironments(identifier_1.Identifier.toString(node.content), environment, { idMap, resolve, ctx, graph, blocked });
                 }
                 else if (graph && resolve === config_1.VariableResolve.Alias) {
                     return trackAliasesInGraph(node.info.id, graph, ctx, idMap);
@@ -153,7 +152,7 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve,
         case type_1.RType.BinaryOp:
         case type_1.RType.UnaryOp:
             return (0, set_constants_1.setFrom)((0, resolve_1.resolveNode)({
-                resolve: variableResolve, node, ctx, environment, graph, idMap, blocked
+                resolve, node, ctx, environment, graph, idMap, blocked
             }));
         case type_1.RType.String:
         case type_1.RType.Number:

package/dataflow/eval/resolve/resolve.js

@@ -27,19 +27,20 @@ const identifier_1 = require("../../environments/identifier");
  * @returns resolved value or top/bottom
  */
 function resolveNode({ resolve, node, ctx, blocked, environment, graph, idMap }) {
-    if (node.type === type_1.RType.String) {
+    const nt = node.type;
+    if (nt === type_1.RType.String) {
         return (0, string_constants_1.stringFrom)(node.content.str);
     }
-    else if (node.type === type_1.RType.Number) {
+    else if (nt === type_1.RType.Number) {
         return (0, interval_constants_1.intervalFrom)(node.content.num, node.content.num);
     }
-    else if (node.type === type_1.RType.Logical) {
+    else if (nt === type_1.RType.Logical) {
         return node.content.valueOf() ? logical_constants_1.ValueLogicalTrue : logical_constants_1.ValueLogicalFalse;
     }
-    else if (node.type === type_1.RType.FunctionDefinition) {
+    else if (nt === type_1.RType.FunctionDefinition) {
         return { type: 'function-definition' };
     }
-    else if ((node.type === type_1.RType.FunctionCall || node.type === type_1.RType.BinaryOp || node.type === type_1.RType.UnaryOp) && graph) {
+    else if ((nt === type_1.RType.FunctionCall || nt === type_1.RType.BinaryOp || nt === type_1.RType.UnaryOp) && graph) {
         const origin = (0, dfg_get_origin_1.getOriginInDfg)(graph, node.info.id)?.[0];
         if (origin === undefined || origin.type !== 3 /* OriginType.BuiltInFunctionOrigin */) {
             return r_value_2.Top;
@@ -48,10 +49,10 @@ function resolveNode({ resolve, node, ctx, blocked, environment, graph, idMap })
         if ((0, built_in_1.isBuiltIn)(origin.proc)) {
             builtInName = origin.proc;
         }
-        else if (node.type === type_1.RType.FunctionCall && node.named) {
+        else if (nt === type_1.RType.FunctionCall && node.named) {
             builtInName = (0, built_in_1.builtInId)(identifier_1.Identifier.getName(node.functionName.content));
         }
-        else if (node.type === type_1.RType.BinaryOp || node.type === type_1.RType.UnaryOp) {
+        else if (nt === type_1.RType.BinaryOp || nt === type_1.RType.UnaryOp) {
             builtInName = (0, built_in_1.builtInId)(node.operator);
         }
         else {

package/dataflow/graph/graph.d.ts

@@ -88,7 +88,7 @@ export declare const FunctionArgument: {
      * ```
      * @see {@link isNotEmpty}
      */
-    readonly isEmpty: (this: void, arg: FunctionArgument) => arg is typeof EmptyArgument;
+    readonly isEmpty: (this: void, arg: unknown) => arg is typeof EmptyArgument;
     /**
      * Checks whether the given argument is not an empty argument.
      * @see {@link isEmpty}

package/dataflow/graph/graph.js

@@ -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;
     }

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

@@ -12,7 +12,7 @@ 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;
@@ -473,8 +476,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 +494,40 @@ 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 = new Set(exits.flatMap(e => e.cds?.map(info_1.negateControlDependency)).filter(assert_1.isNotUndefined));
+    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)) {
+                if (!ref.cds?.find(c => c.id === cId)) {
                     ref.cds.push({ ...cd, byIteration: true });
+                    setVertex = true;
                 }
             }
             else {
                 ref.cds = [{ ...cd, byIteration: true }];
+                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, byIteration: true });
+                        }
+                    }
+                    else {
+                        vertex.cds = [{ ...cd, byIteration: true }];
+                    }
+                }
             }
         }
     }

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

@@ -5,6 +5,7 @@ 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 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 +31,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) || n?.type === type_1.RType.Argument ? n : toUnnamedArgument(n, idMap));
 }
 //# sourceMappingURL=make-argument.js.map

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-repeat-loop.js

@@ -41,8 +41,8 @@ function processRepeatLoop(name, args, rootId, data) {
     });
     const body = processedArguments[0];
     (0, assert_1.guard)(body !== undefined, () => `Repeat-Loop ${identifier_1.Identifier.toString(name.content)} has no body, impossible!`);
-    (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph, [])), body.out);
-    (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences));
+    (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph)), body.out);
+    (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences), information.graph);
     information.exitPoints = (0, info_1.filterOutLoopExitPoints)(information.exitPoints);
     return information;
 }

package/dataflow/internal/process/functions/call/built-in/built-in-s-seven-new-generic.js

@@ -80,7 +80,7 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
         info: {
             id: argNameId,
             nesting: name.info.nesting,
-            role: "arg-name" /* RoleInParent.ArgumentName */,
+            role: "arg-n" /* RoleInParent.ArgumentName */,
             fullRange: r,
             adToks: undefined,
             file: name.info.file,
@@ -117,7 +117,7 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
         info: {
             id: rootId + '-s7-new-generic-fun-body',
             nesting: name.info.nesting,
-            role: "fun-body" /* RoleInParent.FunctionDefinitionBody */,
+            role: "fun-b" /* RoleInParent.FunctionDefinitionBody */,
             fullRange: r,
             adToks: undefined,
             file: name.info.file,
@@ -132,7 +132,7 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
             file: name.info.file,
             id: fdefId,
             nesting: name.info.nesting,
-            role: "arg-value" /* RoleInParent.ArgumentValue */,
+            role: "arg-v" /* RoleInParent.ArgumentValue */,
             parent: rootId,
             index: args + 1,
             adToks: undefined,
@@ -150,7 +150,7 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
                 info: {
                     id: paramNameId,
                     nesting: name.info.nesting,
-                    role: "param-name" /* RoleInParent.ParameterName */,
+                    role: "param-n" /* RoleInParent.ParameterName */,
                     fullRange: r,
                     adToks: undefined,
                     file: name.info.file,

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

@@ -155,19 +155,30 @@ function processSourceCall(name, args, rootId, data, config) {
     if (sourceFile?.length === 1) {
         const path = (0, retriever_1.removeRQuotes)(sourceFile[0]);
         let filepath = path ? findSource(data.ctx.config.solver.resolveSource, path, data) : path;
-        if (Array.isArray(filepath)) {
-            filepath = filepath?.[0];
+        if (!Array.isArray(filepath)) {
+            filepath = filepath ? [filepath] : undefined;
         }
-        if (filepath !== undefined) {
-            // check if the sourced file has already been dataflow analyzed, and if so, skip it
-            const limit = data.ctx.config.solver.resolveSource?.repeatedSourceLimit ?? 0;
-            const findCount = data.referenceChain.filter(e => e !== undefined && filepath === e).length;
-            if (findCount > limit) {
-                logger_1.dataflowLogger.warn(`Found cycle (>=${limit + 1}) in dataflow analysis for ${JSON.stringify(filepath)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
-                (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
-                return information;
+        if (filepath !== undefined && filepath.length > 0) {
+            let result = information;
+            const origCds = data.cds?.slice() ?? [];
+            for (const f of filepath) {
+                // check if the sourced file has already been dataflow analyzed, and if so, skip it
+                const limit = data.ctx.config.solver.resolveSource?.repeatedSourceLimit ?? 0;
+                const findCount = data.referenceChain.filter(e => e !== undefined && f === e).length;
+                if (findCount > limit) {
+                    logger_1.dataflowLogger.warn(`Found cycle (>=${limit + 1}) in dataflow analysis for ${JSON.stringify(filepath)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
+                    (0, unknown_side_effect_1.handleUnknownSideEffect)(result.graph, result.environment, rootId);
+                    continue;
+                }
+                if (filepath.length > 1) {
+                    data = { ...data, cds: [...origCds, { id: rootId, when: true, file: f }] };
+                }
+                result = sourceRequest(rootId, {
+                    request: 'file',
+                    content: f
+                }, data, result, (0, decorate_1.sourcedDeterministicCountingIdGenerator)((findCount > 0 ? findCount + '::' : '') + f, name.location));
             }
-            return sourceRequest(rootId, { request: 'file', content: filepath }, data, information, (0, decorate_1.sourcedDeterministicCountingIdGenerator)((findCount > 0 ? findCount + '::' : '') + path, name.location));
+            return result;
         }
     }
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Non-constant argument ${JSON.stringify(sourceFile)} for source is currently not supported, skipping`);