@eagleoutice/flowr 2.0.1 → 2.0.2

package/dataflow/environments/diff.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.diffEnvironmentInformation = exports.diffEnvironment = exports.diffIdentifierReferences = void 0;
 const diff_1 = require("../../util/diff");
 const json_1 = require("../../util/json");
-const arrays_1 = require("../../util/arrays");
+const info_1 = require("../info");
 function diffIdentifierReferences(a, b, info) {
     if (a === undefined || b === undefined) {
         if (a !== b) {
@@ -17,9 +17,7 @@ function diffIdentifierReferences(a, b, info) {
     if (a.nodeId !== b.nodeId) {
         info.report.addComment(`${info.position}Different nodeIds: ${info.leftname}: ${a.nodeId} vs. ${info.rightname}: ${b.nodeId}`);
     }
-    if (!(0, arrays_1.arrayEqual)(a.controlDependencies, b.controlDependencies)) {
-        info.report.addComment(`${info.position}Different control dependency: ${info.leftname}: ${JSON.stringify(a.controlDependencies)} vs. ${info.rightname}: ${JSON.stringify(b.controlDependencies)}`);
-    }
+    (0, info_1.diffControlDependencies)(a.controlDependencies, b.controlDependencies, info);
 }
 exports.diffIdentifierReferences = diffIdentifierReferences;
 function diffMemory(a, b, info) {
@@ -41,9 +39,7 @@ function diffMemory(a, b, info) {
             if (aVal.nodeId !== bVal.nodeId) {
                 info.report.addComment(`${info.position}Different ids for ${key}. ${info.leftname}: ${aVal.nodeId} vs. ${info.rightname}: ${bVal.nodeId}`);
             }
-            if (!(0, arrays_1.arrayEqual)(aVal.controlDependencies, bVal.controlDependencies)) {
-                info.report.addComment(`${info.position}Different controlDependency for ${key} (${aVal.nodeId}). ${info.leftname}: ${JSON.stringify(aVal.controlDependencies)} vs. ${info.rightname}: ${JSON.stringify(bVal.controlDependencies)}`);
-            }
+            (0, info_1.diffControlDependencies)(aVal.controlDependencies, bVal.controlDependencies, { ...info, position: `${info.position} For ${key}. ` });
             if (aVal.definedAt !== bVal.definedAt) {
                 info.report.addComment(`${info.position}Different definition ids (definedAt) for ${key} (${aVal.nodeId}). ${info.leftname}: ${aVal.definedAt} vs. ${info.rightname}: ${bVal.definedAt}`);
             }
@@ -53,33 +49,35 @@ function diffMemory(a, b, info) {
         }
     }
 }
-function diffEnvironment(a, b, info) {
+function diffEnvironment(a, b, info, depth) {
     if (a === undefined || b === undefined) {
         if (a !== b) {
-            info.report.addComment(`${info.position}Different environments. ${info.leftname}: ${a !== undefined ? 'present' : 'undefined'} vs. ${info.rightname}: ${b !== undefined ? 'present' : 'undefined'}`);
+            info.report.addComment(`${info.position}[at level: ${depth}] Different environments. ${info.leftname}: ${a !== undefined ? 'present' : 'undefined'} vs. ${info.rightname}: ${b !== undefined ? 'present' : 'undefined'}`);
         }
         return;
     }
-    if (a.name !== b.name) {
-        info.report.addComment(`${info.position}Different environment names. ${info.leftname}: ${a.name}  vs. ${info.rightname}: ${b.name}`);
-    }
     if (a.memory.size !== b.memory.size) {
-        info.report.addComment(`${info.position}Different environment sizes. ${info.leftname}: ${a.memory.size} vs. ${info.rightname}: ${b.memory.size}`);
+        info.report.addComment(`${info.position}[at level: ${depth}] Different number of definitions in environment. ${info.leftname}: ${a.memory.size} vs. ${info.rightname}: ${b.memory.size}`);
         (0, diff_1.setDifference)(new Set([...a.memory.keys()]), new Set([...b.memory.keys()]), {
             ...info,
-            position: `${info.position}Key comparison. `
+            position: `${info.position}[at level: ${depth}] Key comparison. `
         });
     }
-    diffMemory(a, b, info);
-    diffEnvironment(a.parent, b.parent, { ...info, position: `${info.position}Parents of ${a.id} & ${b.id}. ` });
+    diffMemory(a, b, { ...info, position: `${info.position}[at level: ${depth}] ` });
+    diffEnvironment(a.parent, b.parent, { ...info, position: `${info.position}Parents of ${a.id} & ${b.id}. ` }, depth--);
 }
 exports.diffEnvironment = diffEnvironment;
 function diffEnvironmentInformation(a, b, info) {
     if (a === undefined || b === undefined) {
-        info.report.addComment(`${info.position}Different environments: ${JSON.stringify(a, json_1.jsonReplacer)} vs. ${JSON.stringify(b, json_1.jsonReplacer)}`);
+        if (a !== b) {
+            info.report.addComment(`${info.position}Different environments: ${JSON.stringify(a, json_1.jsonReplacer)} vs. ${JSON.stringify(b, json_1.jsonReplacer)}`);
+        }
         return;
     }
-    diffEnvironment(a.current, b.current, info);
+    if (a.level !== b.level) {
+        info.report.addComment(`${info.position}Different environment levels: ${info.leftname}: ${a.level} vs. ${info.rightname}: ${b.level}. Using max to report level for further errors.`);
+    }
+    diffEnvironment(a.current, b.current, info, Math.max(a.level, b.level));
 }
 exports.diffEnvironmentInformation = diffEnvironmentInformation;
 //# sourceMappingURL=diff.js.map

package/dataflow/environments/environment.d.ts

@@ -6,13 +6,12 @@
  */
 import type { Identifier, IdentifierDefinition, IdentifierReference } from './identifier';
 import type { DataflowGraph } from '../graph/graph';
-import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-export declare function makeReferenceMaybe(ref: IdentifierReference, graph: DataflowGraph, environments: REnvironmentInformation, includeDefs: boolean, defaultCd?: NodeId | undefined): IdentifierReference;
-export declare function makeAllMaybe(references: readonly IdentifierReference[] | undefined, graph: DataflowGraph, environments: REnvironmentInformation, includeDefs: boolean, defaultCd?: NodeId | undefined): IdentifierReference[];
+import type { ControlDependency } from '../info';
+export declare function makeReferenceMaybe(ref: IdentifierReference, graph: DataflowGraph, environments: REnvironmentInformation, includeDefs: boolean, defaultCd?: ControlDependency | undefined): IdentifierReference;
+export declare function makeAllMaybe(references: readonly IdentifierReference[] | undefined, graph: DataflowGraph, environments: REnvironmentInformation, includeDefs: boolean, defaultCd?: ControlDependency | undefined): IdentifierReference[];
 export interface IEnvironment {
     /** unique and internally generated identifier -- will not be used for comparison but assists debugging for tracking identities */
     readonly id: string;
-    readonly name: string;
     /** Lexical parent of the environment, if any (can be manipulated by R code) */
     parent: IEnvironment;
     /**
@@ -21,11 +20,10 @@ export interface IEnvironment {
     memory: Map<Identifier, IdentifierDefinition[]>;
 }
 export declare class Environment implements IEnvironment {
-    readonly name: string;
     readonly id: string;
     parent: IEnvironment;
     memory: Map<Identifier, IdentifierDefinition[]>;
-    constructor(name: string, parent: IEnvironment);
+    constructor(parent: IEnvironment);
 }
 /**
  * First of all, yes, R stores its environments differently, potentially even with a different differentiation between
@@ -41,5 +39,4 @@ export interface REnvironmentInformation {
     readonly level: number;
 }
 export declare const BuiltInEnvironment: Environment;
-export declare const GLOBAL_ENV_NAME = "global";
 export declare function initializeCleanEnvironments(): REnvironmentInformation;

package/dataflow/environments/environment.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeCleanEnvironments = exports.GLOBAL_ENV_NAME = exports.BuiltInEnvironment = exports.Environment = exports.makeAllMaybe = exports.makeReferenceMaybe = void 0;
+exports.initializeCleanEnvironments = exports.BuiltInEnvironment = exports.Environment = exports.makeAllMaybe = exports.makeReferenceMaybe = void 0;
 const built_in_1 = require("./built-in");
 const resolve_by_name_1 = require("./resolve-by-name");
 function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = undefined) {
@@ -9,7 +9,7 @@ function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = u
         const definitions = ref.name ? (0, resolve_by_name_1.resolveByName)(ref.name, environments) : undefined;
         for (const definition of definitions ?? []) {
             if (definition.kind !== 'built-in-function' && definition.kind !== 'built-in-value') {
-                if (definition.controlDependencies && defaultCd && !definition.controlDependencies.includes(defaultCd)) {
+                if (definition.controlDependencies && defaultCd && !definition.controlDependencies.find(c => c.id === defaultCd.id)) {
                     definition.controlDependencies.push(defaultCd);
                 }
                 else {
@@ -38,24 +38,21 @@ function makeAllMaybe(references, graph, environments, includeDefs, defaultCd =
 exports.makeAllMaybe = makeAllMaybe;
 let environmentIdCounter = 0;
 class Environment {
-    name;
     id = `${environmentIdCounter++}`;
     parent;
     memory;
-    constructor(name, parent) {
-        this.name = name;
+    constructor(parent) {
         this.parent = parent;
         this.memory = new Map();
     }
 }
 exports.Environment = Environment;
 /* the built-in environment is the root of all environments */
-exports.BuiltInEnvironment = new Environment('built-in', undefined);
+exports.BuiltInEnvironment = new Environment(undefined);
 exports.BuiltInEnvironment.memory = built_in_1.BuiltInMemory;
-exports.GLOBAL_ENV_NAME = 'global';
 function initializeCleanEnvironments() {
     return {
-        current: new Environment(exports.GLOBAL_ENV_NAME, exports.BuiltInEnvironment),
+        current: new Environment(exports.BuiltInEnvironment),
         level: 0
     };
 }

package/dataflow/environments/identifier.d.ts

@@ -1,5 +1,6 @@
 import type { BuiltInIdentifierConstant, BuiltInIdentifierDefinition } from './built-in';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { ControlDependency } from '../info';
 export type Identifier = string & {
     __brand?: 'identifier';
 };
@@ -26,6 +27,6 @@ export interface IdentifierReference {
      * If the reference is only effective if, e.g. an if-then-else condition is true, this references the root of the `if`.
      * As a hackey intermediate solution (until we have pointer-analysis), an empty array may indicate a `maybe` which is due to pointer access (e.g., in `a[x] <- 3`).
      */
-    controlDependencies: NodeId[] | undefined;
+    controlDependencies: ControlDependency[] | undefined;
 }
 export {};

package/dataflow/environments/overwrite.js

@@ -16,7 +16,6 @@ function anyIsMaybeOrEmpty(values) {
 }
 function overwriteIEnvironmentWith(base, next, includeParent = true) {
     (0, assert_1.guard)(base !== undefined && next !== undefined, 'can not overwrite environments with undefined');
-    (0, assert_1.guard)(base.name === next.name, 'cannot overwrite environments with different names');
     const map = new Map(base.memory);
     for (const [key, values] of next.memory) {
         const hasMaybe = anyIsMaybeOrEmpty(values);
@@ -43,7 +42,7 @@ function overwriteIEnvironmentWith(base, next, includeParent = true) {
     else {
         parent = base.parent;
     }
-    const out = new environment_1.Environment(base.name, parent);
+    const out = new environment_1.Environment(parent);
     out.memory = map;
     return out;
 }

package/dataflow/environments/scoping.js

@@ -6,7 +6,7 @@ const assert_1 = require("../../util/assert");
 /** Add a new local environment scope to the stack, returns the modified variant - sharing the original environments in the stack (no deep-clone) */
 function pushLocalEnvironment(base) {
     return {
-        current: new environment_1.Environment('local', base.current),
+        current: new environment_1.Environment(base.current),
         level: base.level + 1
     };
 }

package/dataflow/graph/diff.js

@@ -9,6 +9,7 @@ const edge_1 = require("./edge");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const diff_2 = require("../environments/diff");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const info_1 = require("../info");
 class DataflowDifferenceReport {
     _comments = undefined;
     _problematic = undefined;
@@ -62,10 +63,18 @@ function diffOutgoingEdges(ctx) {
         ctx.report.addComment(`Detected different number of edges! ${ctx.leftname} has ${lEdges.size} (${JSON.stringify(lEdges, json_1.jsonReplacer)}). ${ctx.rightname} has ${rEdges.size} ${JSON.stringify(rEdges, json_1.jsonReplacer)}`);
     }
     for (const [id, edge] of lEdges) {
+        if (!ctx.left.hasVertex(id)) {
+            ctx.report.addComment(`The source ${id} of edges ${JSON.stringify(edge, json_1.jsonReplacer)} is not present in ${ctx.leftname}. This means that the graph contains an edge but not the corresponding vertex.`);
+            continue;
+        }
         diffEdges(ctx, id, edge, rEdges.get(id));
     }
     // just to make it both ways in case the length differs
     for (const [id, edge] of rEdges) {
+        if (!ctx.right.hasVertex(id)) {
+            ctx.report.addComment(`The source ${id} of edges ${JSON.stringify(edge, json_1.jsonReplacer)} is not present in ${ctx.rightname}. This means that the graph contains an edge but not the corresponding vertex.`);
+            continue;
+        }
         if (!lEdges.has(id)) {
             diffEdges(ctx, id, undefined, edge);
         }
@@ -137,9 +146,7 @@ function diffFunctionArguments(fn, a, b, ctx) {
             if (aArg.name !== bArg.name) {
                 ctx.report.addComment(`${ctx.position}In argument #${i} (of ${ctx.leftname}, unnamed) the name differs: ${aArg.name} vs ${bArg.name}.`);
             }
-            if (!(0, arrays_1.arrayEqual)(aArg.controlDependencies, bArg.controlDependencies)) {
-                ctx.report.addComment(`${ctx.position}In argument #${i} (of ${ctx.leftname}, unnamed) the control dependency differs: ${JSON.stringify(aArg.controlDependencies)} vs ${JSON.stringify(bArg.controlDependencies)}.`, { tag: 'vertex', id: fn });
-            }
+            (0, info_1.diffControlDependencies)(aArg.controlDependencies, bArg.controlDependencies, { ...ctx, position: `${ctx.position}In argument #${i} (of ${ctx.leftname}, unnamed) the control dependency differs: ${JSON.stringify(aArg.controlDependencies)} vs ${JSON.stringify(bArg.controlDependencies)}.` });
         }
     }
 }
@@ -173,9 +180,7 @@ function diffVertices(ctx) {
                 });
             }
         }
-        if (!(0, arrays_1.arrayEqual)(lInfo.controlDependencies, rInfo.controlDependencies)) {
-            ctx.report.addComment(`Vertex ${id} differs in controlDependency. ${ctx.leftname}: ${JSON.stringify(lInfo.controlDependencies)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.controlDependencies)}`, { tag: 'vertex', id });
-        }
+        (0, info_1.diffControlDependencies)(lInfo.controlDependencies, rInfo.controlDependencies, { ...ctx, position: `Vertex ${id} differs in controlDependencies. ` });
         (0, diff_2.diffEnvironmentInformation)(lInfo.environment, rInfo.environment, { ...ctx, position: `${ctx.position}Vertex ${id} differs in environment. ` });
         if (lInfo.tag === "function-call" /* VertexType.FunctionCall */) {
             if (rInfo.tag !== "function-call" /* VertexType.FunctionCall */) {

package/dataflow/graph/graph.d.ts

@@ -46,7 +46,7 @@ type EdgeData<Edge extends DataflowGraphEdge> = Omit<Edge, 'from' | 'to' | 'type
  */
 export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = DataflowGraphVertexInfo, Edge extends DataflowGraphEdge = DataflowGraphEdge> {
     private static DEFAULT_ENVIRONMENT;
-    readonly idMap: AstIdMap | undefined;
+    private _idMap;
     constructor(idMap: AstIdMap | undefined);
     /** Contains the vertices of the root level graph (i.e., included those vertices from the complete graph, that are nested within function definitions) */
     private rootVertices;
@@ -76,6 +76,10 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     getVertex(id: NodeId, includeDefinedFunctions?: boolean): Vertex | undefined;
     outgoingEdges(id: NodeId): OutgoingEdges | undefined;
     ingoingEdges(id: NodeId): IngoingEdges | undefined;
+    /** Retrieves the id-map to the normalized AST attached to the dataflow graph */
+    get idMap(): AstIdMap | undefined;
+    /** Allows setting the id-map explicitly (which should only be used when, e.g., you plan to compare two dataflow graphs on the same AST-basis) */
+    setIdMap(idMap: AstIdMap): void;
     /**
    * @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
@@ -95,7 +99,7 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
      * @param id                      - The id to check for
      * @param includeDefinedFunctions - If true this will check function definitions as well and not just the toplevel
      */
-    hasVertex(id: NodeId, includeDefinedFunctions: boolean): boolean;
+    hasVertex(id: NodeId, includeDefinedFunctions?: boolean): boolean;
     /**
      * Returns true if the root level of the graph contains a node with the given id.
      */

package/dataflow/graph/graph.js

@@ -40,10 +40,10 @@ function extractEdgeIds(from, to) {
  */
 class DataflowGraph {
     static DEFAULT_ENVIRONMENT = undefined;
-    idMap;
+    _idMap;
     constructor(idMap) {
         DataflowGraph.DEFAULT_ENVIRONMENT ??= (0, environment_1.initializeCleanEnvironments)();
-        this.idMap = idMap;
+        this._idMap = idMap;
     }
     /** Contains the vertices of the root level graph (i.e., included those vertices from the complete graph, that are nested within function definitions) */
     rootVertices = new Set();
@@ -89,6 +89,14 @@ class DataflowGraph {
         }
         return edges;
     }
+    /** Retrieves the id-map to the normalized AST attached to the dataflow graph */
+    get idMap() {
+        return this._idMap;
+    }
+    /** Allows setting the id-map explicitly (which should only be used when, e.g., you plan to compare two dataflow graphs on the same AST-basis) */
+    setIdMap(idMap) {
+        this._idMap = idMap;
+    }
     /**
    * @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
@@ -119,7 +127,7 @@ class DataflowGraph {
      * @param id                      - The id to check for
      * @param includeDefinedFunctions - If true this will check function definitions as well and not just the toplevel
      */
-    hasVertex(id, includeDefinedFunctions) {
+    hasVertex(id, includeDefinedFunctions = true) {
         return includeDefinedFunctions ? this.vertexInformation.has(id) : this.rootVertices.has(id);
     }
     /**
@@ -146,8 +154,9 @@ class DataflowGraph {
         if (oldVertex !== undefined) {
             return this;
         }
+        const fallback = vertex.tag === "variable-definition" /* VertexType.VariableDefinition */ || vertex.tag === "use" /* VertexType.Use */ || vertex.tag === "value" /* VertexType.Value */ ? undefined : DataflowGraph.DEFAULT_ENVIRONMENT;
         // keep a clone of the original environment
-        const environment = vertex.environment === undefined ? DataflowGraph.DEFAULT_ENVIRONMENT : (0, clone_1.cloneEnvironmentInformation)(vertex.environment);
+        const environment = vertex.environment === undefined ? fallback : (0, clone_1.cloneEnvironmentInformation)(vertex.environment);
         this.vertexInformation.set(vertex.id, {
             ...vertex,
             when: vertex.controlDependencies ?? 'always',
@@ -263,9 +272,6 @@ class DataflowGraph {
         const vertex = this.getVertex(reference.nodeId, true);
         (0, assert_1.guard)(vertex !== undefined, () => `node must be defined for ${JSON.stringify(reference)} to set reference`);
         if (vertex.tag === "function-definition" /* VertexType.FunctionDefinition */ || vertex.tag === "variable-definition" /* VertexType.VariableDefinition */) {
-            (0, assert_1.guard)(vertex.controlDependencies !== undefined
-                || reference.controlDependencies !== undefined
-                || (0, arrays_1.arrayEqual)(vertex.controlDependencies, reference.controlDependencies), () => `node ${JSON.stringify(vertex)} must not be previously defined at position or have same scope for ${JSON.stringify(reference)}`);
             vertex.controlDependencies = reference.controlDependencies;
         }
         else {

package/dataflow/graph/vertex.d.ts

@@ -2,6 +2,7 @@ import type { MergeableRecord } from '../../util/objects';
 import type { DataflowFunctionFlowInformation, FunctionArgument } from './graph';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { REnvironmentInformation } from '../environments/environment';
+import type { ControlDependency } from '../info';
 export type DataflowGraphVertices<Vertex extends DataflowGraphVertexInfo = DataflowGraphVertexInfo> = Map<NodeId, Vertex>;
 export declare const enum VertexType {
     Value = "value",
@@ -33,7 +34,7 @@ interface DataflowGraphVertexBase extends MergeableRecord {
     /**
      * See {@link IdentifierReference}
      */
-    controlDependencies: NodeId[] | undefined;
+    controlDependencies: ControlDependency[] | undefined;
 }
 export interface DataflowGraphValue extends DataflowGraphVertexBase {
     readonly tag: VertexType.Value;

package/dataflow/info.d.ts

@@ -3,16 +3,22 @@ import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { IdentifierReference } from './environments/identifier';
 import type { REnvironmentInformation } from './environments/environment';
 import { DataflowGraph } from './graph/graph';
+import type { GenericDifferenceInformation, WriteableDifferenceReport } from '../util/diff';
 export declare const enum ExitPointType {
     Default = 0,
     Return = 1,
     Break = 2,
     Next = 3
 }
+export interface ControlDependency {
+    readonly id: NodeId;
+    /** when does this control dependency trigger (if the condition is true or false)? */
+    readonly when?: boolean;
+}
 export interface ExitPoint {
     readonly type: ExitPointType;
     readonly nodeId: NodeId;
-    readonly controlDependencies: NodeId[] | undefined;
+    readonly controlDependencies: ControlDependency[] | undefined;
 }
 export declare function addNonDefaultExitPoints(existing: ExitPoint[], add: readonly ExitPoint[]): void;
 /**
@@ -45,5 +51,8 @@ export interface DataflowInformation extends DataflowCfgInformation {
     graph: DataflowGraph;
 }
 export declare function initializeCleanDataflowInformation<T>(entryPoint: NodeId, data: Pick<DataflowProcessorInformation<T>, 'environment' | 'completeAst'>): DataflowInformation;
+export declare function happensInEveryBranch(controlDependencies: ControlDependency[] | undefined): boolean;
 export declare function alwaysExits(data: DataflowInformation): boolean;
 export declare function filterOutLoopExitPoints(exitPoints: readonly ExitPoint[]): readonly ExitPoint[];
+export declare function diffControlDependency<Report extends WriteableDifferenceReport>(a: ControlDependency | undefined, b: ControlDependency | undefined, info: GenericDifferenceInformation<Report>): void;
+export declare function diffControlDependencies<Report extends WriteableDifferenceReport>(a: ControlDependency[] | undefined, b: ControlDependency[] | undefined, info: GenericDifferenceInformation<Report>): void;

package/dataflow/info.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterOutLoopExitPoints = exports.alwaysExits = exports.initializeCleanDataflowInformation = exports.addNonDefaultExitPoints = void 0;
+exports.diffControlDependencies = exports.diffControlDependency = exports.filterOutLoopExitPoints = exports.alwaysExits = exports.happensInEveryBranch = exports.initializeCleanDataflowInformation = exports.addNonDefaultExitPoints = void 0;
 const graph_1 = require("./graph/graph");
 function addNonDefaultExitPoints(existing, add) {
     existing.push(...add.filter(({ type }) => type !== 0 /* ExitPointType.Default */));
@@ -18,12 +18,64 @@ function initializeCleanDataflowInformation(entryPoint, data) {
     };
 }
 exports.initializeCleanDataflowInformation = initializeCleanDataflowInformation;
+function happensInEveryBranch(controlDependencies) {
+    if (controlDependencies === undefined) {
+        /* the cds are unconstrained */
+        return true;
+    }
+    else if (controlDependencies.length === 0) {
+        /* this happens only when we have no idea and require more analysis */
+        return false;
+    }
+    const trues = [];
+    const falseSet = new Set();
+    for (const { id, when } of controlDependencies) {
+        if (when) {
+            trues.push(id);
+        }
+        else {
+            falseSet.add(id);
+        }
+    }
+    return trues.every(id => falseSet.has(id));
+}
+exports.happensInEveryBranch = happensInEveryBranch;
 function alwaysExits(data) {
-    return data.exitPoints?.some(e => e.type !== 0 /* ExitPointType.Default */ && e.controlDependencies === undefined) ?? false;
+    return data.exitPoints?.some(e => e.type !== 0 /* ExitPointType.Default */ && happensInEveryBranch(e.controlDependencies)) ?? false;
 }
 exports.alwaysExits = alwaysExits;
 function filterOutLoopExitPoints(exitPoints) {
     return exitPoints.filter(({ type }) => type === 1 /* ExitPointType.Return */ || type === 0 /* ExitPointType.Default */);
 }
 exports.filterOutLoopExitPoints = filterOutLoopExitPoints;
+function diffControlDependency(a, b, info) {
+    if (a === undefined || b === undefined) {
+        if (a !== b) {
+            info.report.addComment(`${info.position}Different control dependencies. ${info.leftname}: ${JSON.stringify(a)} vs. ${info.rightname}: ${JSON.stringify(b)}`);
+        }
+        return;
+    }
+    if (a.id !== b.id) {
+        info.report.addComment(`${info.position}Different control dependency ids. ${info.leftname}: ${a.id} vs. ${info.rightname}: ${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}`);
+    }
+}
+exports.diffControlDependency = diffControlDependency;
+function diffControlDependencies(a, b, info) {
+    if (a === undefined || b === undefined) {
+        if (a !== b) {
+            info.report.addComment(`${info.position}Different control dependencies: ${JSON.stringify(a)} vs. ${JSON.stringify(b)}`);
+        }
+        return;
+    }
+    if (a.length !== b.length) {
+        info.report.addComment(`${info.position}Different control dependency lengths: ${a.length} vs. ${b.length}`);
+    }
+    for (let i = 0; i < a.length; ++i) {
+        diffControlDependency(a[i], b[i], { ...info, position: `${info.position}Control dependency at index: ${i}: ` });
+    }
+}
+exports.diffControlDependencies = diffControlDependencies;
 //# sourceMappingURL=info.js.map

package/dataflow/internal/linker.d.ts

@@ -17,7 +17,7 @@ export declare function linkFunctionCalls(graph: DataflowGraph, idMap: AstIdMap,
     functionCall: NodeId;
     called: readonly DataflowGraphVertexInfo[];
 }[];
-export declare function getAllLinkedFunctionDefinitions(functionDefinitionReadIds: Set<NodeId>, dataflowGraph: DataflowGraph): Map<NodeId, DataflowGraphVertexInfo>;
+export declare function getAllLinkedFunctionDefinitions(functionDefinitionReadIds: ReadonlySet<NodeId>, dataflowGraph: DataflowGraph): Map<NodeId, DataflowGraphVertexInfo>;
 /**
  * This method links a set of read variables to definitions in an environment.
  *

package/dataflow/internal/linker.js

@@ -136,9 +136,8 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
     const result = new Map();
     while (potential.length > 0) {
         const currentId = potential.pop();
+        // do not traverse builtins
         if (currentId === built_in_1.BuiltIn) {
-            // do not traverse builtins
-            static_slicer_1.slicerLogger.trace('skipping builtin function definition during collection');
             continue;
         }
         const currentInfo = dataflowGraph.get(currentId, true);

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

@@ -39,7 +39,7 @@ args, rootId, data, config) {
     }
     const effectiveArgs = getEffectiveOrder(config, args);
     const { target, source } = extractSourceAndTarget(effectiveArgs, name);
-    const { type, flavor } = target;
+    const { type, named } = target;
     if (type === "RSymbol" /* RType.Symbol */) {
         const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, reverseOrder: !config.swapSourceAndTarget });
         return processAssignmentToSymbol({
@@ -53,7 +53,7 @@ args, rootId, data, config) {
             information: res.information,
         });
     }
-    else if (config.canBeReplacement && type === "RFunctionCall" /* RType.FunctionCall */ && flavor === 'named') {
+    else if (config.canBeReplacement && type === "RFunctionCall" /* RType.FunctionCall */ && named) {
         /* as replacement functions take precedence over the lhs fn-call (i.e., `names(x) <- ...` is independent from the definition of `names`), we do not have to process the call */
         logger_1.dataflowLogger.debug(`Assignment ${name.content} has a function call as target => replacement function ${target.lexeme}`);
         const replacement = toReplacementSymbol(target, target.functionName.content, config.superAssignment ?? false);
@@ -132,7 +132,7 @@ function processAssignmentToSymbol({ name, source, args: [targetArg, sourceArg],
     }
     // we drop the first arg which we use to pass along arguments :D
     const readFromSourceWritten = sourceArg.out.slice(1);
-    const readTargets = [{ nodeId: name.info.id, name: name.content, controlDependencies: data.controlDependencies }, ...sourceArg.unknownReferences, ...sourceArg.in, ...targetArg.in.filter(i => i.nodeId !== target.info.id), ...readFromSourceWritten];
+    const readTargets = [{ nodeId: rootId, name: name.content, controlDependencies: data.controlDependencies }, ...sourceArg.unknownReferences, ...sourceArg.in, ...targetArg.in.filter(i => i.nodeId !== target.info.id), ...readFromSourceWritten];
     const writeTargets = [...writeNodes, ...writeNodes, ...readFromSourceWritten];
     information.environment = (0, overwrite_1.overwriteEnvironment)(targetArg.environment, sourceArg.environment);
     // install assigned variables in environment
@@ -152,14 +152,14 @@ function processAssignmentToSymbol({ name, source, args: [targetArg, sourceArg],
             }
         }
     }
-    information.graph.addEdge(name.info.id, targetArg.entryPoint, { type: 8 /* EdgeType.Returns */ });
+    information.graph.addEdge(rootId, targetArg.entryPoint, { type: 8 /* EdgeType.Returns */ });
     if (quoteSource) {
         information.graph.addEdge(rootId, source.info.id, { type: 256 /* EdgeType.NonStandardEvaluation */ });
     }
     return {
         ...information,
         unknownReferences: [],
-        entryPoint: name.info.id,
+        entryPoint: rootId,
         in: readTargets,
         out: writeTargets
     };

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

@@ -29,7 +29,7 @@ function processForLoop(name, args, rootId, data) {
     const variable = (0, processor_1.processDataflowFor)(variableArg, data);
     // this should not be able to exit always!
     const originalDependency = data.controlDependencies;
-    data = { ...data, controlDependencies: [...data.controlDependencies ?? [], name.info.id] };
+    data = { ...data, controlDependencies: [...data.controlDependencies ?? [], { id: name.info.id, when: true }] };
     let headEnvironments = (0, overwrite_1.overwriteEnvironment)(vector.environment, variable.environment);
     const headGraph = variable.graph.mergeWith(vector.graph);
     const writtenVariable = [...variable.unknownReferences, ...variable.in];

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

@@ -13,6 +13,7 @@ const overwrite_1 = require("../../../../../environments/overwrite");
 const scoping_1 = require("../../../../../environments/scoping");
 const environment_1 = require("../../../../../environments/environment");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
+const log_1 = require("../../../../../../util/log");
 function processFunctionDefinition(name, args, rootId, data) {
     if (args.length < 1) {
         logger_1.dataflowLogger.warn(`Function Definition ${name.content} does not have an argument, skipping`);
@@ -53,7 +54,7 @@ function processFunctionDefinition(name, args, rootId, data) {
                 tag: "use" /* VertexType.Use */,
                 id: read.nodeId,
                 environment: undefined,
-                controlDependencies: []
+                controlDependencies: undefined
             });
         }
     }
@@ -65,8 +66,8 @@ function processFunctionDefinition(name, args, rootId, data) {
         graph: new Set(subgraph.rootIds()),
         environment: outEnvironment
     };
+    updateNestedFunctionClosures(subgraph, outEnvironment, name);
     const exitPoints = body.exitPoints;
-    updateNestedFunctionClosures(exitPoints, subgraph, outEnvironment, name);
     const graph = new graph_1.DataflowGraph(data.completeAst.idMap).mergeWith(subgraph, false);
     graph.addVertex({
         tag: "function-definition" /* VertexType.FunctionDefinition */,
@@ -88,33 +89,28 @@ function processFunctionDefinition(name, args, rootId, data) {
     };
 }
 exports.processFunctionDefinition = processFunctionDefinition;
-function updateNestedFunctionClosures(exitPoints, subgraph, outEnvironment, name) {
-    // track *all* function definitions - including those nested within the current graph
+function updateNestedFunctionClosures(subgraph, outEnvironment, name) {
+    // track *all* function definitions - including those nested within the current graph,
     // try to resolve their 'in' by only using the lowest scope which will be popped after this definition
-    for (const [id, info] of subgraph.vertices(true)) {
-        if (info.tag !== "function-definition" /* VertexType.FunctionDefinition */) {
+    for (const [id, { subflow, tag }] of subgraph.vertices(true)) {
+        if (tag !== "function-definition" /* VertexType.FunctionDefinition */) {
             continue;
         }
-        const ingoingRefs = info.subflow.in;
-        const remainingIn = new Set();
+        const ingoingRefs = subflow.in;
+        const remainingIn = [];
         for (const ingoing of ingoingRefs) {
-            for (const { nodeId } of exitPoints) {
-                const node = subgraph.getVertex(nodeId, true);
-                const env = (0, environment_1.initializeCleanEnvironments)();
-                env.current.memory = node === undefined ? outEnvironment.current.memory : (node.environment?.current.memory ?? outEnvironment.current.memory);
-                const resolved = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, env) : undefined;
-                if (resolved === undefined) {
-                    remainingIn.add(ingoing);
-                    continue;
-                }
-                logger_1.dataflowLogger.trace(`Found ${resolved.length} references to open ref ${id} in closure of function definition ${name.info.id}`);
-                for (const ref of resolved) {
-                    subgraph.addEdge(ingoing, ref, { type: 1 /* EdgeType.Reads */ });
-                }
+            const resolved = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, outEnvironment) : undefined;
+            if (resolved === undefined) {
+                remainingIn.push(ingoing);
+                continue;
+            }
+            (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Found ${resolved.length} references to open ref ${id} in closure of function definition ${name.info.id}`);
+            for (const ref of resolved) {
+                subgraph.addEdge(ingoing, ref, { type: 1 /* EdgeType.Reads */ });
             }
         }
-        logger_1.dataflowLogger.trace(`Keeping ${remainingIn.size} (unique) references to open ref ${id} in closure of function definition ${name.info.id}`);
-        info.subflow.in = [...remainingIn];
+        (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Keeping ${remainingIn.length} references to open ref ${id} in closure of function definition ${name.info.id}`);
+        subflow.in = remainingIn;
     }
 }
 function prepareFunctionEnvironment(data) {
@@ -127,11 +123,11 @@ function prepareFunctionEnvironment(data) {
 /**
  * Within something like `f <- function(a=b, m=3) { b <- 1; a; b <- 5; a + 1 }`
  * `a` will be defined by `b` and `b`will be a promise object bound by the first definition of b it can find.
- * This means, that this function returns `2` due to the first `b <- 1` definition.
+ * This means that this function returns `2` due to the first `b <- 1` definition.
  * If the code is `f <- function(a=b, m=3) { if(m > 3) { b <- 1; }; a; b <- 5; a + 1 }`, we need a link to `b <- 1` and `b <- 6`
  * as `b` can be defined by either one of them.
  * <p>
- * <b>Currently we may be unable to narrow down every definition within the body as we have not implemented ways to track what covers a first definitions</b>
+ * <b>Currently we may be unable to narrow down every definition within the body as we have not implemented ways to track what covers the first definitions precisely</b>
  */
 function findPromiseLinkagesForParameters(parameters, readInParameters, parameterEnvs, body) {
     // first, we try to bind again within parameters - if we have it, fine