@eagleoutice/flowr 2.2.14 → 2.2.16

package/cli/repl/server/connection.d.ts

@@ -3,6 +3,7 @@ import { DEFAULT_SLICING_PIPELINE } from '../../../core/steps/pipeline/default-p
 import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
 import type { DeepPartial } from 'ts-essentials';
 import type { KnownParser } from '../../../r-bridge/parser';
+import type { FlowrConfigOptions } from '../../../config';
 /**
  * Each connection handles a single client, answering to its requests.
  * There is no need to construct this class manually, {@link FlowRServer} will do it for you.
@@ -13,8 +14,9 @@ export declare class FlowRServerConnection {
     private readonly name;
     private readonly logger;
     private readonly allowRSessionAccess;
+    private readonly config;
     private readonly fileMap;
-    constructor(socket: Socket, name: string, parser: KnownParser, allowRSessionAccess: boolean);
+    constructor(socket: Socket, name: string, parser: KnownParser, allowRSessionAccess: boolean, config: FlowrConfigOptions);
     private currentMessageBuffer;
     private handleData;
     private handleFileAnalysisRequest;

package/cli/repl/server/connection.js

@@ -71,10 +71,12 @@ class FlowRServerConnection {
     name;
     logger;
     allowRSessionAccess;
+    config;
     // maps token to information
     fileMap = new Map();
     // we do not have to ensure synchronized shell-access as we are always running synchronized
-    constructor(socket, name, parser, allowRSessionAccess) {
+    constructor(socket, name, parser, allowRSessionAccess, config) {
+        this.config = config;
         this.socket = socket;
         this.parser = parser;
         this.name = name;
@@ -160,7 +162,7 @@ class FlowRServerConnection {
     async sendFileAnalysisResponse(slicer, results, message) {
         let cfg = undefined;
         if (message.cfg) {
-            cfg = (0, extract_cfg_1.extractCfg)(results.normalize, results.dataflow?.graph);
+            cfg = (0, extract_cfg_1.extractCfg)(results.normalize, this.config, results.dataflow?.graph);
         }
         const config = () => ({ context: message.filename ?? 'unknown', getId: (0, quads_1.defaultQuadIdGenerator)() });
         const sanitizedResults = sanitizeAnalysisResults(results);
@@ -222,7 +224,7 @@ class FlowRServerConnection {
         const slicer = (0, default_pipelines_1.createSlicePipeline)(this.parser, {
             request,
             criterion: [] // currently unknown
-        });
+        }, this.config);
         if (message.filetoken) {
             this.logger.info(`Storing file token ${message.filetoken}`);
             this.fileMap.set(message.filetoken, {
@@ -286,7 +288,7 @@ class FlowRServerConnection {
                 stream
             });
         };
-        void (0, core_1.replProcessAnswer)({
+        void (0, core_1.replProcessAnswer)(this.config, {
             formatter: request.ansi ? ansi_1.ansiFormatter : ansi_1.voidFormatter,
             stdout: msg => out('stdout', msg),
             stderr: msg => out('stderr', msg)
@@ -346,7 +348,7 @@ class FlowRServerConnection {
         const { dataflow: dfg, normalize: ast } = fileInformation.pipeline.getResults(true);
         (0, assert_1.guard)(dfg !== undefined, `Dataflow graph must be present (request: ${request.filetoken})`);
         (0, assert_1.guard)(ast !== undefined, `AST must be present (request: ${request.filetoken})`);
-        const results = (0, query_1.executeQueries)({ dataflow: dfg, ast }, request.query);
+        const results = (0, query_1.executeQueries)({ dataflow: dfg, ast, config: this.config }, request.query);
         (0, send_1.sendMessage)(this.socket, {
             type: 'response-query',
             id: request.id,

package/cli/repl/server/server.d.ts

@@ -1,6 +1,6 @@
 import type { Server } from './net';
 import { FlowrLogger } from '../../../util/log';
-import type { KnownEngines } from '../../../config';
+import type { FlowrConfigOptions, KnownEngines } from '../../../config';
 export declare const serverLog: FlowrLogger;
 /**
  * This class controls the TCP server, which can be started by calling {@link start}.
@@ -13,10 +13,11 @@ export declare class FlowRServer {
     private readonly defaultEngine;
     private versionInformation;
     private readonly allowRSessionAccess;
+    private readonly config;
     /** maps names to the respective connection */
     private readonly connections;
     private nameCounter;
