@eagleoutice/flowr 2.2.13 → 2.2.15

package/control-flow/extract-cfg.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResolvedCallSuffix = void 0;
-exports.extractCFG = extractCFG;
+exports.extractCfg = extractCfg;
 exports.extractSimpleCfg = extractSimpleCfg;
 exports.cfg2quads = cfg2quads;
 const quads_1 = require("../util/quads");
@@ -62,20 +62,18 @@ function dataflowCfgFolds(dataflowGraph) {
  *
  * @see {@link extractSimpleCfg} - for a simplified version of this function
  */
-function extractCFG(ast, graph, simplifications) {
-    return (0, cfg_simplification_1.simplifyControlFlowInformation)((0, fold_1.foldAst)(ast.ast, graph ? dataflowCfgFolds(graph) : cfgFolds), simplifications);
+function extractCfg(ast, graph, simplifications) {
+    return (0, cfg_simplification_1.simplifyControlFlowInformation)((0, fold_1.foldAst)(ast.ast, graph ? dataflowCfgFolds(graph) : cfgFolds), { ast, dfg: graph }, simplifications);
 }
 /**
- * Simplified version of {@link extractCFG} that is much quicker, but much simpler!
+ * Simplified version of {@link extractCfg} that is much quicker, but much simpler!
  */
 function extractSimpleCfg(ast) {
     return (0, fold_1.foldAst)(ast.ast, cfgFolds);
 }
 function cfgLeaf(type) {
-    return (leaf) => {
-        const graph = new control_flow_graph_1.ControlFlowGraph();
-        graph.addVertex({ id: leaf.info.id, type });
-        return { graph, breaks: [], nexts: [], returns: [], exitPoints: [leaf.info.id], entryPoints: [leaf.info.id] };
+    return ({ info: { id } }) => {
+        return { graph: new control_flow_graph_1.ControlFlowGraph().addVertex({ id, type }), breaks: [], nexts: [], returns: [], exitPoints: [id], entryPoints: [id] };
     };
 }
 function cfgBreak(leaf) {
@@ -91,40 +89,41 @@ function identifyMayStatementType(node) {
     return node.info.role === "expr-list-child" /* RoleInParent.ExpressionListChild */ ? control_flow_graph_1.CfgVertexType.Statement : control_flow_graph_1.CfgVertexType.Expression;
 }
 function cfgIfThenElse(ifNode, condition, then, otherwise) {
+    const ifId = ifNode.info.id;
     const graph = new control_flow_graph_1.ControlFlowGraph();
-    graph.addVertex({ id: ifNode.info.id, type: identifyMayStatementType(ifNode), mid: [ifNode.info.id + '-condition'], end: [ifNode.info.id + '-exit'] });
-    graph.addVertex({ id: ifNode.info.id + '-condition', kind: 'condition', type: control_flow_graph_1.CfgVertexType.MidMarker, root: ifNode.info.id });
-    graph.addVertex({ id: ifNode.info.id + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: ifNode.info.id });
+    graph.addVertex({ id: ifId, type: identifyMayStatementType(ifNode), mid: [ifId + '-condition'], end: [ifId + '-exit'] });
+    graph.addVertex({ id: ifId + '-condition', kind: 'condition', type: control_flow_graph_1.CfgVertexType.MidMarker, root: ifId });
+    graph.addVertex({ id: ifId + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: ifId });
     graph.mergeWith(condition.graph);
     graph.mergeWith(then.graph);
     if (otherwise) {
         graph.mergeWith(otherwise.graph);
     }
     for (const exitPoint of condition.exitPoints) {
-        graph.addEdge(ifNode.info.id + '-condition', exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(ifId + '-condition', exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const entryPoint of then.entryPoints) {
-        graph.addEdge(entryPoint, ifNode.info.id + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: ifNode.info.id });
+        graph.addEdge(entryPoint, ifId + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: ifId });
     }
     for (const entryPoint of otherwise?.entryPoints ?? []) {
-        graph.addEdge(entryPoint, ifNode.info.id + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: ifNode.info.id });
+        graph.addEdge(entryPoint, ifId + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: ifId });
     }
     for (const entryPoint of condition.entryPoints) {
-        graph.addEdge(entryPoint, ifNode.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entryPoint, ifId, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const exit of [...then.exitPoints, ...otherwise?.exitPoints ?? []]) {
-        graph.addEdge(ifNode.info.id + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(ifId + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
     }
     if (!otherwise) {
-        graph.addEdge(ifNode.info.id + '-exit', ifNode.info.id + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: ifNode.info.id });
+        graph.addEdge(ifId + '-exit', ifId + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: ifId });
     }
     return {
         graph,
         breaks: [...then.breaks, ...otherwise?.breaks ?? []],
         nexts: [...then.nexts, ...otherwise?.nexts ?? []],
         returns: [...then.returns, ...otherwise?.returns ?? []],
-        exitPoints: [ifNode.info.id + '-exit'],
-        entryPoints: [ifNode.info.id]
+        exitPoints: [ifId + '-exit'],
+        entryPoints: [ifId]
     };
 }
 function cfgRepeat(repeat, body) {
@@ -144,110 +143,114 @@ function cfgRepeat(repeat, body) {
     return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [repeat.info.id + '-exit'], entryPoints: [repeat.info.id] };
 }
 function cfgWhile(whileLoop, condition, body) {
+    const whileId = whileLoop.info.id;
     const graph = condition.graph;
-    graph.addVertex({ id: whileLoop.info.id, type: identifyMayStatementType(whileLoop), mid: [whileLoop.info.id + '-condition'], end: [whileLoop.info.id + '-exit'] });
-    graph.addVertex({ id: whileLoop.info.id + '-condition', kind: 'condition', type: control_flow_graph_1.CfgVertexType.MidMarker, root: whileLoop.info.id });
-    graph.addVertex({ id: whileLoop.info.id + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: whileLoop.info.id });
+    graph.addVertex({ id: whileId, type: identifyMayStatementType(whileLoop), mid: [whileId + '-condition'], end: [whileId + '-exit'] });
+    graph.addVertex({ id: whileId + '-condition', kind: 'condition', type: control_flow_graph_1.CfgVertexType.MidMarker, root: whileId });
+    graph.addVertex({ id: whileId + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: whileId });
     graph.mergeWith(body.graph);
     for (const entry of condition.entryPoints) {
-        graph.addEdge(entry, whileLoop.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entry, whileId, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const exit of condition.exitPoints) {
-        graph.addEdge(whileLoop.info.id + '-condition', exit, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(whileId + '-condition', exit, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const entry of body.entryPoints) {
-        graph.addEdge(entry, whileLoop.info.id + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: whileLoop.info.id });
+        graph.addEdge(entry, whileId + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: whileId });
     }
     for (const next of [...body.nexts, ...body.exitPoints]) {
-        graph.addEdge(whileLoop.info.id, next, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(whileId, next, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const breakPoint of body.breaks) {
-        graph.addEdge(whileLoop.info.id + '-exit', breakPoint, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(whileId + '-exit', breakPoint, { label: 0 /* CfgEdgeType.Fd */ });
     }
     // while can break on the condition as well
-    graph.addEdge(whileLoop.info.id + '-exit', whileLoop.info.id + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: whileLoop.info.id });
-    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [whileLoop.info.id + '-exit'], entryPoints: [whileLoop.info.id] };
+    graph.addEdge(whileId + '-exit', whileId + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: whileId });
+    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [whileId + '-exit'], entryPoints: [whileId] };
 }
 function cfgFor(forLoop, variable, vector, body) {
+    const forLoopId = forLoop.info.id;
     const graph = variable.graph;
-    graph.addVertex({ id: forLoop.info.id, type: identifyMayStatementType(forLoop), end: [forLoop.info.id + '-exit'], mid: [forLoop.info.id + '-head'] });
+    graph.addVertex({ id: forLoopId, type: identifyMayStatementType(forLoop), end: [forLoopId + '-exit'], mid: [forLoopId + '-head'] });
     graph.mergeWith(vector.graph);
     graph.mergeWith(body.graph);
     for (const entry of vector.entryPoints) {
-        graph.addEdge(entry, forLoop.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entry, forLoopId, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const exit of vector.exitPoints) {
         for (const entry of variable.entryPoints) {
             graph.addEdge(entry, exit, { label: 0 /* CfgEdgeType.Fd */ });
         }
     }
-    graph.addVertex({ id: forLoop.info.id + '-head', type: control_flow_graph_1.CfgVertexType.MidMarker, root: forLoop.info.id, kind: 'head' });
+    graph.addVertex({ id: forLoopId + '-head', type: control_flow_graph_1.CfgVertexType.MidMarker, root: forLoopId, kind: 'head' });
     for (const exit of variable.exitPoints) {
-        graph.addEdge(forLoop.info.id + '-head', exit, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(forLoopId + '-head', exit, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const entry of body.entryPoints) {
-        graph.addEdge(entry, forLoop.info.id + '-head', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: forLoop.info.id });
+        graph.addEdge(entry, forLoopId + '-head', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: forLoopId });
     }
     for (const next of [...body.nexts, ...body.exitPoints]) {
-        graph.addEdge(forLoop.info.id, next, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(forLoopId, next, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const breakPoint of body.breaks) {
-        graph.addEdge(forLoop.info.id + '-exit', breakPoint, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(forLoopId + '-exit', breakPoint, { label: 0 /* CfgEdgeType.Fd */ });
     }
     const isNotEndless = body.exitPoints.length > 0 || body.breaks.length > 0;
     if (isNotEndless) {
         graph.addVertex({
-            id: forLoop.info.id + '-exit',
+            id: forLoopId + '-exit',
             type: control_flow_graph_1.CfgVertexType.EndMarker,
-            root: forLoop.info.id
+            root: forLoopId
         });
-        graph.addEdge(forLoop.info.id + '-exit', forLoop.info.id + '-head', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: forLoop.info.id });
+        graph.addEdge(forLoopId + '-exit', forLoopId + '-head', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: forLoopId });
     }
-    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: isNotEndless ? [forLoop.info.id + '-exit'] : [], entryPoints: [forLoop.info.id] };
+    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: isNotEndless ? [forLoopId + '-exit'] : [], entryPoints: [forLoopId] };
 }
 function cfgFunctionDefinition(fn, params, body) {
+    const fnId = fn.info.id;
     const graph = new control_flow_graph_1.ControlFlowGraph();
-    const children = [fn.info.id + '-params', fn.info.id + '-exit'];
-    graph.addVertex({ id: fn.info.id + '-params', kind: 'parameters', type: control_flow_graph_1.CfgVertexType.MidMarker, root: fn.info.id }, false);
-    graph.addVertex({ id: fn.info.id + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: fn.info.id }, false);
-    graph.addVertex({ id: fn.info.id, children, type: identifyMayStatementType(fn), mid: [fn.info.id + '-params'], end: [fn.info.id + '-exit'] });
+    const children = [fnId + '-params', fnId + '-exit'];
+    graph.addVertex({ id: fnId + '-params', kind: 'parameters', type: control_flow_graph_1.CfgVertexType.MidMarker, root: fnId }, false);
+    graph.addVertex({ id: fnId + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: fnId }, false);
+    graph.addVertex({ id: fnId, children, type: identifyMayStatementType(fn), mid: [fnId + '-params'], end: [fnId + '-exit'] });
     graph.mergeWith(body.graph, true);
     children.push(...body.graph.rootIds());
     for (const param of params) {
         graph.mergeWith(param.graph, true);
         children.push(...param.graph.rootIds());
         for (const entry of param.entryPoints) {
-            graph.addEdge(entry, fn.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+            graph.addEdge(entry, fnId, { label: 0 /* CfgEdgeType.Fd */ });
         }
         for (const exit of param.exitPoints) {
-            graph.addEdge(fn.info.id + '-params', exit, { label: 0 /* CfgEdgeType.Fd */ });
+            graph.addEdge(fnId + '-params', exit, { label: 0 /* CfgEdgeType.Fd */ });
         }
     }
     if (params.length === 0) {
-        graph.addEdge(fn.info.id + '-params', fn.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(fnId + '-params', fnId, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const entry of body.entryPoints) {
-        graph.addEdge(entry, fn.info.id + '-params', { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entry, fnId + '-params', { label: 0 /* CfgEdgeType.Fd */ });
     }
-    // breaks and nexts should be illegal but safe is safe i guess
-    for (const next of [...body.returns, ...body.breaks, ...body.nexts, ...body.exitPoints]) {
-        graph.addEdge(fn.info.id + '-exit', next, { label: 0 /* CfgEdgeType.Fd */ });
+    // breaks and nexts should be illegal but safe is safe, I guess
+    for (const next of body.returns.concat(body.breaks, body.nexts, body.exitPoints)) {
+        graph.addEdge(fnId + '-exit', next, { label: 0 /* CfgEdgeType.Fd */ });
     }
-    return { graph: graph, breaks: [], nexts: [], returns: [], exitPoints: [fn.info.id], entryPoints: [fn.info.id] };
+    return { graph: graph, breaks: [], nexts: [], returns: [], exitPoints: [fnId], entryPoints: [fnId] };
 }
 function cfgFunctionCall(call, name, args, exit = 'exit') {
+    const callId = call.info.id;
     const graph = name.graph;
-    const info = { graph, breaks: [...name.breaks], nexts: [...name.nexts], returns: [...name.returns], exitPoints: [call.info.id + '-' + exit], entryPoints: [call.info.id] };
-    graph.addVertex({ id: call.info.id, type: identifyMayStatementType(call), mid: [call.info.id + '-name'], end: [call.info.id + '-' + exit] });
+    const info = { graph, breaks: [...name.breaks], nexts: [...name.nexts], returns: [...name.returns], exitPoints: [callId + '-' + exit], entryPoints: [callId] };
+    graph.addVertex({ id: callId, type: identifyMayStatementType(call), mid: [callId + '-name'], end: [callId + '-' + exit] });
     for (const entryPoint of name.entryPoints) {
-        graph.addEdge(entryPoint, call.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entryPoint, callId, { label: 0 /* CfgEdgeType.Fd */ });
     }
-    graph.addVertex({ id: call.info.id + '-name', kind: 'name', type: control_flow_graph_1.CfgVertexType.MidMarker, root: call.info.id });
+    graph.addVertex({ id: callId + '-name', kind: 'name', type: control_flow_graph_1.CfgVertexType.MidMarker, root: callId });
     for (const exitPoint of name.exitPoints) {
-        graph.addEdge(call.info.id + '-name', exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(callId + '-name', exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
     }
-    graph.addVertex({ id: call.info.id + '-' + exit, type: control_flow_graph_1.CfgVertexType.EndMarker, root: call.info.id });
-    let lastArgExits = [call.info.id + '-name'];
+    graph.addVertex({ id: callId + '-' + exit, type: control_flow_graph_1.CfgVertexType.EndMarker, root: callId });
+    let lastArgExits = [callId + '-name'];
     for (const arg of args) {
         if (arg === r_function_call_1.EmptyArgument) {
             continue;
@@ -264,7 +267,7 @@ function cfgFunctionCall(call, name, args, exit = 'exit') {
         lastArgExits = arg.exitPoints;
     }
     for (const exit of lastArgExits) {
-        graph.addEdge(call.info.id + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(callId + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
     }
     // should not contain any breaks, nexts, or returns, (except for the body if something like 'break()')
     return info;
@@ -272,11 +275,11 @@ function cfgFunctionCall(call, name, args, exit = 'exit') {
 exports.ResolvedCallSuffix = '-resolved-call-exit';
 function cfgFunctionCallWithDataflow(graph) {
     return (call, name, args) => {
-        const baseCFG = cfgFunctionCall(call, name, args);
+        const baseCfg = cfgFunctionCall(call, name, args);
         /* try to resolve the call and link the target definitions */
         const targets = (0, linker_1.getAllFunctionCallTargets)(call.info.id, graph);
         const exits = [];
-        const callVertex = baseCFG.graph.getVertex(call.info.id);
+        const callVertex = baseCfg.graph.getVertex(call.info.id);
         (0, assert_1.guard)(callVertex !== undefined, 'cfgFunctionCallWithDataflow: call vertex not found');
         for (const target of targets) {
             // we have to filter out non func-call targets as the call targets contains names and call ids
@@ -287,21 +290,21 @@ function cfgFunctionCallWithDataflow(graph) {
             }
         }
         if (exits.length > 0) {
-            baseCFG.graph.addVertex({
+            baseCfg.graph.addVertex({
                 id: call.info.id + exports.ResolvedCallSuffix,
                 type: control_flow_graph_1.CfgVertexType.EndMarker,
                 root: call.info.id
             });
-            for (const exit of [...baseCFG.exitPoints, ...exits]) {
-                baseCFG.graph.addEdge(call.info.id + exports.ResolvedCallSuffix, exit, { label: 0 /* CfgEdgeType.Fd */ });
+            for (const exit of [...baseCfg.exitPoints, ...exits]) {
+                baseCfg.graph.addEdge(call.info.id + exports.ResolvedCallSuffix, exit, { label: 0 /* CfgEdgeType.Fd */ });
             }
             return {
-                ...baseCFG,
+                ...baseCfg,
                 exitPoints: [call.info.id + exports.ResolvedCallSuffix]
             };
         }
         else {
-            return baseCFG;
+            return baseCfg;
         }
     };
 }

package/control-flow/semantic-cfg-guided-visitor.d.ts

@@ -1,5 +1,4 @@
 import type { CfgExpressionVertex, CfgStatementVertex, ControlFlowInformation } from './control-flow-graph';
-import type { DataflowInformation } from '../dataflow/info';
 import type { DataflowCfgGuidedVisitorConfiguration } from './dfg-cfg-guided-visitor';
 import { DataflowAwareCfgGuidedVisitor } from './dfg-cfg-guided-visitor';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
@@ -10,12 +9,12 @@ import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefini
 import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
-import type { FunctionArgument } from '../dataflow/graph/graph';
+import type { DataflowGraph, FunctionArgument } from '../dataflow/graph/graph';
 import type { NoInfo, RNode } from '../r-bridge/lang-4.x/ast/model/model';
 import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { BuiltInProcessorMapper } from '../dataflow/environments/built-in';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
-export interface SemanticCfgGuidedVisitorConfiguration<OtherInfo = NoInfo, Cfg extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo> = NormalizedAst<OtherInfo>, Dfg extends DataflowInformation = DataflowInformation> extends DataflowCfgGuidedVisitorConfiguration<Cfg, Dfg>, SyntaxCfgGuidedVisitorConfiguration<OtherInfo, Cfg, Ast> {
+export interface SemanticCfgGuidedVisitorConfiguration<OtherInfo = NoInfo, ControlFlow extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo> = NormalizedAst<OtherInfo>, Dfg extends DataflowGraph = DataflowGraph> extends DataflowCfgGuidedVisitorConfiguration<ControlFlow, Dfg>, SyntaxCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast> {
 }
 /**
  * This visitor extends on the {@link DataflowAwareCfgGuidedVisitor} by dispatching visitors for separate function calls as well,
@@ -40,7 +39,7 @@ export interface SemanticCfgGuidedVisitorConfiguration<OtherInfo = NoInfo, Cfg e
  *
  * Use {@link BasicCfgGuidedVisitor#start} to start the traversal.
  */
-export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo> = NormalizedAst<OtherInfo>, Dfg extends DataflowInformation = DataflowInformation, Config extends SemanticCfgGuidedVisitorConfiguration<OtherInfo, Cfg, Ast, Dfg> = SemanticCfgGuidedVisitorConfiguration<OtherInfo, Cfg, Ast, Dfg>> extends DataflowAwareCfgGuidedVisitor<Cfg, Dfg, Config> {
+export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, ControlFlow extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo> = NormalizedAst<OtherInfo>, Dfg extends DataflowGraph = DataflowGraph, Config extends SemanticCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dfg> = SemanticCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dfg>> extends DataflowAwareCfgGuidedVisitor<ControlFlow, Dfg, Config> {
     /**
      * A helper function to get the normalized AST node for the given id or fail if it does not exist.
      */
@@ -117,6 +116,11 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends Co
      * @protected
      */
     protected onDispatchFunctionCallOrigin(call: DataflowGraphVertexFunctionCall, origin: keyof typeof BuiltInProcessorMapper | string): void;
+    /**
+     * This event is called for the root program node, i.e., the program that is being analyzed.
+     *
+     * @protected
+     */
     protected onProgram(_data: RExpressionList<OtherInfo>): void;
     /**
      * A helper function to request the {@link getOriginInDfg|origins} of the given node.
@@ -180,6 +184,7 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends Co
      */
     protected onFunctionDefinition(_data: {
         vertex: DataflowGraphVertexFunctionDefinition;
+        parameters?: readonly NodeId[];
     }): void;
     /**
      * This event triggers for every anonymous call within the program.
@@ -211,7 +216,7 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends Co
      *
      * This explicitly will not trigger for scenarios in which the function has no name (i.e., if it is anonymous).
      * For such cases, you may rely on the {@link SemanticCfgGuidedVisitor#onUnnamedCall|`onUnnamedCall`} event.
-     * The main reason for this separation is part of flowR's handling of these functions, as anonmyous calls cannot be resolved using the active environment.
+     * The main reason for this separation is part of flowR's handling of these functions, as anonymous calls cannot be resolved using the active environment.
      *
      * @protected
      */
@@ -282,9 +287,9 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends Co
      */
     protected onIfThenElseCall(_data: {
         call: DataflowGraphVertexFunctionCall;
-        condition: FunctionArgument;
-        then: FunctionArgument;
-        else: FunctionArgument | undefined;
+        condition: NodeId | undefined;
+        then: NodeId | undefined;
+        else: NodeId | undefined;
     }): void;
     /**
      * This event triggers for every call to the `get` function, which is used to access variables in the global environment.
@@ -346,6 +351,8 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends Co
      */
     protected onSpecialBinaryOpCall(_data: {
         call: DataflowGraphVertexFunctionCall;
+        lhs?: FunctionArgument;
+        rhs?: FunctionArgument;
     }): void;
     /**
      * This event triggers for every call to R's pipe operator, i.e., for every call to `|>`.
@@ -354,6 +361,8 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends Co
      */
     protected onPipeCall(_data: {
         call: DataflowGraphVertexFunctionCall;
+        lhs?: FunctionArgument;
+        rhs?: FunctionArgument;
     }): void;
     /**
      * This event triggers for every call to the `quote` function, which is used to quote expressions.

package/control-flow/semantic-cfg-guided-visitor.js

@@ -6,6 +6,7 @@ const dfg_get_origin_1 = require("../dataflow/origin/dfg-get-origin");
 const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
 const edge_1 = require("../dataflow/graph/edge");
 const assert_1 = require("../util/assert");
+const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 /**
  * This visitor extends on the {@link DataflowAwareCfgGuidedVisitor} by dispatching visitors for separate function calls as well,
  * providing more information!
@@ -90,7 +91,13 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
      */
     visitFunctionDefinition(vertex) {
         super.visitFunctionDefinition(vertex);
-        this.onFunctionDefinition({ vertex });
+        const ast = this.getNormalizedAst(vertex.id);
+        if (ast?.type === type_1.RType.FunctionDefinition) {
+            this.onFunctionDefinition({ vertex, parameters: ast.parameters.map(p => p.info.id) });
+        }
+        else {
+            this.onFunctionDefinition({ vertex });
+        }
     }
     /**
      * See {@link DataflowAwareCfgGuidedVisitor#visitFunctionCall} for the base implementation.
@@ -161,8 +168,26 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
                 return this.onSourceCall({ call });
             case 'builtin:access':
                 return this.onAccessCall({ call });
-            case 'builtin:if-then-else':
-                return this.onIfThenElseCall({ call, condition: call.args[0], then: call.args[1], else: call.args[2] });
+            case 'builtin:if-then-else': {
+                // recover dead arguments from ast
+                const ast = this.getNormalizedAst(call.id);
+                if (!ast || ast.type !== type_1.RType.IfThenElse) {
+                    return this.onIfThenElseCall({
+                        call,
+                        condition: call.args[0] === r_function_call_1.EmptyArgument ? undefined : call.args[0].nodeId,
+                        then: call.args[1] === r_function_call_1.EmptyArgument ? undefined : call.args[1].nodeId,
+                        else: call.args[2] === r_function_call_1.EmptyArgument ? undefined : call.args[2].nodeId
+                    });
+                }
+                else {
+                    return this.onIfThenElseCall({
+                        call,
+                        condition: ast.condition.info.id,
+                        then: ast.then.info.id,
+                        else: ast.otherwise?.info.id
+                    });
+                }
+            }
             case 'builtin:get':
                 return this.onGetCall({ call });
             case 'builtin:rm':
@@ -173,11 +198,11 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
                 return this.onVectorCall({ call });
             case 'table:assign':
             case 'builtin:assignment': {
-                const outgoing = this.config.dataflow.graph.outgoingEdges(call.id);
+                const outgoing = this.config.dfg.outgoingEdges(call.id);
                 if (outgoing) {
                     const target = [...outgoing.entries()].filter(([, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Returns));
                     if (target.length === 1) {
-                        const targetOut = this.config.dataflow.graph.outgoingEdges(target[0][0]);
+                        const targetOut = this.config.dfg.outgoingEdges(target[0][0]);
                         if (targetOut) {
                             const source = [...targetOut.entries()].filter(([t, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.DefinedBy) && t !== call.id);
                             if (source.length === 1) {
@@ -189,9 +214,15 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
                 return this.onAssignmentCall({ call, target: undefined, source: undefined });
             }
             case 'builtin:special-bin-op':
-                return this.onSpecialBinaryOpCall({ call });
+                if (call.args.length !== 2) {
+                    return this.onSpecialBinaryOpCall({ call });
+                }
+                return this.onSpecialBinaryOpCall({ call, lhs: call.args[0], rhs: call.args[1] });
             case 'builtin:pipe':
-                return this.onPipeCall({ call });
+                if (call.args.length !== 2) {
+                    return this.onPipeCall({ call });
+                }
+                return this.onPipeCall({ call, lhs: call.args[0], rhs: call.args[1] });
             case 'builtin:quote':
                 return this.onQuoteCall({ call });
             case 'builtin:for-loop':
@@ -201,11 +232,11 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
             case 'builtin:while-loop':
                 return this.onWhileLoopCall({ call, condition: call.args[0], body: call.args[1] });
             case 'builtin:replacement': {
-                const outgoing = this.config.dataflow.graph.outgoingEdges(call.id);
+                const outgoing = this.config.dfg.outgoingEdges(call.id);
                 if (outgoing) {
                     const target = [...outgoing.entries()].filter(([, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Returns));
                     if (target.length === 1) {
-                        const targetOut = this.config.dataflow.graph.outgoingEdges(target[0][0]);
+                        const targetOut = this.config.dfg.outgoingEdges(target[0][0]);
                         if (targetOut) {
                             const source = [...targetOut.entries()].filter(([t, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.DefinedBy) && t !== call.id);
                             if (source.length === 1) {
@@ -223,13 +254,17 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
                 return this.onDefaultFunctionCall({ call });
         }
     }
-    onProgram(_data) {
-    }
+    /**
+     * This event is called for the root program node, i.e., the program that is being analyzed.
+     *
+     * @protected
+     */
+    onProgram(_data) { }
     /**
      * A helper function to request the {@link getOriginInDfg|origins} of the given node.
      */
     getOrigins(id) {
-        return (0, dfg_get_origin_1.getOriginInDfg)(this.config.dataflow.graph, id);
+        return (0, dfg_get_origin_1.getOriginInDfg)(this.config.dfg, id);
     }
     /** Called for every occurrence of a `NULL` in the program. */
     onNullConstant(_data) { }
@@ -300,7 +335,7 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
      *
      * This explicitly will not trigger for scenarios in which the function has no name (i.e., if it is anonymous).
      * For such cases, you may rely on the {@link SemanticCfgGuidedVisitor#onUnnamedCall|`onUnnamedCall`} event.
-     * The main reason for this separation is part of flowR's handling of these functions, as anonmyous calls cannot be resolved using the active environment.
+     * The main reason for this separation is part of flowR's handling of these functions, as anonymous calls cannot be resolved using the active environment.
      *
      * @protected
      */
@@ -351,15 +386,13 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
      *
      * @protected
      */
-    onAccessCall(_data) {
-    }
+    onAccessCall(_data) { }
     /**
      * This event triggers for every call to the `if` function, which is used to implement the `if-then-else` control flow.
      *
      * @protected
      */
-    onIfThenElseCall(_data) {
-    }
+    onIfThenElseCall(_data) { }
     /**
      * This event triggers for every call to the `get` function, which is used to access variables in the global environment.
      *

package/control-flow/simple-visitor.d.ts

@@ -23,3 +23,7 @@ export declare function visitCfgInReverseOrder(graph: ControlFlowGraph, startNod
  * @see {@link visitCfgInReverseOrder} for a traversal in reversed order
  */
 export declare function visitCfgInOrder(graph: ControlFlowGraph, startNodes: readonly NodeId[], visitor: (node: NodeId) => boolean | void): void;
+/**
+ * Check if a node can reach another node in the control flow graph.
+ */
+export declare function canReach(graph: ControlFlowGraph, from: NodeId[], to: NodeId): boolean;

package/control-flow/simple-visitor.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.visitCfgInReverseOrder = visitCfgInReverseOrder;
 exports.visitCfgInOrder = visitCfgInOrder;
+exports.canReach = canReach;
 const control_flow_graph_1 = require("./control-flow-graph");
 /**
  * Visit all nodes reachable from the start node in the control flow graph, traversing the dependencies but ignoring cycles.
@@ -77,4 +78,17 @@ visitor) {
         }
     }
 }
+/**
+ * Check if a node can reach another node in the control flow graph.
+ */
+function canReach(graph, from, to) {
+    let reached = false;
+    visitCfgInOrder(graph, from, node => {
+        if (node === to) {
+            reached = true;
+            return true;
+        }
+    });
+    return reached;
+}
 //# sourceMappingURL=simple-visitor.js.map

package/control-flow/syntax-cfg-guided-visitor.d.ts

@@ -25,7 +25,7 @@ import type { RNext } from '../r-bridge/lang-4.x/ast/model/nodes/r-next';
 import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NoInfo, RNode } from '../r-bridge/lang-4.x/ast/model/model';
-export interface SyntaxCfgGuidedVisitorConfiguration<OtherInfo = NoInfo, Cfg extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo> = NormalizedAst<OtherInfo>> extends BasicCfgGuidedVisitorConfiguration<Cfg> {
+export interface SyntaxCfgGuidedVisitorConfiguration<OtherInfo = NoInfo, ControlFlow extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo> = NormalizedAst<OtherInfo>> extends BasicCfgGuidedVisitorConfiguration<ControlFlow> {
     readonly normalizedAst: Ast;
 }
 /**
@@ -33,7 +33,7 @@ export interface SyntaxCfgGuidedVisitorConfiguration<OtherInfo = NoInfo, Cfg ext
  *
  * Use {@link BasicCfgGuidedVisitor#start} to start the traversal.
  */
-export declare class SyntaxAwareCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo> = NormalizedAst<OtherInfo>, Config extends SyntaxCfgGuidedVisitorConfiguration<OtherInfo, Cfg, Ast> = SyntaxCfgGuidedVisitorConfiguration<OtherInfo, Cfg, Ast>> extends BasicCfgGuidedVisitor<Cfg, Config> {
+export declare class SyntaxAwareCfgGuidedVisitor<OtherInfo = NoInfo, ControlFlow extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo> = NormalizedAst<OtherInfo>, Config extends SyntaxCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast> = SyntaxCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast>> extends BasicCfgGuidedVisitor<ControlFlow, Config> {
     /**
      * Get the normalized AST node for the given id or fail if it does not exist.
      */

package/dataflow/environments/built-in-config.d.ts

@@ -27,6 +27,7 @@ export interface BuiltInFunctionDefinition<BuiltInProcessor extends BuiltInMappi
     readonly type: 'function';
     readonly processor: BuiltInProcessor;
     readonly config?: ConfigOfBuiltInMappingName<BuiltInProcessor>;
+    readonly evalHandler?: string;
 }
 /**
  * Define a built-in replacement (like `[` or `$`) and the processor to use.

package/dataflow/environments/built-in.d.ts

@@ -15,7 +15,7 @@ import { processQuote } from '../internal/process/functions/call/built-in/built-
 import { processFunctionDefinition } from '../internal/process/functions/call/built-in/built-in-function-definition';
 import { processExpressionList } from '../internal/process/functions/call/built-in/built-in-expression-list';
 import { processGet } from '../internal/process/functions/call/built-in/built-in-get';
-import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { AstIdMap, ParentInformation, RNodeWithParent } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RFunctionArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
@@ -28,6 +28,10 @@ import { processList } from '../internal/process/functions/call/built-in/built-i
 import { processVector } from '../internal/process/functions/call/built-in/built-in-vector';
 import { processRm } from '../internal/process/functions/call/built-in/built-in-rm';
 import { processEvalCall } from '../internal/process/functions/call/built-in/built-in-eval';
+import type { REnvironmentInformation } from './environment';
+import type { Value } from '../eval/values/r-value';
+import { resolveAsVector } from '../eval/resolve/resolve';
+import type { DataflowGraph } from '../graph/graph';
 export type BuiltIn = `built-in:${string}`;
 export declare function builtInId(name: string): BuiltIn;
 export declare function isBuiltIn(name: NodeId | string): name is BuiltIn;
@@ -52,6 +56,7 @@ export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
     /** record mapping the actual function name called to the arguments that should be treated as function calls */
     readonly treatAsFnCall?: Record<string, readonly string[]>;
 }
+export type BuiltInEvalHandler = (a: RNodeWithParent, env: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap) => Value;
 declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: DefaultBuiltInProcessorConfiguration): DataflowInformation;
 export declare function registerBuiltInFunctions<Config extends object, Proc extends BuiltInIdentifierProcessorWithConfig<Config>>(both: boolean, names: readonly Identifier[], processor: Proc, config: Config): void;
 export declare const BuiltInProcessorMapper: {
@@ -77,6 +82,10 @@ export declare const BuiltInProcessorMapper: {
     readonly 'builtin:list': typeof processList;
     readonly 'builtin:vector': typeof processVector;
 };
+export declare const BuiltInEvalHandlerMapper: {
+    readonly 'built-in:c': typeof resolveAsVector;
+    readonly 'builtin:vector': typeof resolveAsVector;
+};
 export type BuiltInMappingName = keyof typeof BuiltInProcessorMapper;
 export type ConfigOfBuiltInMappingName<N extends BuiltInMappingName> = Parameters<typeof BuiltInProcessorMapper[N]>[4];
 export declare const BuiltInMemory: Map<Identifier, IdentifierDefinition[]>;