@eagleoutice/flowr 2.2.16 → 2.4.0

package/control-flow/extract-cfg.js

@@ -52,12 +52,12 @@ function dataflowCfgFolds(dataflowGraph) {
     };
 }
 /**
- * Given a normalized AST this approximates the control flow graph of the program.
+ * Given a normalized AST, this approximates the control flow graph of the program.
  * This view is different from the computation of the dataflow graph and may differ,
  * especially because it focuses on intra-procedural analysis.
  *
  * @param ast             - the normalized AST
- * @param config          - the Flowr config
+ * @param config          - the flowR config
  * @param graph           - additional dataflow facts to consider by the control flow extraction
  * @param simplifications - a list of simplification passes to apply to the control flow graph
  *
@@ -92,22 +92,20 @@ function identifyMayStatementType(node) {
 function cfgIfThenElse(ifNode, condition, then, otherwise) {
     const ifId = ifNode.info.id;
     const graph = new control_flow_graph_1.ControlFlowGraph();
-    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, type: identifyMayStatementType(ifNode), mid: condition.exitPoints, end: [ifId + '-exit'] });
     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(ifId + '-condition', exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
-    }
-    for (const entryPoint of then.entryPoints) {
-        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, ifId + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: ifId });
+    for (const e of condition.exitPoints) {
+        for (const entryPoint of then.entryPoints) {
+            graph.addEdge(entryPoint, e, { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: ifId });
+        }
+        for (const entryPoint of otherwise?.entryPoints ?? []) {
+            graph.addEdge(entryPoint, e, { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: ifId });
+        }
     }
     for (const entryPoint of condition.entryPoints) {
         graph.addEdge(entryPoint, ifId, { label: 0 /* CfgEdgeType.Fd */ });
@@ -116,7 +114,9 @@ function cfgIfThenElse(ifNode, condition, then, otherwise) {
         graph.addEdge(ifId + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
     }
     if (!otherwise) {
-        graph.addEdge(ifId + '-exit', ifId + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: ifId });
+        for (const e of condition.exitPoints) {
+            graph.addEdge(ifId + '-exit', e, { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: ifId });
+        }
     }
     return {
         graph,
@@ -146,18 +146,16 @@ function cfgRepeat(repeat, body) {
 function cfgWhile(whileLoop, condition, body) {
     const whileId = whileLoop.info.id;
     const graph = condition.graph;
-    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, type: identifyMayStatementType(whileLoop), mid: condition.exitPoints, end: [whileId + '-exit'] });
     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, whileId, { label: 0 /* CfgEdgeType.Fd */ });
     }
