@eagleoutice/flowr 2.3.0 → 2.4.0

package/control-flow/cfg-simplification.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultCfgSimplificationOrder = exports.CfgSimplificationPasses = void 0;
 exports.simplifyControlFlowInformation = simplifyControlFlowInformation;
+exports.cfgFindAllReachable = cfgFindAllReachable;
 const cfg_to_basic_blocks_1 = require("./cfg-to-basic-blocks");
 const simple_visitor_1 = require("./simple-visitor");
 const cfg_dead_code_1 = require("./cfg-dead-code");
@@ -32,10 +33,7 @@ function simplifyControlFlowInformation(cfg, info, passes = exports.DefaultCfgSi
  */
 function cfgRemoveDeadCode(cfg, _info) {
     // remove every root level node and accompanying vertices that can not be reached from the entry points
-    const reachable = new Set();
-    (0, simple_visitor_1.visitCfgInOrder)(cfg.graph, cfg.entryPoints, node => {
-        reachable.add(node);
-    });
+    const reachable = cfgFindAllReachable(cfg);
     for (const id of cfg.graph.rootIds()) {
         if (!reachable.has(id)) {
             cfg.graph.removeVertex(id);
@@ -45,15 +43,26 @@ function cfgRemoveDeadCode(cfg, _info) {
 }
 function uniqueControlFlowSets(cfg, _info) {
     return {
-        returns: [...new Set(cfg.returns)],
-        entryPoints: [...new Set(cfg.entryPoints)],
-        exitPoints: [...new Set(cfg.exitPoints)],
-        breaks: [...new Set(cfg.breaks)],
-        nexts: [...new Set(cfg.nexts)],
+        returns: Array.from(new Set(cfg.returns)),
+        entryPoints: Array.from(new Set(cfg.entryPoints)),
+        exitPoints: Array.from(new Set(cfg.exitPoints)),
+        breaks: Array.from(new Set(cfg.breaks)),
+        nexts: Array.from(new Set(cfg.nexts)),
         graph: cfg.graph
     };
 }
 function toBasicBlocks(cfg, _info) {
     return (0, cfg_to_basic_blocks_1.convertCfgToBasicBlocks)(cfg);
 }
+/**
+ * Uses {@link visitCfgInOrder} to find all nodes that are reachable from the control flow graph's {@link ControlFlowInformation.entryPoints} and returns them as a set.
+ * @param cfg - The control flow graph whose reachable nodes to find.
+ */
+function cfgFindAllReachable(cfg) {
+    const reachable = new Set();
+    (0, simple_visitor_1.visitCfgInOrder)(cfg.graph, cfg.entryPoints, node => {
+        reachable.add(node);
+    });
+    return reachable;
+}
 //# sourceMappingURL=cfg-simplification.js.map

package/control-flow/control-flow-graph.d.ts

@@ -2,8 +2,6 @@ import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { MergeableRecord } from '../util/objects';
 import type { RFalse, RTrue } from '../r-bridge/lang-4.x/convert-values';
 export declare enum CfgVertexType {
-    /** Marks a break point in a construct (e.g., between the name and the value of an argument, or the formals and the body of a function)  */
-    MidMarker = "mid",
     /** The explicit exit-nodes to ensure the hammock property */
     EndMarker = "end",
     /** something like an if, assignment, ... even though in the classical sense of R they are still expressions */
@@ -50,10 +48,6 @@ export interface CfgWithRoot extends CfgBaseVertex {
     /** the vertex for which this is a marker */
     root: NodeId;
 }
-export interface CfgMidMarkerVertex extends CfgWithRoot {
-    type: CfgVertexType.MidMarker;
-    kind: string;
-}
 export interface CfgEndMarkerVertex extends CfgWithRoot {
     type: CfgVertexType.EndMarker;
 }
@@ -65,9 +59,9 @@ export interface CfgBasicBlockVertex extends CfgBaseVertex {
 /**
  * A vertex in the {@link ControlFlowGraph}.
  */
-export type CfgSimpleVertex = CfgStatementVertex | CfgExpressionVertex | CfgBasicBlockVertex | CfgMidMarkerVertex | CfgEndMarkerVertex;
+export type CfgSimpleVertex = CfgStatementVertex | CfgExpressionVertex | CfgBasicBlockVertex | CfgEndMarkerVertex;
 export declare function equalVertex(a: CfgSimpleVertex, b: CfgSimpleVertex): boolean;
-export declare function isMarkerVertex(vertex: CfgSimpleVertex): vertex is CfgMidMarkerVertex | CfgEndMarkerVertex;
+export declare function isMarkerVertex(vertex: CfgSimpleVertex): vertex is CfgEndMarkerVertex;
 export declare function getVertexRootId(vertex: CfgSimpleVertex): NodeId;
 interface CfgFlowDependencyEdge extends MergeableRecord {
     label: CfgEdgeType.Fd;

package/control-flow/control-flow-graph.js

@@ -9,8 +9,6 @@ exports.emptyControlFlowInformation = emptyControlFlowInformation;
 const assert_1 = require("../util/assert");
 var CfgVertexType;
 (function (CfgVertexType) {
-    /** Marks a break point in a construct (e.g., between the name and the value of an argument, or the formals and the body of a function)  */
-    CfgVertexType["MidMarker"] = "mid";
     /** The explicit exit-nodes to ensure the hammock property */
     CfgVertexType["EndMarker"] = "end";
     /** something like an if, assignment, ... even though in the classical sense of R they are still expressions */
@@ -37,16 +35,13 @@ function equalVertex(a, b) {
     else if (a.type === CfgVertexType.Block && b.type === CfgVertexType.Block) {
         return a.elems.length === b.elems.length && a.elems.every((e, i) => e.id === b.elems[i].id);
     }
-    else if (a.type === CfgVertexType.MidMarker && b.type === CfgVertexType.MidMarker) {
-        return a.kind === b.kind && a.root === b.root;
-    }
     else if (a.type === CfgVertexType.EndMarker && b.type === CfgVertexType.EndMarker) {
         return a.root === b.root;
     }
     return true;
 }
 function isMarkerVertex(vertex) {
-    return vertex.type === CfgVertexType.MidMarker || vertex.type === CfgVertexType.EndMarker;
+    return vertex.type === CfgVertexType.EndMarker;
 }
 function getVertexRootId(vertex) {
     return isMarkerVertex(vertex) ? vertex.root : vertex.id;

package/control-flow/extract-cfg.d.ts

@@ -5,12 +5,12 @@ import type { ControlFlowInformation } from './control-flow-graph';
 import type { CfgSimplificationPassName } from './cfg-simplification';
 import type { FlowrConfigOptions } from '../config';
 /**
- * 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
  *

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/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',