@eagleoutice/flowr 2.0.1 → 2.0.3

package/cli/slicer-app.js

@@ -40,7 +40,7 @@ async function getSlice() {
             reconstruct = reconstructedCode;
             if (options.output) {
                 console.log('Written reconstructed code to', options.output);
-                console.log(`Automatically selected ${reconstructedCode.autoSelected} statements`);
+                console.log(`Automatically selected ${reconstructedCode.linesWithAutoSelected} lines`);
                 fs_1.default.writeFileSync(options.output, reconstructedCode.code);
             }
             else if (!options.api && !options.diff) {

package/dataflow/environments/append.js

@@ -15,7 +15,6 @@ function uniqueMergeValues(old, value) {
 }
 function appendIEnvironmentWith(base, next) {
     (0, assert_1.guard)(base !== undefined && next !== undefined, 'can not append 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, value] of next.memory) {
         const old = map.get(key);
@@ -27,7 +26,7 @@ function appendIEnvironmentWith(base, next) {
         }
     }
     const parent = base.parent === environment_1.BuiltInEnvironment ? environment_1.BuiltInEnvironment : appendIEnvironmentWith(base.parent, next.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/built-in.js

@@ -111,7 +111,8 @@ registerBuiltInFunctions(['delayedAssign'], built_in_assignment_1.processAssignm
 registerBuiltInFunctions(['<<-'], built_in_assignment_1.processAssignment, { superAssignment: true, canBeReplacement: true });
 registerBuiltInFunctions(['->'], built_in_assignment_1.processAssignment, { swapSourceAndTarget: true, canBeReplacement: true });
 registerBuiltInFunctions(['->>'], built_in_assignment_1.processAssignment, { superAssignment: true, swapSourceAndTarget: true, canBeReplacement: true });
-registerBuiltInFunctions(['&&', '||', '&', '|'], built_in_logical_bin_op_1.processSpecialBinOp, { lazy: true });
+registerBuiltInFunctions(['&&', '&'], built_in_logical_bin_op_1.processSpecialBinOp, { lazy: true, evalRhsWhen: true });
+registerBuiltInFunctions(['||', '|'], built_in_logical_bin_op_1.processSpecialBinOp, { lazy: true, evalRhsWhen: false });
 registerBuiltInFunctions(['|>', '%>%'], built_in_pipe_1.processPipe, {});
 registerBuiltInFunctions(['function', '\\'], built_in_function_definition_1.processFunctionDefinition, {});
 registerBuiltInFunctions(['quote', 'substitute', 'bquote'], built_in_quote_1.processQuote, { quoteArgumentsWithIndex: 0 });

package/dataflow/environments/clone.js

@@ -9,7 +9,7 @@ function cloneEnvironment(environment, recurseParents) {
     else if (environment.id === environment_1.BuiltInEnvironment.id) {
         return environment_1.BuiltInEnvironment;
     }
-    const clone = new environment_1.Environment(environment.name, recurseParents ? cloneEnvironment(environment.parent, recurseParents) : environment.parent);
+    const clone = new environment_1.Environment(recurseParents ? cloneEnvironment(environment.parent, recurseParents) : environment.parent);
     clone.memory = new Map(JSON.parse(JSON.stringify([...environment.memory])));
     return clone;
 }

package/dataflow/environments/diff.d.ts

@@ -2,5 +2,5 @@ import type { GenericDifferenceInformation, WriteableDifferenceReport } from '..
 import type { IEnvironment, REnvironmentInformation } from './environment';
 import type { IdentifierReference } from './identifier';
 export declare function diffIdentifierReferences<Report extends WriteableDifferenceReport>(a: IdentifierReference | undefined, b: IdentifierReference | undefined, info: GenericDifferenceInformation<Report>): void;
-export declare function diffEnvironment<Report extends WriteableDifferenceReport>(a: IEnvironment | undefined, b: IEnvironment | undefined, info: GenericDifferenceInformation<Report>): void;
+export declare function diffEnvironment<Report extends WriteableDifferenceReport>(a: IEnvironment | undefined, b: IEnvironment | undefined, info: GenericDifferenceInformation<Report>, depth: number): void;
 export declare function diffEnvironmentInformation<Report extends WriteableDifferenceReport>(a: REnvironmentInformation | undefined, b: REnvironmentInformation | undefined, info: GenericDifferenceInformation<Report>): void;

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,26 +6,25 @@
  */
 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 type EnvironmentMemory = Map<Identifier, IdentifierDefinition[]>;
 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;
     /**
    * Maps to exactly one definition of an identifier if the source is known, otherwise to a list of all possible definitions
    */
-    memory: Map<Identifier, IdentifierDefinition[]>;
+    memory: EnvironmentMemory;
 }
 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 +40,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/edge.d.ts

@@ -2,7 +2,6 @@
  * An edge consist of:
  * - the target node (i.e., the variable or processing node),
  * - a type (if it is read or used in the context), and
- * - an attribute (if this edge exists for every program execution or if it is only one possible execution path).
  */
 export interface DataflowGraphEdge {
     types: EdgeTypeBits;
@@ -40,8 +39,8 @@ export declare const enum EdgeTypeName {
     DefinedBy = "defined-by",
     Calls = "calls",
     Returns = "returns",
-    DefinesOnCall = "defined-by-on-call",
-    DefinedByOnCall = "defines-on-call",
+    DefinesOnCall = "defines-on-call",
+    DefinedByOnCall = "defined-by-on-call",
     Argument = "argument",
     SideEffectOnCall = "side-effect-on-call",
     NonStandardEvaluation = "non-standard-evaluation"

package/dataflow/graph/edge.js

@@ -6,8 +6,8 @@ const edgeTypeToHumanReadableName = new Map([
     [2 /* EdgeType.DefinedBy */, "defined-by" /* EdgeTypeName.DefinedBy */],
     [4 /* EdgeType.Calls */, "calls" /* EdgeTypeName.Calls */],
     [8 /* EdgeType.Returns */, "returns" /* EdgeTypeName.Returns */],
-    [16 /* EdgeType.DefinesOnCall */, "defined-by-on-call" /* EdgeTypeName.DefinesOnCall */],
-    [32 /* EdgeType.DefinedByOnCall */, "defines-on-call" /* EdgeTypeName.DefinedByOnCall */],
+    [16 /* EdgeType.DefinesOnCall */, "defines-on-call" /* EdgeTypeName.DefinesOnCall */],
+    [32 /* EdgeType.DefinedByOnCall */, "defined-by-on-call" /* EdgeTypeName.DefinedByOnCall */],
     [64 /* EdgeType.Argument */, "argument" /* EdgeTypeName.Argument */],
     [128 /* EdgeType.SideEffectOnCall */, "side-effect-on-call" /* EdgeTypeName.SideEffectOnCall */],
     [256 /* EdgeType.NonStandardEvaluation */, "non-standard-evaluation" /* EdgeTypeName.NonStandardEvaluation */]

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

@@ -7,6 +7,7 @@ const arrays_1 = require("../../util/arrays");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const environment_1 = require("../environments/environment");
 const clone_1 = require("../environments/clone");
+const built_in_1 = require("../environments/built-in");
 function isPositionalArgument(arg) {
     return arg !== r_function_call_1.EmptyArgument && arg.name === undefined;
 }
@@ -40,10 +41,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 +90,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 +128,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,11 +155,11 @@ 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',
             environment
         });
         if (asRoot) {
@@ -162,11 +171,12 @@ class DataflowGraph {
    * Will insert a new edge into the graph,
    * if the direction of the edge is of no importance (`same-read-read` or `same-def-def`), source
    * and target will be sorted so that `from` has the lower, and `to` the higher id (default ordering).
+    * Please note, that this will never make edges to {@link BuiltIn} as they are not part of the graph.
    */
     addEdge(from, to, edgeInfo) {
         const { fromId, toId } = extractEdgeIds(from, to);
         const { type, ...rest } = edgeInfo;
-        if (fromId === toId) {
+        if (fromId === toId || toId === built_in_1.BuiltIn) {
             return this;
         }
         /* we now that we pass all required arguments */
@@ -263,9 +273,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);