-    for (const exit of condition.exitPoints) {
-        graph.addEdge(whileId + '-condition', exit, { label: 0 /* CfgEdgeType.Fd */ });
-    }
-    for (const entry of body.entryPoints) {
-        graph.addEdge(entry, whileId + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: whileId });
+    for (const e of condition.exitPoints) {
+        for (const entry of body.entryPoints) {
+            graph.addEdge(entry, e, { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: whileId });
+        }
     }
     for (const next of [...body.nexts, ...body.exitPoints]) {
         graph.addEdge(whileId, next, { label: 0 /* CfgEdgeType.Fd */ });
@@ -166,13 +164,19 @@ function cfgWhile(whileLoop, condition, body) {
         graph.addEdge(whileId + '-exit', breakPoint, { label: 0 /* CfgEdgeType.Fd */ });
     }
     // while can break on the condition as well
-    graph.addEdge(whileId + '-exit', whileId + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: whileId });
+    for (const e of condition.exitPoints) {
+        graph.addEdge(whileId + '-exit', e, {
+            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: forLoopId, type: identifyMayStatementType(forLoop), end: [forLoopId + '-exit'], mid: [forLoopId + '-head'] });
+    graph.addVertex({ id: forLoopId, type: identifyMayStatementType(forLoop), end: [forLoopId + '-exit'], mid: variable.exitPoints });
     graph.mergeWith(vector.graph);
     graph.mergeWith(body.graph);
     for (const entry of vector.entryPoints) {
@@ -183,12 +187,10 @@ function cfgFor(forLoop, variable, vector, body) {
             graph.addEdge(entry, exit, { label: 0 /* CfgEdgeType.Fd */ });
         }
     }
-    graph.addVertex({ id: forLoopId + '-head', type: control_flow_graph_1.CfgVertexType.MidMarker, root: forLoopId, kind: 'head' });
-    for (const exit of variable.exitPoints) {
-        graph.addEdge(forLoopId + '-head', exit, { label: 0 /* CfgEdgeType.Fd */ });
-    }
-    for (const entry of body.entryPoints) {
-        graph.addEdge(entry, forLoopId + '-head', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: forLoopId });
+    for (const e of variable.exitPoints) {
+        for (const entry of body.entryPoints) {
+            graph.addEdge(entry, e, { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: forLoopId });
+        }
     }
     for (const next of [...body.nexts, ...body.exitPoints]) {
         graph.addEdge(forLoopId, next, { label: 0 /* CfgEdgeType.Fd */ });
@@ -203,17 +205,19 @@ function cfgFor(forLoop, variable, vector, body) {
             type: control_flow_graph_1.CfgVertexType.EndMarker,
             root: forLoopId
         });
-        graph.addEdge(forLoopId + '-exit', forLoopId + '-head', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: forLoopId });
+        for (const e of variable.exitPoints) {
+            graph.addEdge(forLoopId + '-exit', e, { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: forLoopId });
+        }
     }
     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 = [fnId + '-params', fnId + '-exit'];