-    constructor(engines: KnownEngines, defaultEngine: keyof KnownEngines, allowRSessionAccess: boolean, server?: Server);
+    constructor(engines: KnownEngines, defaultEngine: keyof KnownEngines, allowRSessionAccess: boolean, config: FlowrConfigOptions, server?: Server);
     start(port: number): Promise<void>;
     private onConnect;
 }

package/cli/repl/server/server.js

@@ -19,15 +19,17 @@ class FlowRServer {
     defaultEngine;
     versionInformation;
     allowRSessionAccess;
+    config;
     /** maps names to the respective connection */
     connections = new Map();
     nameCounter = 0;
-    constructor(engines, defaultEngine, allowRSessionAccess, server = new net_1.NetServer()) {
+    constructor(engines, defaultEngine, allowRSessionAccess, config, server = new net_1.NetServer()) {
         this.server = server;
         this.server.onConnect(c => this.onConnect(c));
         this.engines = engines;
         this.defaultEngine = defaultEngine;
         this.allowRSessionAccess = allowRSessionAccess;
+        this.config = config;
     }
     async start(port) {
         this.versionInformation = await (0, repl_version_1.retrieveVersionInformation)(this.engines[this.defaultEngine]);
@@ -41,7 +43,7 @@ class FlowRServer {
         }
         const name = `client-${this.nameCounter++}`;
         exports.serverLog.info(`Client connected: ${(0, send_1.getUnnamedSocketName)(c)} as "${name}"`);
-        this.connections.set(name, new connection_1.FlowRServerConnection(c, name, this.engines[this.defaultEngine], this.allowRSessionAccess));
+        this.connections.set(name, new connection_1.FlowRServerConnection(c, name, this.engines[this.defaultEngine], this.allowRSessionAccess, this.config));
         helloClient(c, name, this.versionInformation);
         c.on('close', () => {
             this.connections.delete(name);

package/cli/script-core/statistics-core.d.ts

@@ -1,2 +1,3 @@
 import type { StatsCliOptions } from '../statistics-app';
-export declare function flowrScriptGetStats(options: StatsCliOptions): Promise<void>;
+import type { FlowrConfigOptions } from '../../config';
+export declare function flowrScriptGetStats(options: StatsCliOptions, config: FlowrConfigOptions): Promise<void>;

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

@@ -57,7 +57,7 @@ async function collectFileArguments(options, verboseAdd, dumpJson, features) {
     console.log(`Total: ${counter} files (${skipped} skipped with archive existing)`);
     return files;
 }
-async function flowrScriptGetStats(options) {
+async function flowrScriptGetStats(options, config) {
     if (options.input.length === 0) {
         console.error('No input files given. Nothing to do. See \'--help\' if this is an error.');
         process.exit(0);
@@ -93,7 +93,7 @@ async function flowrScriptGetStats(options) {
     else {
         console.log('Run Sequentially as parallel <= 0...');
         for (const arg of args) {
-            await (0, statistics_helper_core_1.getStatsForSingleFile)((0, command_line_args_1.default)(scripts_info_1.scripts['stats-helper'].options, { argv: arg }));
+            await (0, statistics_helper_core_1.getStatsForSingleFile)((0, command_line_args_1.default)(scripts_info_1.scripts['stats-helper'].options, { argv: arg }), config);
         }
     }
 }

package/cli/script-core/statistics-helper-core.d.ts

@@ -1,2 +1,3 @@
 import type { StatsHelperCliOptions } from '../statistics-helper-app';
-export declare function getStatsForSingleFile(options: StatsHelperCliOptions): Promise<void>;
+import type { FlowrConfigOptions } from '../../config';
+export declare function getStatsForSingleFile(options: StatsHelperCliOptions, config: FlowrConfigOptions): Promise<void>;

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

@@ -20,6 +20,7 @@ const assert_1 = require("../../util/assert");
 const time_1 = require("../../util/text/time");
 const tar_1 = require("tar");
 const ansi_1 = require("../../util/text/ansi");
+const config_1 = require("../../config");
 function compressFolder(folder, target) {
     return (0, tar_1.create)({
         gzip: true,
@@ -35,7 +36,7 @@ function compressFolder(folder, target) {
         console.error('Error during compression:', e);
     });
 }
-async function getStatsForSingleFile(options) {
+async function getStatsForSingleFile(options, config) {
     if (options['no-ansi']) {
         log_1.log.info('disabling ansi colors');
         (0, ansi_1.setFormatter)(ansi_1.voidFormatter);
@@ -50,15 +51,15 @@ async function getStatsForSingleFile(options) {
     }
     // assume correct
     const processedFeatures = new Set(options.features);
-    const shell = new shell_1.RShell();
+    const shell = new shell_1.RShell((0, config_1.getEngineConfig)(config, 'r-shell'));
     (0, statistics_file_1.initFileProvider)(options['output-dir']);
     await shell.obtainTmpDir();
-    const stats = await (0, statistics_1.extractUsageStatistics)(shell, () => { }, processedFeatures, (0, statistics_1.staticRequests)({ request: 'file', content: options.input }), options['root-dir']);
+    const stats = await (0, statistics_1.extractUsageStatistics)(shell, config, () => { }, processedFeatures, (0, statistics_1.staticRequests)({ request: 'file', content: options.input }), options['root-dir']);
     // console.warn(`skipped ${stats.meta.failedRequests.length} requests due to errors (run with logs to get more info)`)
     if (stats.outputs.size === 1) {
         if (options['dump-json']) {
             const [, output] = [...stats.outputs.entries()][0];
-            const cfg = (0, extract_cfg_1.extractCfg)(output.normalize, output.dataflow.graph);
+            const cfg = (0, extract_cfg_1.extractCfg)(output.normalize, config, 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/cli/slicer-app.js

@@ -14,6 +14,7 @@ const slicer_1 = require("../benchmark/slicer");
 const print_1 = require("../benchmark/stats/print");
 const magic_comments_1 = require("../reconstruct/auto-select/magic-comments");
 const auto_select_defaults_1 = require("../reconstruct/auto-select/auto-select-defaults");
+const config_1 = require("../config");
 const options = (0, script_1.processCommandLineArgs)('slicer', ['input', 'criterion'], {
     subtitle: 'Slice R code based on a given slicing criterion',
     examples: [
@@ -28,9 +29,10 @@ async function getSlice() {
     const slicer = new slicer_1.BenchmarkSlicer('r-shell');
     (0, assert_1.guard)(options.input !== undefined, 'input must be given');
     (0, assert_1.guard)(options.criterion !== undefined, 'a slicing criterion must be given');
+    const config = (0, config_1.getConfig)();
     await slicer.init(options['input-is-text']
         ? { request: 'text', content: options.input.replaceAll('\\n', '\n') }
-        : { request: 'file', content: options.input }, options['no-magic-comments'] ? auto_select_defaults_1.doNotAutoSelect : (0, magic_comments_1.makeMagicCommentHandler)(auto_select_defaults_1.doNotAutoSelect));
+        : { request: 'file', content: options.input }, config, options['no-magic-comments'] ? auto_select_defaults_1.doNotAutoSelect : (0, magic_comments_1.makeMagicCommentHandler)(auto_select_defaults_1.doNotAutoSelect));
     let mappedSlices = [];
     let reconstruct = undefined;
     const doSlicing = options.criterion.trim() !== '';
@@ -58,7 +60,7 @@ async function getSlice() {
     const { stats, normalize, parse, tokenMap, dataflow } = slicer.finish();
     const mappedCriteria = mappedSlices.map(c => `    ${c.criterion} => ${c.id} (${JSON.stringify(normalize.idMap.get(c.id)?.location)})`).join('\n');
     log_1.log.info(`Mapped criteria:\n${mappedCriteria}`);
-    const sliceStatsAsString = (0, print_1.stats2string)(await (0, process_1.summarizeSlicerStats)(stats));
+    const sliceStatsAsString = (0, print_1.stats2string)(await (0, process_1.summarizeSlicerStats)(stats, undefined, (0, config_1.getEngineConfig)(config, 'r-shell')));
     if (options.api) {
         const output = {
             tokenMap,

package/cli/statistics-app.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const script_1 = require("./common/script");
 const statistics_core_1 = require("./script-core/statistics-core");
+const config_1 = require("../config");
 const scriptOptions = (0, script_1.processCommandLineArgs)('stats', [], {
     subtitle: 'Given input files or folders, this will collect usage statistics for the given features and write them to a file',
     examples: [
@@ -11,5 +12,5 @@ const scriptOptions = (0, script_1.processCommandLineArgs)('stats', [], {
         '{bold --help}'
     ]
 });
-void (0, statistics_core_1.flowrScriptGetStats)(scriptOptions);
+void (0, statistics_core_1.flowrScriptGetStats)(scriptOptions, (0, config_1.getConfig)());
 //# sourceMappingURL=statistics-app.js.map

package/cli/statistics-helper-app.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const script_1 = require("./common/script");
 const statistics_helper_core_1 = require("./script-core/statistics-helper-core");
+const config_1 = require("../config");
 const scriptOptions = (0, script_1.processCommandLineArgs)('stats-helper', [], {
     subtitle: 'Given a single input file, this will collect usage statistics for the given features and write them to a file',
     examples: [
@@ -9,5 +10,5 @@ const scriptOptions = (0, script_1.processCommandLineArgs)('stats-helper', [], {
         '{bold --help}'
     ]
 });
-void (0, statistics_helper_core_1.getStatsForSingleFile)(scriptOptions);
+void (0, statistics_helper_core_1.getStatsForSingleFile)(scriptOptions, (0, config_1.getConfig)());
 //# sourceMappingURL=statistics-helper-app.js.map

package/config.d.ts

@@ -2,7 +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';
+import type { DeepWritable } from 'ts-essentials';
 export declare enum VariableResolve {
     /** Don't resolve constants at all */
     Disabled = "disabled",
@@ -47,7 +47,7 @@ export interface FlowrLaxSourcingOptions extends MergeableRecord {
     /**
      * Additionally search in these paths
      */
-    readonly searchPath: readonly string[];
+    readonly searchPath: string[];
     /**
      * Allow to drop the first or all parts of the sourced path,
      * if it is relative.
@@ -77,7 +77,7 @@ export interface FlowrLaxSourcingOptions extends MergeableRecord {
      * - `foo bar.R` (original name)
      * - `main.R` (replaced with main.R)
      * - `foo_bar.R` (replaced spaces)
-     * - `foo-bar.R` (replaced spaces and oo)
+     * - `faa-bar.R` (replaced spaces and oo)
      */
     readonly applyReplacements?: Record<string, string>[];
 }
@@ -103,7 +103,7 @@ export interface FlowrConfigOptions extends MergeableRecord {
      * The engines to use for interacting with R code. Currently, supports {@link TreeSitterEngineConfig} and {@link RShellEngineConfig}.
      * An empty array means all available engines will be used.
      */
-    readonly engines: readonly EngineConfig[];
+    readonly engines: EngineConfig[];
     /**
      * The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from {@link engines} will be used.
      */
@@ -174,12 +174,14 @@ export type KnownEngines = {
 };
 export declare const defaultConfigOptions: FlowrConfigOptions;
 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: DeepPartial<FlowrConfigOptions>): void;
-export declare function getConfig(): FlowrConfigOptions;
-export declare function getEngineConfig<T extends EngineConfig['type']>(engine: T): EngineConfig & {
+/**
+ * Creates a new flowr config that has the updated values.
+ */
+export declare function amendConfig(config: FlowrConfigOptions, amendmentFunc: (config: DeepWritable<FlowrConfigOptions>) => FlowrConfigOptions): FlowrConfigOptions;
+export declare function cloneConfig(config: FlowrConfigOptions): FlowrConfigOptions;
+export declare function getConfig(configFile?: string, configWorkingDirectory?: string): FlowrConfigOptions;
+export declare function getEngineConfig<T extends EngineConfig['type']>(config: FlowrConfigOptions, engine: T): EngineConfig & {
     type: T;
 } | undefined;
-export declare function isOverPointerAnalysisThreshold(count: number): boolean;
+export declare function isOverPointerAnalysisThreshold(config: FlowrConfigOptions, count: number): boolean;

package/config.js

@@ -4,10 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrConfigFileSchema = exports.defaultConfigOptions = exports.DropPathsOption = exports.InferWorkingDirectory = exports.VariableResolve = void 0;
-exports.setConfigFile = setConfigFile;
 exports.parseConfig = parseConfig;
-exports.setConfig = setConfig;
 exports.amendConfig = amendConfig;
+exports.cloneConfig = cloneConfig;
 exports.getConfig = getConfig;
 exports.getEngineConfig = getEngineConfig;
 exports.isOverPointerAnalysisThreshold = isOverPointerAnalysisThreshold;
@@ -67,7 +66,7 @@ exports.defaultConfigOptions = {
         }
     },
     engines: [],
-    defaultEngine: 'r-shell',
+    defaultEngine: 'tree-sitter',
     solver: {
         variables: VariableResolve.Alias,
         evalStrings: true,
@@ -123,19 +122,6 @@ exports.flowrConfigFileSchema = joi_1.default.object({
         }).optional().description('The configuration for the slicer.')
     }).description('How to resolve constants, constraints, cells, ...')
 }).description('The configuration file format for flowR.');
-// we don't load from a config file at all by default unless setConfigFile is called
-let configFile = undefined;
-let configWorkingDirectory = process.cwd();
-let currentConfig = undefined;
-function setConfigFile(file, workingDirectory = process.cwd(), forceLoad = false) {
-    configFile = file;
-    configWorkingDirectory = workingDirectory;
-    // reset the config so it gets reloaded
-    currentConfig = undefined;
-    if (forceLoad) {
-        getConfig();
-    }
-}
 function parseConfig(jsonString) {
     try {
         const parsed = JSON.parse(jsonString);
@@ -153,46 +139,44 @@ function parseConfig(jsonString) {
         log_1.log.error(`Failed to parse config ${jsonString}: ${e.message}`);
     }
 }
-function setConfig(config) {
-    currentConfig = config;
+/**
+ * Creates a new flowr config that has the updated values.
+ */
+function amendConfig(config, amendmentFunc) {
+    return amendmentFunc(cloneConfig(config));
 }
-function amendConfig(amendment) {
-    setConfig((0, objects_1.deepMergeObject)(getConfig(), amendment));
-    log_1.log.trace(`Amending config with ${JSON.stringify(amendment)}, resulting in ${JSON.stringify(getConfig())}}`);
+function cloneConfig(config) {
+    return JSON.parse(JSON.stringify(config));
 }
-function getConfig() {
-    // lazy-load the config based on the current settings
-    if (currentConfig === undefined) {
-        try {
-            setConfig(loadConfigFromFile(configFile, configWorkingDirectory));
-        }
-        catch (e) {
-            log_1.log.error(`Failed to load config: ${e.message}`);
-            setConfig(exports.defaultConfigOptions);
-        }
+function getConfig(configFile, configWorkingDirectory = process.cwd()) {
+    try {
+        return loadConfigFromFile(configFile, configWorkingDirectory);
+    }
+    catch (e) {
+        log_1.log.error(`Failed to load config: ${e.message}`);
+        return exports.defaultConfigOptions;
     }
-    return currentConfig;
 }
-function getEngineConfig(engine) {
-    const config = getConfig().engines;
-    if (!config.length) {
+function getEngineConfig(config, engine) {
+    const engines = config.engines;
+    if (!engines.length) {
         return defaultEngineConfigs[engine];
     }
     else {
-        return config.find(e => e.type == engine);
+        return engines.find(e => e.type == engine);
     }
 }
-function getPointerAnalysisThreshold() {
-    const config = getConfig().solver.pointerTracking;
-    if (typeof config === 'object') {
-        return config.maxIndexCount;
+function getPointerAnalysisThreshold(config) {
+    const pointerTracking = config.solver.pointerTracking;
+    if (typeof pointerTracking === 'object') {
+        return pointerTracking.maxIndexCount;
     }
     else {
-        return config ? 'unlimited' : 'disabled';
+        return pointerTracking ? 'unlimited' : 'disabled';
     }
 }
-function isOverPointerAnalysisThreshold(count) {
-    const threshold = getPointerAnalysisThreshold();
+function isOverPointerAnalysisThreshold(config, count) {
+    const threshold = getPointerAnalysisThreshold(config);
     return threshold !== 'unlimited' && (threshold === 'disabled' || count > threshold);
 }
 function loadConfigFromFile(configFile, workingDirectory) {

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

@@ -1,7 +1,7 @@
 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;
+export interface BasicCfgGuidedVisitorConfiguration<ControlFlow extends ControlFlowInformation = ControlFlowInformation> {
+    readonly controlFlow: ControlFlow;
     readonly defaultVisitingOrder: 'forward' | 'backward';
 }
 /**
@@ -11,7 +11,7 @@ export interface BasicCfgGuidedVisitorConfiguration<Cfg extends ControlFlowInfor
  *
  * Use {@link BasicCfgGuidedVisitor#start} to start the traversal.
  */
-export declare class BasicCfgGuidedVisitor<Cfg extends ControlFlowInformation = ControlFlowInformation, Config extends BasicCfgGuidedVisitorConfiguration<Cfg> = BasicCfgGuidedVisitorConfiguration<Cfg>> {
+export declare class BasicCfgGuidedVisitor<ControlFlow extends ControlFlowInformation = ControlFlowInformation, Config extends BasicCfgGuidedVisitorConfiguration<ControlFlow> = BasicCfgGuidedVisitorConfiguration<ControlFlow>> {
     protected readonly config: Config;
     protected readonly visited: Map<NodeId, number>;
     constructor(config: Config);

package/control-flow/cfg-dead-code.d.ts

@@ -0,0 +1,4 @@
+import type { ControlFlowInformation } from './control-flow-graph';
+import type { CfgPassInfo } from './cfg-simplification';
+/** Breaks unsatisfiable control dependencies */
+export declare function cfgAnalyzeDeadCode(cfg: ControlFlowInformation, info: CfgPassInfo): ControlFlowInformation;

package/control-flow/cfg-dead-code.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cfgAnalyzeDeadCode = cfgAnalyzeDeadCode;
+const logic_1 = require("../util/logic");
+const semantic_cfg_guided_visitor_1 = require("./semantic-cfg-guided-visitor");
+const alias_tracking_1 = require("../dataflow/eval/resolve/alias-tracking");
+const log_1 = require("../util/log");
+const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const general_1 = require("../dataflow/eval/values/general");
+const r_value_1 = require("../dataflow/eval/values/r-value");
+class CfgConditionalDeadCodeRemoval extends semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor {
+    cachedConditions = new Map();
+    cachedStatements = new Map();
+    getValue(id) {
+        const has = this.cachedConditions.get(id);
+        if (has) {
+            return has;
+        }
+        this.visitNode(id);
+        return this.cachedConditions.get(id) ?? logic_1.Ternary.Maybe;
+    }
+    isUnconditionalJump(id) {
+        const has = this.cachedStatements.get(id);
+        if (has) {
+            return has;
+        }
+        this.visitNode(id);
+        return this.cachedStatements.get(id) ?? false;
+    }
+    unableToCalculateValue(id) {
+        this.cachedConditions.set(id, logic_1.Ternary.Maybe);
+    }
+    storeDefiniteValue(id, value) {
+        this.cachedConditions.set(id, value ? logic_1.Ternary.Always : logic_1.Ternary.Never);
+    }
+    startVisitor() {
+        for (const [from, targets] of this.config.controlFlow.graph.edges()) {
+            for (const [target, edge] of targets) {
+                if (edge.label === 1 /* CfgEdgeType.Cd */) {
+                    const og = this.getValue(edge.caused);
+                    if (og === logic_1.Ternary.Always && edge.when === 'FALSE') {
+                        this.config.controlFlow.graph.removeEdge(from, target);
+                    }
+                    else if (og === logic_1.Ternary.Never && edge.when === 'TRUE') {
+                        this.config.controlFlow.graph.removeEdge(from, target);
+                    }
+                }
+                else if (edge.label === 0 /* CfgEdgeType.Fd */) {
+                    if (this.isUnconditionalJump(target)) {
+                        this.config.controlFlow.graph.removeEdge(from, target);
+                    }
+                }
+            }
+        }
+    }
+    handleValuesFor(id, valueId) {
+        const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(valueId, { graph: this.config.dfg, full: true, idMap: this.config.normalizedAst.idMap, resolve: this.config.flowrConfig.solver.variables }));
+        if (values === undefined || values.elements.length !== 1 || values.elements[0].type != 'logical' || !(0, r_value_1.isValue)(values.elements[0].value)) {
+            this.unableToCalculateValue(id);
+            return;
+        }
+        /* we should translate this to truthy later */
+        this.storeDefiniteValue(id, Boolean(values.elements[0].value));
+    }
+    handleWithCondition(data) {
+        const id = data.call.id;
+        if (data.condition === undefined || data.condition === r_function_call_1.EmptyArgument) {
+            this.unableToCalculateValue(id);
+            return;
+        }
+        this.handleValuesFor(id, typeof data.condition === 'object' ? data.condition.nodeId : data.condition);
+    }
+    getBoolArgValue(data) {
+        if (data.call.args.length !== 1 || data.call.args[0] === r_function_call_1.EmptyArgument) {
+            return undefined;
+        }
+        const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(data.call.args[0].nodeId, { graph: this.config.dfg, full: true, idMap: this.config.normalizedAst.idMap, resolve: this.config.flowrConfig.solver.variables }));
+        if (values === undefined || values.elements.length !== 1 || values.elements[0].type != 'logical' || !(0, r_value_1.isValue)(values.elements[0].value)) {
+            return undefined;
+        }
+        return Boolean(values.elements[0].value);
+    }
+    handleFunctionCall(data) {
+        switch (data.call.origin[0]) {
+            case 'builtin:return':
+            case 'builtin:stop':
+                this.cachedStatements.set(data.call.id, true);
+                break;
+            case 'builtin:stopifnot': {
+                const arg = this.getBoolArgValue(data);
+                if (arg !== undefined) {
+                    this.cachedStatements.set(data.call.id, !arg);
+                }
+                break;
+            }
+        }
+    }
+    onIfThenElseCall(data) {
+        this.handleWithCondition(data);
+    }
+    onWhileLoopCall(data) {
+        this.handleWithCondition(data);
+    }
+    onDefaultFunctionCall(data) {
+        this.handleFunctionCall(data);
+    }
+}
+/** Breaks unsatisfiable control dependencies */
+function cfgAnalyzeDeadCode(cfg, info) {
+    if (!info.ast || !info.dfg) {
+        log_1.log.warn('cfgAnalyzeDeadCode called without ast or dfg, skipping dead code analysis');
+        return cfg;
+    }
+    const visitor = new CfgConditionalDeadCodeRemoval({
+        controlFlow: cfg,
+        normalizedAst: info.ast,
+        dfg: info.dfg,
+        flowrConfig: info.config,
+        defaultVisitingOrder: 'forward',
+    });
+    visitor.start();
+    return cfg;
+}
+//# sourceMappingURL=cfg-dead-code.js.map

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

@@ -1,7 +1,17 @@
 import type { ControlFlowInformation } from './control-flow-graph';
-export type CfgSimplificationPass = (cfg: ControlFlowInformation) => ControlFlowInformation;
-declare const CfgSimplificationPasses: {
+import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { DataflowGraph } from '../dataflow/graph/graph';
+import { cfgAnalyzeDeadCode } from './cfg-dead-code';
+import type { FlowrConfigOptions } from '../config';
+export interface CfgPassInfo {
+    ast?: NormalizedAst;
+    dfg?: DataflowGraph;
+    config: FlowrConfigOptions;
+}
+export type CfgSimplificationPass = (cfg: ControlFlowInformation, info: CfgPassInfo) => ControlFlowInformation;
+export declare const CfgSimplificationPasses: {
     readonly 'unique-cf-sets': typeof uniqueControlFlowSets;
+    readonly 'analyze-dead-code': typeof cfgAnalyzeDeadCode;
     readonly 'remove-dead-code': typeof cfgRemoveDeadCode;
     readonly 'to-basic-blocks': typeof toBasicBlocks;
 };
@@ -11,8 +21,11 @@ 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 declare function simplifyControlFlowInformation(cfg: ControlFlowInformation, info: CfgPassInfo, passes?: readonly CfgSimplificationPassName[]): ControlFlowInformation;
+/**
+ * removes dead vertices and edges from the control flow graph.
+ */
+declare function cfgRemoveDeadCode(cfg: ControlFlowInformation, _info?: CfgPassInfo): ControlFlowInformation;
+declare function uniqueControlFlowSets(cfg: ControlFlowInformation, _info?: CfgPassInfo): ControlFlowInformation;
+declare function toBasicBlocks(cfg: ControlFlowInformation, _info?: CfgPassInfo): ControlFlowInformation;
 export {};