@eagleoutice/flowr 2.2.11 → 2.2.13

package/cli/script-core/statistics-helper-core.js

@@ -9,7 +9,7 @@ const fs_1 = __importDefault(require("fs"));
 const shell_1 = require("../../r-bridge/shell");
 const statistics_file_1 = require("../../statistics/output/statistics-file");
 const statistics_1 = require("../../statistics/statistics");
-const cfg_1 = require("../../util/cfg/cfg");
+const extract_cfg_1 = require("../../control-flow/extract-cfg");
 const print_1 = require("../../core/print/print");
 const _00_parse_1 = require("../../core/steps/all/core/00-parse");
 const _10_normalize_1 = require("../../core/steps/all/core/10-normalize");
@@ -17,9 +17,9 @@ const _20_dataflow_1 = require("../../core/steps/all/core/20-dataflow");
 const json_1 = require("../../util/json");
 const log_1 = require("../../util/log");
 const assert_1 = require("../../util/assert");
-const time_1 = require("../../util/time");
+const time_1 = require("../../util/text/time");
 const tar_1 = require("tar");
-const ansi_1 = require("../../util/ansi");
+const ansi_1 = require("../../util/text/ansi");
 function compressFolder(folder, target) {
     return (0, tar_1.create)({
         gzip: true,
@@ -58,7 +58,7 @@ async function getStatsForSingleFile(options) {
     if (stats.outputs.size === 1) {
         if (options['dump-json']) {
             const [, output] = [...stats.outputs.entries()][0];
-            const cfg = (0, cfg_1.extractCFG)(output.normalize, output.dataflow.graph);
+            const cfg = (0, extract_cfg_1.extractCFG)(output.normalize, output.dataflow.graph);
             statistics_file_1.statisticsFileProvider.append('output-json', 'parse', await (0, print_1.printStepResult)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, output.parse, 2 /* StepOutputFormat.Json */));
             statistics_file_1.statisticsFileProvider.append('output-json', 'normalize', await (0, print_1.printStepResult)(_10_normalize_1.NORMALIZE, output.normalize, 2 /* StepOutputFormat.Json */));
             statistics_file_1.statisticsFileProvider.append('output-json', 'dataflow', await (0, print_1.printStepResult)(_20_dataflow_1.STATIC_DATAFLOW, output.dataflow, 2 /* StepOutputFormat.Json */));

package/config.d.ts

@@ -2,6 +2,7 @@ import type { MergeableRecord } from './util/objects';
 import Joi from 'joi';
 import type { BuiltInDefinitions } from './dataflow/environments/built-in-config';
 import type { KnownParser } from './r-bridge/parser';
+import type { DeepPartial } from 'ts-essentials';
 export declare enum VariableResolve {
     /** Don't resolve constants at all */
     Disabled = "disabled",
@@ -34,6 +35,52 @@ export declare enum DropPathsOption {
     /** try to drop every folder of the path */
     All = "all"
 }
+export interface FlowrLaxSourcingOptions extends MergeableRecord {
+    /**
+     * search for filenames matching in the lowercase
+     */
+    readonly ignoreCapitalization: boolean;
+    /**
+     * try to infer the working directory from the main or any script to analyze.
+     */
+    readonly inferWorkingDirectory: InferWorkingDirectory;
+    /**
+     * Additionally search in these paths
+     */
+    readonly searchPath: readonly string[];
+    /**
+     * Allow to drop the first or all parts of the sourced path,
+     * if it is relative.
+     */
+    readonly dropPaths: DropPathsOption;
+    /**
+     * How often the same file can be sourced within a single run?
+     * Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.
+     */
+    readonly repeatedSourceLimit?: number;
+    /**
+     * sometimes files may have a different name in the source call	(e.g., due to later replacements),
+     * with this setting you can provide a list of replacements to apply for each sourced file.
+     * Every replacement consists of a record that maps a regex to a replacement string.
+     *
+     * @example
+     * ```ts
+     * [
+     *      { }, // no replacement -> still try the original name/path
+     *      { '.*\\.R$': 'main.R' }, // replace all .R files with main.R
+     *      { '\s' : '_' }, // replace all spaces with underscores
+     *      { '\s' : '-', 'oo': 'aa' }, // replace all spaces with dashes and oo with aa
+     * ]
+     * ```
+     *
+     * Given a `source("foo bar.R")` this configuration will search for (in this order):
+     * - `foo bar.R` (original name)
+     * - `main.R` (replaced with main.R)
+     * - `foo_bar.R` (replaced spaces)
+     * - `foo-bar.R` (replaced spaces and oo)
+     */
+    readonly applyReplacements?: Record<string, string>[];
+}
 export interface FlowrConfigOptions extends MergeableRecord {
     /**
      * Whether source calls should be ignored, causing {@link processSourceCall}'s behavior to be skipped
@@ -67,36 +114,27 @@ export interface FlowrConfigOptions extends MergeableRecord {
          * How to resolve variables and their values
          */
         readonly variables: VariableResolve;
+        /**
+         * Should we include eval(parse(text="...")) calls in the dataflow graph?
+         */
+        readonly evalStrings: boolean;
         /**
          * Whether to track pointers in the dataflow graph,
          * if not, the graph will be over-approximated wrt.
          * containers and accesses
          */
-        readonly pointerTracking: boolean;
+        readonly pointerTracking: boolean | {
+            /**
+             * The maximum number of indices tracked per obj with the pointer analysis (currently this focuses on initialization)
+             */
+            readonly maxIndexCount: number;
+        };
         /**
          * If lax source calls are active, flowR searches for sourced files much more freely,
          * based on the configurations you give it.
          * This option is only in effect if {@link ignoreSourceCalls} is set to false.
          */
-        readonly resolveSource?: {
-            /**
-             * search for filenames matching in the lowercase
-             */
-            readonly ignoreCapitalization: boolean;
-            /**
-             * try to infer the working directory from the main or any script to analyze.
-             */
-            readonly inferWorkingDirectory: InferWorkingDirectory;
-            /**
-             * Additionally search in these paths
-             */
-            readonly searchPath: readonly string[];
-            /**
-             * Allow to drop the first or all parts of the sourced path,
-             * if it is relative.
-             */
-            readonly dropPaths: DropPathsOption;
-        };
+        readonly resolveSource?: FlowrLaxSourcingOptions;
         /**
          * The configuration for flowR's slicer
          */
@@ -139,8 +177,9 @@ export declare const flowrConfigFileSchema: Joi.ObjectSchema<any>;
 export declare function setConfigFile(file: string | undefined, workingDirectory?: string, forceLoad?: boolean): void;
 export declare function parseConfig(jsonString: string): FlowrConfigOptions | undefined;
 export declare function setConfig(config: FlowrConfigOptions): void;
-export declare function amendConfig(amendment: Partial<FlowrConfigOptions>): void;
+export declare function amendConfig(amendment: DeepPartial<FlowrConfigOptions>): void;
 export declare function getConfig(): FlowrConfigOptions;
 export declare function getEngineConfig<T extends EngineConfig['type']>(engine: T): EngineConfig & {
     type: T;
 } | undefined;
+export declare function isOverPointerAnalysisThreshold(count: number): boolean;

package/config.js

@@ -10,6 +10,7 @@ exports.setConfig = setConfig;
 exports.amendConfig = amendConfig;
 exports.getConfig = getConfig;
 exports.getEngineConfig = getEngineConfig;
+exports.isOverPointerAnalysisThreshold = isOverPointerAnalysisThreshold;
 const objects_1 = require("./util/objects");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
@@ -51,7 +52,6 @@ var DropPathsOption;
     /** try to drop every folder of the path */
     DropPathsOption["All"] = "all";
 })(DropPathsOption || (exports.DropPathsOption = DropPathsOption = {}));
-;
 const defaultEngineConfigs = {
     'tree-sitter': { type: 'tree-sitter' },
     'r-shell': { type: 'r-shell' }
@@ -70,12 +70,14 @@ exports.defaultConfigOptions = {
     defaultEngine: 'r-shell',
     solver: {
         variables: VariableResolve.Alias,
+        evalStrings: true,
         pointerTracking: false,
         resolveSource: {
             dropPaths: DropPathsOption.No,
             ignoreCapitalization: true,
             inferWorkingDirectory: InferWorkingDirectory.ActiveScript,
-            searchPath: []
+            searchPath: [],
+            repeatedSourceLimit: 2
         },
         slicer: {
             threshold: 50
@@ -104,12 +106,17 @@ exports.flowrConfigFileSchema = joi_1.default.object({
     defaultEngine: joi_1.default.string().optional().valid('tree-sitter', 'r-shell').description('The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from the specified list will be used.'),
     solver: joi_1.default.object({
         variables: joi_1.default.string().valid(...Object.values(VariableResolve)).description('How to resolve variables and their values.'),
-        pointerTracking: joi_1.default.boolean().description('Whether to track pointers in the dataflow graph, if not, the graph will be over-approximated wrt. containers and accesses.'),
+        evalStrings: joi_1.default.boolean().description('Should we include eval(parse(text="...")) calls in the dataflow graph?'),
+        pointerTracking: joi_1.default.alternatives(joi_1.default.boolean(), joi_1.default.object({
+            maxIndexCount: joi_1.default.number().required().description('The maximum number of indices tracked per object with the pointer analysis.')
+        })).description('Whether to track pointers in the dataflow graph, if not, the graph will be over-approximated wrt. containers and accesses.'),
         resolveSource: joi_1.default.object({
             dropPaths: joi_1.default.string().valid(...Object.values(DropPathsOption)).description('Allow to drop the first or all parts of the sourced path, if it is relative.'),
             ignoreCapitalization: joi_1.default.boolean().description('Search for filenames matching in the lowercase.'),
             inferWorkingDirectory: joi_1.default.string().valid(...Object.values(InferWorkingDirectory)).description('Try to infer the working directory from the main or any script to analyze.'),
-            searchPath: joi_1.default.array().items(joi_1.default.string()).description('Additionally search in these paths.')
+            searchPath: joi_1.default.array().items(joi_1.default.string()).description('Additionally search in these paths.'),
+            repeatedSourceLimit: joi_1.default.number().optional().description('How often the same file can be sourced within a single run? Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.'),
+            applyReplacements: joi_1.default.array().items(joi_1.default.object()).description('Provide name replacements for loaded files')
         }).optional().description('If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if `ignoreSourceCalls` is set to false.'),
         slicer: joi_1.default.object({
             threshold: joi_1.default.number().optional().description('The maximum number of iterations to perform on a single function call during slicing.')
@@ -175,6 +182,19 @@ function getEngineConfig(engine) {
         return config.find(e => e.type == engine);
     }
 }
+function getPointerAnalysisThreshold() {
+    const config = getConfig().solver.pointerTracking;
+    if (typeof config === 'object') {
+        return config.maxIndexCount;
+    }
+    else {
+        return config ? 'unlimited' : 'disabled';
+    }
+}
+function isOverPointerAnalysisThreshold(count) {
+    const threshold = getPointerAnalysisThreshold();
+    return threshold !== 'unlimited' && (threshold === 'disabled' || count > threshold);
+}
 function loadConfigFromFile(configFile, workingDirectory) {
     if (configFile !== undefined) {
         if (path_1.default.isAbsolute(configFile) && fs_1.default.existsSync(configFile)) {

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

@@ -0,0 +1,39 @@
+import type { CfgBasicBlockVertex, CfgEndMarkerVertex, CfgExpressionVertex, CfgMidMarkerVertex, CfgSimpleVertex, CfgStatementVertex, ControlFlowInformation } from './control-flow-graph';
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+export interface BasicCfgGuidedVisitorConfiguration<Cfg extends ControlFlowInformation = ControlFlowInformation> {
+    readonly controlFlow: Cfg;
+    readonly defaultVisitingOrder: 'forward' | 'backward';
+}
+/**
+ * In contrast to {@link visitCfgInOrder} and {@link visitCfgInReverseOrder}, this visitor is not a simple visitor
+ * and serves as the basis for a variety of more complicated visiting orders of the control flow graph.
+ * It includes features to provide additional information using the {@link NormalizedAst} and the {@link DataflowGraph}.
+ *
+ * Use {@link BasicCfgGuidedVisitor#start} to start the traversal.
+ */
+export declare class BasicCfgGuidedVisitor<Cfg extends ControlFlowInformation = ControlFlowInformation, Config extends BasicCfgGuidedVisitorConfiguration<Cfg> = BasicCfgGuidedVisitorConfiguration<Cfg>> {
+    protected readonly config: Config;
+    protected readonly visited: Map<NodeId, number>;
+    constructor(config: Config);
+    /**
+     * call this function to indicate that a node is to be considered visited.
+     *
+     * @returns `true` if the node was not visited before, `false` otherwise
+     */
+    protected visitNode(node: NodeId): boolean;
+    protected startVisitor(start: readonly NodeId[]): void;
+    /**
+     * Start the visiting process.
+     */
+    start(): void;
+    /**
+     * Get the control flow vertex for the given node id or fail if it does not exist.
+     */
+    protected getCfgVertex(id: NodeId): CfgSimpleVertex | undefined;
+    protected onVisitNode(node: NodeId): void;
+    protected onBasicBlockNode(node: CfgBasicBlockVertex): void;
+    protected onStatementNode(_node: CfgStatementVertex): void;
+    protected onExpressionNode(_node: CfgExpressionVertex): void;
+    protected onMidMarkerNode(_node: CfgMidMarkerVertex): void;
+    protected onEndMarkerNode(_node: CfgEndMarkerVertex): void;
+}

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

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicCfgGuidedVisitor = void 0;
+const control_flow_graph_1 = require("./control-flow-graph");
+const assert_1 = require("../util/assert");
+/**
+ * In contrast to {@link visitCfgInOrder} and {@link visitCfgInReverseOrder}, this visitor is not a simple visitor
+ * and serves as the basis for a variety of more complicated visiting orders of the control flow graph.
+ * It includes features to provide additional information using the {@link NormalizedAst} and the {@link DataflowGraph}.
+ *
+ * Use {@link BasicCfgGuidedVisitor#start} to start the traversal.
+ */
+class BasicCfgGuidedVisitor {
+    config;
+    visited;
+    constructor(config) {
+        this.config = { ...config };
+        this.visited = new Map();
+    }
+    /**
+     * call this function to indicate that a node is to be considered visited.
+     *
+     * @returns `true` if the node was not visited before, `false` otherwise
+     */
+    visitNode(node) {
+        if (this.visited.has(node)) {
+            return false;
+        }
+        this.visited.set(node, 1);
+        this.onVisitNode(node);
+        return true;
+    }
+    startVisitor(start) {
+        const g = this.config.controlFlow.graph;
+        const n = this.config.defaultVisitingOrder === 'forward' ?
+            (n) => g.ingoingEdges(n) :
+            (n) => g.outgoingEdges(n);
+        const stack = [...start];
+        while (stack.length > 0) {
+            const current = stack.shift();
+            if (!this.visitNode(current)) {
+                continue;
+            }
+            const outgoing = n(current) ?? [];
+            for (const [to] of outgoing) {
+                stack.unshift(to);
+            }
+        }
+    }
+    /**
+     * Start the visiting process.
+     */
+    start() {
+        this.startVisitor(this.config.defaultVisitingOrder === 'forward' ? this.config.controlFlow.entryPoints : this.config.controlFlow.exitPoints);
+    }
+    /**
+     * Get the control flow vertex for the given node id or fail if it does not exist.
+     */
+    getCfgVertex(id) {
+        return this.config.controlFlow.graph.getVertex(id);
+    }
+    onVisitNode(node) {
+        const vertex = this.getCfgVertex(node);
+        if (vertex === undefined) {
+            return;
+        }
+        const type = vertex.type;
+        switch (type) {
+            case control_flow_graph_1.CfgVertexType.Statement:
+                this.onStatementNode(vertex);
+                break;
+            case control_flow_graph_1.CfgVertexType.Expression:
+                this.onExpressionNode(vertex);
+                break;
+            case control_flow_graph_1.CfgVertexType.MidMarker:
+                this.onMidMarkerNode(vertex);
+                break;
+            case control_flow_graph_1.CfgVertexType.EndMarker:
+                this.onEndMarkerNode(vertex);
+                break;
+            case control_flow_graph_1.CfgVertexType.Block:
+                this.onBasicBlockNode(vertex);
+                break;
+            default:
+                (0, assert_1.assertUnreachable)(type);
+        }
+    }
+    onBasicBlockNode(node) {
+        if (this.config.defaultVisitingOrder === 'forward') {
+            for (const elem of node.elems.toReversed()) {
+                this.visitNode(elem.id);
+            }
+        }
+        else {
+            for (const elem of node.elems) {
+                this.visitNode(elem.id);
+            }
+        }
+    }
+    onStatementNode(_node) {
+        /* does nothing by default */
+    }
+    onExpressionNode(_node) {
+        /* does nothing by default */
+    }
+    onMidMarkerNode(_node) {
+        /* does nothing by default */
+    }
+    onEndMarkerNode(_node) {
+        /* does nothing by default */
+    }
+}
+exports.BasicCfgGuidedVisitor = BasicCfgGuidedVisitor;
+//# sourceMappingURL=basic-cfg-guided-visitor.js.map

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

@@ -0,0 +1,26 @@
+import { type ControlFlowInformation } from './control-flow-graph';
+/**
+ * The collection of properties that can be checked on a control flow graph.
+ */
+declare const CfgProperties: {
+    readonly 'single-entry-and-exit': typeof checkSingleEntryAndExit;
+    readonly 'has-entry-and-exit': typeof hasEntryAndExit;
+    readonly 'entry-reaches-all': typeof checkEntryReachesAll;
+    readonly 'exit-reaches-all': typeof checkExitIsReachedByAll;
+    readonly 'no-direct-fd-cycles': (c: ControlFlowInformation<import("./control-flow-graph").CfgSimpleVertex>) => boolean;
+    readonly 'no-direct-cd-cycles': (c: ControlFlowInformation<import("./control-flow-graph").CfgSimpleVertex>) => boolean;
+};
+export type CfgProperty = keyof typeof CfgProperties;
+declare function checkSingleEntryAndExit(cfg: ControlFlowInformation): boolean;
+declare function hasEntryAndExit(cfg: ControlFlowInformation): boolean;
+declare function checkExitIsReachedByAll(cfg: ControlFlowInformation): boolean;
+declare function checkEntryReachesAll(cfg: ControlFlowInformation): boolean;
+/** either returns true or the name of the property that is not satisfied */
+export type PropertyReport = true | CfgProperty;
+/**
+ * Check if the given CFG satisfies all properties.
+ * @param cfg                 - The control flow graph to check.
+ * @param excludeProperties   - If provided, exclude the given properties, otherwise this checks all properties.
+ */
+export declare function assertCfgSatisfiesProperties(cfg: ControlFlowInformation, excludeProperties?: readonly CfgProperty[]): PropertyReport;
+export {};

package/control-flow/cfg-properties.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertCfgSatisfiesProperties = assertCfgSatisfiesProperties;
+const set_1 = require("../util/collections/set");
+const log_1 = require("../util/log");
+const simple_visitor_1 = require("./simple-visitor");
+/**
+ * The collection of properties that can be checked on a control flow graph.
+ */
+const CfgProperties = {
+    'single-entry-and-exit': checkSingleEntryAndExit,
+    'has-entry-and-exit': hasEntryAndExit,
+    'entry-reaches-all': checkEntryReachesAll,
+    'exit-reaches-all': checkExitIsReachedByAll,
+    /* currently not satisfied for function calls
+    'at-most-one-in-fd':     c => checkFdIOCount(c, 'in', 'at-most', 1),
+    'exactly-one-in-fd':     c => checkFdIOCount(c, 'in', 'exact', 1),
+    'at-most-one-out-fd':    c => checkFdIOCount(c, 'out', 'at-most', 1),
+    'exactly-one-out-fd':    c => checkFdIOCount(c, 'out', 'exact', 1),
+    */
+    'no-direct-fd-cycles': c => checkNoDirectCycles(c, 0 /* CfgEdgeType.Fd */),
+    'no-direct-cd-cycles': c => checkNoDirectCycles(c, 1 /* CfgEdgeType.Cd */),
+};
+function checkSingleEntryAndExit(cfg) {
+    return new Set(cfg.entryPoints).size === 1 && new Set(cfg.exitPoints).size === 1 && new Set(cfg.breaks).size === 0 &&
+        new Set(cfg.returns).size === 0 && new Set(cfg.nexts).size === 0;
+}
+function hasEntryAndExit(cfg) {
+    return cfg.entryPoints.every(e => cfg.graph.hasVertex(e)) && cfg.exitPoints.every(e => cfg.graph.hasVertex(e));
+}
+function checkReachFrom(label, cfg, start, collect) {
+    if (start === undefined) {
+        return false;
+    }
+    const collected = new Set();
+    collect(cfg.graph, [start], node => {
+        collected.add(node);
+    });
+    // we only require the roots to be there
+    const allVertices = cfg.graph.rootIds();
+    const diff = (0, set_1.setMinus)(allVertices, collected);
+    if (diff.size > 0) {
+        log_1.log.error(`Unreachable vertices from ${label}:`, diff);
+        return false;
+    }
+    return true;
+}
+function checkExitIsReachedByAll(cfg) {
+    return checkReachFrom('exit', cfg, cfg.exitPoints[0], simple_visitor_1.visitCfgInReverseOrder);
+}
+function checkEntryReachesAll(cfg) {
+    return checkReachFrom('entry', cfg, cfg.entryPoints[0], simple_visitor_1.visitCfgInOrder);
+}
+function _checkFdIOCount(cfg, dir, type, limit) {
+    const counts = new Map();
+    for (const [from, targets] of cfg.graph.edges()) {
+        for (const [to, edge] of targets) {
+            const important = dir === 'in' ? to : from;
+            if (edge.label === 0 /* CfgEdgeType.Fd */) {
+                counts.set(important, (counts.get(important) ?? 0) + 1);
+            }
+        }
+    }
+    const check = type === 'exact' ? (a) => a === limit : (a) => a <= limit;
+    for (const [node, count] of counts) {
+        if (type === 'exact' && (cfg.entryPoints.includes(node) || cfg.exitPoints.includes(node) || !cfg.graph.rootIds().has(node))) {
+            continue; // skip entry and exit points, they do not have to satisfy this
+        }
+        if (!check(count)) {
+            log_1.log.error(`Node ${node} has ${count} ${dir} edges, expected ${type} ${limit}`);
+            return false;
+        }
+    }
+    return true;
+}
+function checkNoDirectCycles(cfg, type) {
+    for (const [from, targets] of cfg.graph.edges()) {
+        for (const [to, edge] of targets) {
+            if (edge.label === type && to === from) {
+                log_1.log.error(`Node ${from} has a direct cycle with ${to}`);
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Check if the given CFG satisfies all properties.
+ * @param cfg                 - The control flow graph to check.
+ * @param excludeProperties   - If provided, exclude the given properties, otherwise this checks all properties.
+ */
+function assertCfgSatisfiesProperties(cfg, excludeProperties) {
+    for (const [propName, prop] of Object.entries(CfgProperties)) {
+        if ((!excludeProperties || !excludeProperties.includes(propName)) && !prop(cfg)) {
+            return propName;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=cfg-properties.js.map

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

@@ -0,0 +1,18 @@
+import type { ControlFlowInformation } from './control-flow-graph';
+export type CfgSimplificationPass = (cfg: ControlFlowInformation) => ControlFlowInformation;
+declare const CfgSimplificationPasses: {
+    readonly 'unique-cf-sets': typeof uniqueControlFlowSets;
+    readonly 'remove-dead-code': typeof cfgRemoveDeadCode;
+    readonly 'to-basic-blocks': typeof toBasicBlocks;
+};
+export type CfgSimplificationPassName = keyof typeof CfgSimplificationPasses;
+export declare const DefaultCfgSimplificationOrder: ["unique-cf-sets"];
+/**
+ * Simplify the control flow information by applying the given passes.
+ * This may reduce the vertex count, in- and outgoing edges, entry and exit points, etc.
+ */
+export declare function simplifyControlFlowInformation(cfg: ControlFlowInformation, passes?: readonly CfgSimplificationPassName[]): ControlFlowInformation;
+declare function uniqueControlFlowSets(cfg: ControlFlowInformation): ControlFlowInformation;
+declare function cfgRemoveDeadCode(cfg: ControlFlowInformation): ControlFlowInformation;
+declare function toBasicBlocks(cfg: ControlFlowInformation): ControlFlowInformation;
+export {};

package/control-flow/cfg-simplification.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultCfgSimplificationOrder = void 0;
+exports.simplifyControlFlowInformation = simplifyControlFlowInformation;
+const simple_visitor_1 = require("./simple-visitor");
+const cfg_to_basic_blocks_1 = require("./cfg-to-basic-blocks");
+const CfgSimplificationPasses = {
+    'unique-cf-sets': uniqueControlFlowSets,
+    'remove-dead-code': cfgRemoveDeadCode,
+    'to-basic-blocks': toBasicBlocks
+};
+exports.DefaultCfgSimplificationOrder = [
+    'unique-cf-sets',
+    // 'remove-dead-code' // way too expensive for conventional use!
+    // basic blocks must be requested
+];
+/**
+ * Simplify the control flow information by applying the given passes.
+ * This may reduce the vertex count, in- and outgoing edges, entry and exit points, etc.
+ */
+function simplifyControlFlowInformation(cfg, passes = exports.DefaultCfgSimplificationOrder) {
+    for (const pass of passes) {
+        const passFn = CfgSimplificationPasses[pass];
+        cfg = passFn(cfg);
+    }
+    return cfg;
+}
+function uniqueControlFlowSets(cfg) {
+    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)],
+        graph: cfg.graph
+    };
+}
+/* currently this does not do work on function definitions */
+function cfgRemoveDeadCode(cfg) {
+    // 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);
+    });
+    for (const id of cfg.graph.rootIds()) {
+        if (!reachable.has(id)) {
+            cfg.graph.removeVertex(id);
+        }
+    }
+    return cfg;
+}
+function toBasicBlocks(cfg) {
+    return (0, cfg_to_basic_blocks_1.convertCfgToBasicBlocks)(cfg);
+}
+//# sourceMappingURL=cfg-simplification.js.map

package/control-flow/cfg-to-basic-blocks.d.ts

@@ -0,0 +1,5 @@
+import type { ControlFlowInformation } from './control-flow-graph';
+/**
+ * Take a control flow information of a graph without any basic blocks and convert it to a graph with basic blocks.
+ */
+export declare function convertCfgToBasicBlocks(cfInfo: ControlFlowInformation): ControlFlowInformation;

package/control-flow/cfg-to-basic-blocks.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertCfgToBasicBlocks = convertCfgToBasicBlocks;
+const control_flow_graph_1 = require("./control-flow-graph");
+/** if true, return the target */
+function singleOutgoingFd(outgoing) {
+    if (!outgoing || outgoing.size !== 1) {
+        return undefined;
+    }
+    const next = outgoing.entries().next().value;
+    if (next?.[1].label === 0 /* CfgEdgeType.Fd */) {
+        return next[0];
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * Take a control flow information of a graph without any basic blocks and convert it to a graph with basic blocks.
+ */
+function convertCfgToBasicBlocks(cfInfo) {
+    const newCfg = wrapEveryVertexInBasicBlock(cfInfo.graph);
+    if (!newCfg) {
+        return cfInfo;
+    }
+    for (const [id, vtx] of newCfg.vertices(false)) {
+        if (vtx.type !== control_flow_graph_1.CfgVertexType.Block) {
+            continue;
+        }
+        const outgoing = newCfg.outgoingEdges(id);
+        const target = singleOutgoingFd(outgoing);
+        if (target) {
+            const targetIn = newCfg.ingoingEdges(target);
+            if (targetIn && targetIn.size === 1) {
+                newCfg.mergeTwoBasicBlocks(id, target);
+            }
+        }
+        const ingoing = newCfg.ingoingEdges(id);
+        const ingoingTarget = singleOutgoingFd(ingoing);
+        if (ingoingTarget) {
+            const ingoingOut = newCfg.outgoingEdges(ingoingTarget);
+            if (ingoingOut && ingoingOut.size === 1) {
+                newCfg.mergeTwoBasicBlocks(ingoingTarget, id);
+            }
+        }
+    }
+    const findEntries = cfInfo.entryPoints.map(e => newCfg.getBasicBlock(e)?.id);
+    const findExits = cfInfo.exitPoints.map(e => newCfg.getBasicBlock(e)?.id);
+    if (findEntries.some(f => f === undefined) || findExits.some(f => f === undefined)) {
+        /* something went wrong */
+        return cfInfo;
+    }
+    return {
+        ...cfInfo,
+        graph: newCfg,
+        entryPoints: findEntries,
+        exitPoints: findExits,
+    };
+}
+/** only returns undefined when the cfg already contains basic blocks */
+function wrapEveryVertexInBasicBlock(existing) {
+    const newGraph = new control_flow_graph_1.ControlFlowGraph();
+    for (const [id, vertex] of existing.vertices(false)) {
+        if (vertex.type === control_flow_graph_1.CfgVertexType.Block) {
+            return undefined;
+        }
+        newGraph.addVertex({
+            type: control_flow_graph_1.CfgVertexType.Block,
+            elems: [vertex],
+            id: 'bb-' + id,
+        });
+    }
+    // promote all edges
+    for (const [from, outgoing] of existing.edges().entries()) {
+        for (const [to, edge] of outgoing.entries()) {
+            newGraph.addEdge('bb-' + from, 'bb-' + to, edge);
+        }
+    }
+    return newGraph;
+}
+//# sourceMappingURL=cfg-to-basic-blocks.js.map