-    graph.addVertex({ id: fnId + '-params', kind: 'parameters', type: control_flow_graph_1.CfgVertexType.MidMarker, root: fnId }, false);
+    let paramExits = params.flatMap(e => e.exitPoints);
+    const children = [...paramExits, fnId + '-exit'];
     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.addVertex({ id: fnId, children, type: identifyMayStatementType(fn), mid: paramExits, end: [fnId + '-exit'] });
     graph.mergeWith(body.graph, true);
     children.push(...body.graph.rootIds());
     for (const param of params) {
@@ -222,15 +226,14 @@ function cfgFunctionDefinition(fn, params, body) {
         for (const entry of param.entryPoints) {
             graph.addEdge(entry, fnId, { label: 0 /* CfgEdgeType.Fd */ });
         }
-        for (const exit of param.exitPoints) {
-            graph.addEdge(fnId + '-params', exit, { label: 0 /* CfgEdgeType.Fd */ });
-        }
     }
-    if (params.length === 0) {
-        graph.addEdge(fnId + '-params', fnId, { label: 0 /* CfgEdgeType.Fd */ });
+    if (paramExits.length === 0) {
+        paramExits = [fnId];
     }
-    for (const entry of body.entryPoints) {
-        graph.addEdge(entry, fnId + '-params', { label: 0 /* CfgEdgeType.Fd */ });
+    for (const e of paramExits) {
+        for (const entry of body.entryPoints) {
+            graph.addEdge(entry, e, { 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)) {
@@ -242,16 +245,12 @@ 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: [callId + '-' + exit], entryPoints: [callId] };
-    graph.addVertex({ id: callId, type: identifyMayStatementType(call), mid: [callId + '-name'], end: [callId + '-' + exit] });
+    graph.addVertex({ id: callId, type: identifyMayStatementType(call), mid: name.exitPoints, end: [callId + '-' + exit] });
     for (const entryPoint of name.entryPoints) {
         graph.addEdge(entryPoint, callId, { label: 0 /* CfgEdgeType.Fd */ });
     }
-    graph.addVertex({ id: callId + '-name', kind: 'name', type: control_flow_graph_1.CfgVertexType.MidMarker, root: callId });
-    for (const exitPoint of name.exitPoints) {
-        graph.addEdge(callId + '-name', exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
-    }
     graph.addVertex({ id: callId + '-' + exit, type: control_flow_graph_1.CfgVertexType.EndMarker, root: callId });
-    let lastArgExits = [callId + '-name'];
+    let lastArgExits = name.exitPoints;
     for (const arg of args) {
         if (arg === r_function_call_1.EmptyArgument) {
             continue;
@@ -283,7 +282,7 @@ function cfgFunctionCallWithDataflow(graph) {
         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
+            // we have to filter out non-func-call targets as the call targets contains names and call ids
             if ((0, vertex_1.isFunctionDefinitionVertex)(graph.getVertex(target))) {
                 callVertex.callTargets ??= new Set();
                 callVertex.callTargets.add(target);
@@ -312,8 +311,8 @@ function cfgFunctionCallWithDataflow(graph) {
 function cfgArgumentOrParameter(node, name, value) {
     const graph = new control_flow_graph_1.ControlFlowGraph();
     const info = { graph, breaks: [], nexts: [], returns: [], exitPoints: [node.info.id + '-exit'], entryPoints: [node.info.id] };
-    graph.addVertex({ id: node.info.id, type: control_flow_graph_1.CfgVertexType.Expression, mid: [node.info.id + '-before-value'], end: [node.info.id + '-exit'] });
-    let currentExitPoint = [node.info.id];
+    let currentExitPoints = name?.exitPoints ?? [node.info.id];
+    graph.addVertex({ id: node.info.id, type: control_flow_graph_1.CfgVertexType.Expression, mid: currentExitPoints, end: [node.info.id + '-exit'] });
     if (name) {
         graph.mergeWith(name.graph);
         info.breaks = info.breaks.concat(name.breaks);
@@ -322,27 +321,21 @@ function cfgArgumentOrParameter(node, name, value) {
         for (const entry of name.entryPoints) {
             graph.addEdge(entry, node.info.id, { label: 0 /* CfgEdgeType.Fd */ });
         }
-        currentExitPoint = name.exitPoints;
     }
-    graph.addVertex({ id: node.info.id + '-before-value', kind: 'before-value', type: control_flow_graph_1.CfgVertexType.MidMarker, root: node.info.id });
-    for (const exitPoints of currentExitPoint) {
-        graph.addEdge(node.info.id + '-before-value', exitPoints, { label: 0 /* CfgEdgeType.Fd */ });
-    }
-    currentExitPoint = [node.info.id + '-before-value'];
     if (value) {
         graph.mergeWith(value.graph);
         info.breaks = info.breaks.concat(value.breaks);
         info.nexts = info.nexts.concat(value.nexts);
         info.returns = info.returns.concat(value.returns);
-        for (const exitPoint of currentExitPoint) {
+        for (const exitPoint of currentExitPoints) {
             for (const entry of value.entryPoints) {
                 graph.addEdge(entry, exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
             }
         }
-        currentExitPoint = value.exitPoints;
+        currentExitPoints = value.exitPoints;
     }
     graph.addVertex({ id: node.info.id + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: node.info.id });
-    for (const exit of currentExitPoint) {
+    for (const exit of currentExitPoints) {
         graph.addEdge(node.info.id + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
     }
     return info;
@@ -368,16 +361,12 @@ function cfgBinaryOp(binOp, lhs, rhs) {
 function cfgAccess(access, name, accessors) {
     const result = { ...name };
     const graph = result.graph;
-    graph.addVertex({ id: access.info.id, type: control_flow_graph_1.CfgVertexType.Expression, mid: [access.info.id + '-after-name'], end: [access.info.id + '-exit'] });
+    graph.addVertex({ id: access.info.id, type: control_flow_graph_1.CfgVertexType.Expression, mid: name.exitPoints, end: [access.info.id + '-exit'] });
     result.entryPoints = [access.info.id];
     for (const entry of name.entryPoints) {
         graph.addEdge(entry, access.info.id, { label: 0 /* CfgEdgeType.Fd */ });
     }
-    for (const exit of name.exitPoints) {
-        graph.addEdge(access.info.id + '-after-name', exit, { label: 0 /* CfgEdgeType.Fd */ });
-    }
-    graph.addVertex({ id: access.info.id + '-after-name', kind: 'after-name', type: control_flow_graph_1.CfgVertexType.MidMarker, root: access.info.id });
-    result.exitPoints = [access.info.id + '-after-name'];
+    result.exitPoints = name.exitPoints;
     for (const accessor of accessors) {
         if (accessor === r_function_call_1.EmptyArgument) {
             continue;

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

@@ -45,7 +45,7 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, ControlFlow ex
     /**
      * A helper function to get the normalized AST node for the given id or fail if it does not exist.
      */
-    protected getNormalizedAst(id: NodeId): RNode<OtherInfo & ParentInformation> | undefined;
+    protected getNormalizedAst(id: NodeId | undefined): RNode<OtherInfo & ParentInformation> | undefined;
     /**
      * See {@link DataflowAwareCfgGuidedVisitor#visitValue} for the base implementation.
      * This now dispatches the value to the appropriate event handler based on its type.

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

@@ -35,7 +35,7 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
      * A helper function to get the normalized AST node for the given id or fail if it does not exist.
      */
     getNormalizedAst(id) {
-        return this.config.normalizedAst.idMap.get(id);
+        return id !== undefined ? this.config.normalizedAst.idMap.get(id) : undefined;
     }
     /**
      * See {@link DataflowAwareCfgGuidedVisitor#visitValue} for the base implementation.

package/core/steps/all/static-slicing/00-slice.d.ts

@@ -9,11 +9,17 @@ export interface SliceRequiredInput {
     readonly criterion: SlicingCriteria;
     /** How many re-visits of the same node are ok? */
     readonly threshold?: number;
+    /** The direction to slice in. Defaults to backward slicing if unset. */
+    readonly direction?: SliceDirection;
+}
+export declare enum SliceDirection {
+    Backward = "backward",
+    Forward = "forward"
 }
 declare function processor(results: {
     dataflow?: DataflowInformation;
     normalize?: NormalizedAst;
-}, input: Partial<SliceRequiredInput>, config: FlowrConfigOptions): Readonly<import("../../../../slicing/static/slicer-types").SliceResult>;
+}, input: Partial<SliceRequiredInput>, _config: FlowrConfigOptions): Readonly<import("../../../../slicing/static/slicer-types").SliceResult>;
 export declare const STATIC_SLICE: {
     readonly name: "slice";
     readonly humanReadableName: "static slice";

package/core/steps/all/static-slicing/00-slice.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STATIC_SLICE = void 0;
+exports.STATIC_SLICE = exports.SliceDirection = void 0;
 const print_1 = require("../../../print/print");
 const static_slicer_1 = require("../../../../slicing/static/static-slicer");
-function processor(results, input, config) {
-    return (0, static_slicer_1.staticSlicing)(results.dataflow.graph, results.normalize, input.criterion, input.threshold ?? config.solver.slicer?.threshold);
+var SliceDirection;
+(function (SliceDirection) {
+    SliceDirection["Backward"] = "backward";
+    SliceDirection["Forward"] = "forward";
+})(SliceDirection || (exports.SliceDirection = SliceDirection = {}));
+function processor(results, input, _config) {
+    const direction = input.direction ?? SliceDirection.Backward;
+    return (0, static_slicer_1.staticSlice)(results.dataflow.graph, results.normalize, input.criterion, direction, input.threshold);
 }
 exports.STATIC_SLICE = {
     name: 'slice',

package/core/steps/pipeline/default-pipelines.d.ts

@@ -8,6 +8,20 @@ import type { RShell } from '../../../r-bridge/shell';
 import type { TreeSitterExecutor } from '../../../r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
 import type { FlowrConfigOptions } from '../../../config';
 export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
@@ -60,20 +74,6 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
         readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
     };
     readonly dependencies: readonly ["normalize"];
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "reconstruct";
     readonly humanReadableName: "static code reconstruction";
@@ -90,6 +90,20 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     readonly requiredInput: import("../all/static-slicing/10-reconstruct").ReconstructRequiredInput;
 }>;
 export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
@@ -142,20 +156,6 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
         readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
     };
     readonly dependencies: readonly ["normalize"];
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "reconstruct";
     readonly humanReadableName: "static code reconstruction";
@@ -172,6 +172,20 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
     readonly requiredInput: import("../all/static-slicing/10-reconstruct").ReconstructRequiredInput;
 }>;
 export declare const DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
@@ -224,22 +238,22 @@ export declare const DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipel
         readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
     };
     readonly dependencies: readonly ["normalize"];
-} | {
+}>;
+export declare const TREE_SITTER_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     readonly name: "slice";
     readonly humanReadableName: "static slice";
     readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
     readonly processor: (results: {
         dataflow?: import("../../../dataflow/info").DataflowInformation;
         normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
     readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
     readonly printer: {
         readonly 0: typeof import("../../print/print").internalPrinter;
     };
     readonly dependencies: readonly ["dataflow"];
     readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
-}>;
-export declare const TREE_SITTER_SLICING_PIPELINE: import("./pipeline").Pipeline<{
+} | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
         normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
@@ -259,20 +273,6 @@ export declare const TREE_SITTER_SLICING_PIPELINE: import("./pipeline").Pipeline
         readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
     };
     readonly dependencies: readonly ["normalize"];
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "reconstruct";
     readonly humanReadableName: "static code reconstruction";
@@ -321,6 +321,20 @@ export declare const TREE_SITTER_SLICING_PIPELINE: import("./pipeline").Pipeline
     readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
 }>;
 export declare const TREE_SITTER_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
         normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
@@ -340,20 +354,6 @@ export declare const TREE_SITTER_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipel
         readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
     };
     readonly dependencies: readonly ["normalize"];
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "reconstruct";
     readonly humanReadableName: "static code reconstruction";
@@ -402,6 +402,20 @@ export declare const TREE_SITTER_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipel
     readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
 }>;
 export declare const TREE_SITTER_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, _config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
         normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
@@ -421,20 +435,6 @@ export declare const TREE_SITTER_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./p
         readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
     };
     readonly dependencies: readonly ["normalize"];
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>, config: FlowrConfigOptions) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "parse";
     readonly humanReadableName: "parse with tree-sitter";

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

@@ -30,7 +30,7 @@ import { processRm } from '../internal/process/functions/call/built-in/built-in-
 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 { resolveAsVector, resolveAsSeq, resolveAsMinus, resolveAsPlus } from '../eval/resolve/resolve';
 import type { DataflowGraph } from '../graph/graph';
 import type { VariableResolve } from '../../config';
 export type BuiltIn = `built-in:${string}`;
@@ -54,7 +54,7 @@ export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
     readonly returnsNthArgument?: number | 'last';
     readonly cfg?: ExitPointType;
     readonly readAllArguments?: boolean;
-    readonly hasUnknownSideEffects?: boolean | LinkTo<RegExp | string>;
+    readonly hasUnknownSideEffects?: boolean | LinkTo;
     /** record mapping the actual function name called to the arguments that should be treated as function calls */
     readonly treatAsFnCall?: Record<string, readonly string[]>;
     /** Name that should be used for the origin (useful when needing to differentiate between
@@ -62,8 +62,8 @@ export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
      */
     readonly useAsProcessor?: UseAsProcessors;
 }
-export type BuiltInEvalHandler = (resolve: VariableResolve, 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 type BuiltInEvalHandler = (resolve: VariableResolve, 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>, { returnsNthArgument, useAsProcessor, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }: 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: {
     readonly 'builtin:default': typeof defaultBuiltInProcessor;
@@ -90,7 +90,9 @@ export declare const BuiltInProcessorMapper: {
 };
 export declare const BuiltInEvalHandlerMapper: {
     readonly 'built-in:c': typeof resolveAsVector;
-    readonly 'builtin:vector': typeof resolveAsVector;
+    readonly 'built-in::': typeof resolveAsSeq;
+    readonly 'built-in:+': typeof resolveAsPlus;
+    readonly 'built-in:-': typeof resolveAsMinus;
 };
 export type BuiltInMappingName = keyof typeof BuiltInProcessorMapper;
 export type ConfigOfBuiltInMappingName<N extends BuiltInMappingName> = Parameters<typeof BuiltInProcessorMapper[N]>[4];