@eagleoutice/flowr 2.10.4 → 2.10.5

package/abstract-interpretation/domains/state-abstract-domain.d.ts

@@ -1,32 +1,33 @@
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { AbstractDomain, type AnyAbstractDomain, type ConcreteDomain } from './abstract-domain';
 import { Bottom, Top } from './lattice';
+import type { StateDomainLike } from './state-domain-like';
 /** The type of the concrete state of the concrete domain of a state abstract domain that maps keys to a concrete value in the concrete domain */
 export type ConcreteState<Domain extends AnyAbstractDomain> = ReadonlyMap<NodeId, ConcreteDomain<Domain>>;
 /** The type of the actual values of the state abstract domain as map of keys to domain values */
-type StateDomainValue<Domain extends AnyAbstractDomain> = ReadonlyMap<NodeId, Domain>;
+export type StateDomainValue<Domain extends AnyAbstractDomain> = ReadonlyMap<NodeId, Domain>;
 /** The type of the Top element of the state abstract domain as (empty) map of keys to domain values */
-type StateDomainTop = ReadonlyMap<NodeId, never>;
+export type StateDomainTop = ReadonlyMap<NodeId, never>;
 /** The type of the Bottom element of the state abstract domain as {@link Bottom} symbol */
-type StateDomainBottom = typeof Bottom;
+export type StateDomainBottom = typeof Bottom;
 /** The type of the abstract values of the state abstract domain that are Top, Bottom, or actual values */
-type StateDomainLift<Domain extends AnyAbstractDomain> = StateDomainValue<Domain> | StateDomainBottom;
+export type StateDomainLift<Domain extends AnyAbstractDomain> = StateDomainValue<Domain> | StateDomainBottom;
 /**
  * A state abstract domain that maps AST node IDs of a program to abstract values of an abstract domain.
  * The Bottom element is defined as {@link Bottom} symbol and the Top element as empty mapping.
  * @template Domain - Type of the value abstract domain to map the AST node IDs to
  * @see {@link NodeId} for the node IDs of the AST nodes
  */
-export declare class StateAbstractDomain<Domain extends AnyAbstractDomain, Value extends StateDomainLift<Domain> = StateDomainLift<Domain>> extends AbstractDomain<ConcreteState<Domain>, StateDomainValue<Domain>, StateDomainTop, StateDomainBottom, Value> {
-    protected domain: Domain;
+export declare class StateAbstractDomain<Domain extends AnyAbstractDomain, Value extends StateDomainLift<Domain> = StateDomainLift<Domain>> extends AbstractDomain<ConcreteState<Domain>, StateDomainValue<Domain>, StateDomainTop, StateDomainBottom, Value> implements StateDomainLike<Domain> {
+    readonly domain: Domain;
     constructor(value: Value, domain: Domain);
     create(value: StateDomainLift<Domain>): this;
-    static top<Domain extends AnyAbstractDomain>(domain: Domain): StateAbstractDomain<Domain, StateDomainTop>;
-    static bottom<Domain extends AnyAbstractDomain>(domain: Domain): StateAbstractDomain<Domain, StateDomainBottom>;
-    get(key: NodeId): Domain | undefined;
-    has(key: NodeId): boolean;
-    protected set(key: NodeId, value: Domain): void;
-    protected remove(key: NodeId): void;
+    static top<Domain extends AnyAbstractDomain, StateDomain extends StateAbstractDomain<Domain, StateDomainTop>>(this: new (value: StateDomainTop, domain: Domain) => StateDomain, domain: Domain): StateDomain;
+    static bottom<Domain extends AnyAbstractDomain, StateDomain extends StateAbstractDomain<Domain, StateDomainBottom>>(this: new (value: StateDomainBottom, domain: Domain) => StateDomain, domain: Domain): StateDomain;
+    get(node: NodeId): Domain | undefined;
+    has(node: NodeId): boolean;
+    set(node: NodeId, value: Domain): void;
+    remove(node: NodeId): void;
     top(): this & StateAbstractDomain<Domain, StateDomainTop>;
     bottom(): this & StateAbstractDomain<Domain, StateDomainBottom>;
     equals(other: this): boolean;
@@ -43,19 +44,3 @@ export declare class StateAbstractDomain<Domain extends AnyAbstractDomain, Value
     isBottom(): this is this & StateAbstractDomain<Domain, StateDomainBottom>;
     isValue(): this is this & StateAbstractDomain<Domain, StateDomainValue<Domain>>;
 }
-/**
- * A mutable version of the {@link StateAbstractDomain} with {@link MutableStateAbstractDomain#set|`set`} and {@link MutableStateAbstractDomain#remove|`remove`}.
- */
-export declare class MutableStateAbstractDomain<Domain extends AnyAbstractDomain, Value extends StateDomainLift<Domain> = StateDomainLift<Domain>> extends StateAbstractDomain<Domain, Value> {
-    create(value: StateDomainLift<Domain>): this;
-    static top<Domain extends AnyAbstractDomain>(domain: Domain): MutableStateAbstractDomain<Domain, StateDomainTop>;
-    static bottom<Domain extends AnyAbstractDomain>(domain: Domain): MutableStateAbstractDomain<Domain, StateDomainBottom>;
-    set(key: NodeId, value: Domain): void;
-    remove(key: NodeId): void;
-}
-/**
- * The type of the value abstract domain of a state abstract domain (i.e. the abstract domain a state abstract domain maps to).
- * @template StateDomain - The state abstract domain to get the value abstract domain type for
- */
-export type ValueAbstractDomain<StateDomain extends StateAbstractDomain<AnyAbstractDomain>> = StateDomain extends StateAbstractDomain<infer Domain> ? Domain : never;
-export {};

package/abstract-interpretation/domains/state-abstract-domain.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MutableStateAbstractDomain = exports.StateAbstractDomain = void 0;
+exports.StateAbstractDomain = void 0;
 const abstract_domain_1 = require("./abstract-domain");
 const lattice_1 = require("./lattice");
 /**
@@ -24,33 +24,32 @@ class StateAbstractDomain extends abstract_domain_1.AbstractDomain {
         return new StateAbstractDomain(value, this.domain);
     }
     static top(domain) {
-        return new StateAbstractDomain(new Map(), domain);
+        return new this(new Map(), domain);
     }
     static bottom(domain) {
-        return new StateAbstractDomain(lattice_1.Bottom, domain);
+        return new this(lattice_1.Bottom, domain);
     }
-    get(key) {
-        return this.value === lattice_1.Bottom ? this.domain.bottom() : this.value.get(key);
+    get(node) {
+        return this.value === lattice_1.Bottom ? this.domain.bottom() : this.value.get(node);
     }
-    has(key) {
-        return this.value !== lattice_1.Bottom && this.value.has(key);
+    has(node) {
+        return this.value !== lattice_1.Bottom && this.value.has(node);
     }
-    set(key, value) {
-        if (this.value === lattice_1.Bottom) {
-            this._value = new Map();
+    set(node, value) {
+        if (this.value !== lattice_1.Bottom) {
+            this._value.set(node, value);
         }
-        this._value.set(key, value);
     }
-    remove(key) {
+    remove(node) {
         if (this.value !== lattice_1.Bottom) {
-            this._value.delete(key);
+            this._value.delete(node);
         }
     }
     top() {
-        return StateAbstractDomain.top(this.domain);
+        return this.create(new Map());
     }
     bottom() {
-        return StateAbstractDomain.bottom(this.domain);
+        return this.create(lattice_1.Bottom);
     }
     equals(other) {
         if (this.value === other.value) {
@@ -216,38 +215,17 @@ class StateAbstractDomain extends abstract_domain_1.AbstractDomain {
         if (this.value === lattice_1.Bottom) {
             return lattice_1.BottomSymbol;
         }
-        return '(' + this.value.entries().toArray().map(([key, value]) => `${(0, abstract_domain_1.domainElementToString)(key)} -> ${value.toString()}`).join(', ') + ')';
+        return '(' + this.value.entries().toArray().map(([key, value]) => `${abstract_domain_1.AbstractDomain.toString(key)} -> ${value.toString()}`).join(', ') + ')';
     }
     isTop() {
         return this.value !== lattice_1.Bottom && this.value.size === 0;
     }
     isBottom() {
-        return this.value == lattice_1.Bottom;
+        return this.value === lattice_1.Bottom;
     }
     isValue() {
         return this.value !== lattice_1.Bottom;
     }
 }
 exports.StateAbstractDomain = StateAbstractDomain;
-/**
- * A mutable version of the {@link StateAbstractDomain} with {@link MutableStateAbstractDomain#set|`set`} and {@link MutableStateAbstractDomain#remove|`remove`}.
- */
-class MutableStateAbstractDomain extends StateAbstractDomain {
-    create(value) {
-        return new MutableStateAbstractDomain(value, this.domain);
-    }
-    static top(domain) {
-        return new MutableStateAbstractDomain(new Map(), domain);
-    }
-    static bottom(domain) {
-        return new MutableStateAbstractDomain(lattice_1.Bottom, domain);
-    }
-    set(key, value) {
-        super.set(key, value);
-    }
-    remove(key) {
-        super.remove(key);
-    }
-}
-exports.MutableStateAbstractDomain = MutableStateAbstractDomain;
 //# sourceMappingURL=state-abstract-domain.js.map

package/abstract-interpretation/domains/state-domain-like.d.ts

@@ -0,0 +1,36 @@
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { type AnyAbstractDomain } from './abstract-domain';
+/**
+ * An interface for state-like domains that store abstract values for AST nodes.
+ */
+export interface StateDomainLike<Domain extends AnyAbstractDomain> {
+    /**
+     * The underlying value domain of the state domain.
+     */
+    get domain(): Domain;
+    /**
+     * Gets the inferred abstract value for an AST node ID.
+     */
+    get(node: NodeId): Domain | undefined;
+    /**
+     * Checks whether the state domain has an inferred value for an AST node ID.
+     */
+    has(node: NodeId): boolean;
+    /**
+     * Removes the inferred value for an AST node ID from the state domain.
+     */
+    remove(node: NodeId): void;
+    /**
+     * Sets the inferred value for an AST node ID from the state domain.
+     */
+    set(node: NodeId, value: Domain): void;
+}
+/**
+ * A type representing any state abstract domain that stores abstract values for AST nodes.
+ */
+export type AnyStateDomain<Domain extends AnyAbstractDomain> = AnyAbstractDomain & StateDomainLike<Domain>;
+/**
+ * The type of the value abstract domain of a state abstract domain.
+ * @template StateDomain - The state abstract domain to get the value abstract domain type for
+ */
+export type ValueDomain<StateDomain extends AnyStateDomain<AnyAbstractDomain>> = StateDomain extends AnyStateDomain<infer Domain> ? Domain : never;

package/abstract-interpretation/domains/state-domain-like.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=state-domain-like.js.map

package/cli/flowr.js

@@ -102,6 +102,15 @@ function hookSignalHandlers(engines) {
     process.on('SIGINT', end);
     process.on('SIGTERM', end);
 }
+function getReplPlugins(config) {
+    const plugins = config.repl.plugins.filter(p => p !== 'flowr:default');
+    if (plugins.length !== config.repl.plugins.length) {
+        return plugins.concat(config.defaultPlugins);
+    }
+    else {
+        return plugins;
+    }
+}
 async function mainRepl() {
     const config = createConfig();
     if (options.script) {
@@ -128,9 +137,10 @@ async function mainRepl() {
         process.exit(0);
     }
     hookSignalHandlers(engines);
-    const analyzer = new flowr_analyzer_builder_1.FlowrAnalyzerBuilder()
+    const analyzer = new flowr_analyzer_builder_1.FlowrAnalyzerBuilder(false)
         .setParser(defaultEngine)
         .setConfig(config)
+        .registerPlugins(...getReplPlugins(config))
         .buildSync();
     const allowRSessionAccess = options['r-session-access'] ?? false;
     if (options.execute) {

package/config.d.ts

@@ -6,6 +6,7 @@ import type { DeepWritable, Paths, PathValue } from 'ts-essentials';
 import type { DataflowProcessors } from './dataflow/processor';
 import type { ParentInformation } from './r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { FlowrAnalyzerContext } from './project/context/flowr-analyzer-context';
+import type { BuiltInFlowrPluginArgs, BuiltInFlowrPluginName } from './project/plugins/plugin-registry';
 export declare enum VariableResolve {
     /** Don't resolve constants at all */
     Disabled = "disabled",
@@ -83,6 +84,7 @@ export interface FlowrLaxSourcingOptions extends MergeableRecord {
      */
     readonly applyReplacements?: Record<string, string>[];
 }
+export type ConfigPlugin<T extends BuiltInFlowrPluginName | string> = T | string | (T extends BuiltInFlowrPluginName ? [T, BuiltInFlowrPluginArgs<T>] : [string, unknown[]]);
 /**
  * The configuration file format for flowR.
  * @see {@link FlowrConfig.default} for the default configuration.
@@ -106,12 +108,16 @@ export interface FlowrConfig extends MergeableRecord {
             };
         };
     };
+    /** Plugins to load by default when creating a new FlowrAnalyzer */
+    readonly defaultPlugins: ConfigPlugin<string>[];
     /** Configuration options for the REPL */
     readonly repl: {
         /** Whether to show quick stats in the REPL after each evaluation */
         quickStats: boolean;
         /** This instruments the dataflow processors to count how often each processor is called */
         dfProcessorHeat: boolean;
+        /** Plugins to load in REPL mode */
+        plugins: (ConfigPlugin<string> | 'flowr:default')[];
     };
     readonly project: {
         /** Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files */
@@ -226,6 +232,7 @@ export type EngineConfig = TreeSitterEngineConfig | RShellEngineConfig;
 export type KnownEngines = {
     [T in EngineConfig['type']]?: KnownParser;
 };
+export declare const FlowrDefaultPlugins: string[];
 /**
  * Helper Object to work with {@link FlowrConfig}, provides the default config and the Joi schema for validation.
  */

package/config.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowrConfig = exports.DropPathsOption = exports.InferWorkingDirectory = exports.VariableResolve = void 0;
+exports.FlowrConfig = exports.FlowrDefaultPlugins = exports.DropPathsOption = exports.InferWorkingDirectory = exports.VariableResolve = void 0;
 const objects_1 = require("./util/objects");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
@@ -50,6 +50,21 @@ const defaultEngineConfigs = {
     'tree-sitter': { type: 'tree-sitter' },
     'r-shell': { type: 'r-shell' }
 };
+exports.FlowrDefaultPlugins = [
+    'file:description',
+    'versions:description',
+    'loading-order:description',
+    'meta:description',
+    'files:vignette',
+    'files:test',
+    'file:rmd',
+    'file:qmd',
+    'file:rnw',
+    'file:ipynb',
+    'file:namespace',
+    'file:news',
+    'file:license',
+];
 /**
  * Helper Object to work with {@link FlowrConfig}, provides the default config and the Joi schema for validation.
  */
@@ -70,9 +85,11 @@ exports.FlowrConfig = {
                     }
                 }
             },
+            defaultPlugins: exports.FlowrDefaultPlugins,
             repl: {
                 quickStats: false,
-                dfProcessorHeat: false
+                dfProcessorHeat: false,
+                plugins: ['flowr:default'],
             },
             project: {
                 resolveUnknownPathsOnDisk: true
@@ -122,9 +139,11 @@ exports.FlowrConfig = {
                 }).optional().description('Do you want to overwrite (parts) of the builtin definition?')
             }).optional().description('Semantics regarding how to handle the R environment.')
         }).description('Configure language semantics and how flowR handles them.'),
+        defaultPlugins: joi_1.default.array().items(joi_1.default.alternatives().try(joi_1.default.string(), joi_1.default.array().ordered(joi_1.default.string(), joi_1.default.array().items(joi_1.default.any())).length(2))).optional().description('The default plugins to load when creating a new instance of FlowrAnalyzer'),
         repl: joi_1.default.object({
             quickStats: joi_1.default.boolean().optional().description('Whether to show quick stats in the REPL after each evaluation.'),
-            dfProcessorHeat: joi_1.default.boolean().optional().description('This instruments the dataflow processors to count how often each processor is called.')
+            dfProcessorHeat: joi_1.default.boolean().optional().description('This instruments the dataflow processors to count how often each processor is called.'),
+            plugins: joi_1.default.array().items(joi_1.default.alternatives().try(joi_1.default.string(), joi_1.default.array().ordered(joi_1.default.string(), joi_1.default.array().items(joi_1.default.any())).length(2))).optional().description('The plugins to load in REPL mode')
         }).description('Configuration options for the REPL.'),
         project: joi_1.default.object({
             resolveUnknownPathsOnDisk: joi_1.default.boolean().optional().description('Whether to resolve unknown paths loaded by the r project disk when trying to source/analyze files.')

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

@@ -572,4 +572,8 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, ControlFlow ex
     protected onPurrFormulaCall(_data: {
         call: DataflowGraphVertexFunctionCall;
     }): void;
+    protected getSourceAndTarget(call: DataflowGraphVertexFunctionCall): {
+        target: NodeId | undefined;
+        source: NodeId | undefined;
+    };
 }

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

@@ -200,22 +200,8 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
                 return this.onVectorCall({ call });
             case built_in_proc_name_1.BuiltInProcName.Assignment:
             case built_in_proc_name_1.BuiltInProcName.AssignmentLike:
-            case built_in_proc_name_1.BuiltInProcName.TableAssignment: {
-                const outgoing = this.config.dfg.outgoingEdges(call.id);
-                if (outgoing) {
-                    const target = outgoing.entries().filter(([, e]) => edge_1.DfEdge.includesType(e, edge_1.EdgeType.Returns)).toArray();
-                    if (target.length === 1) {
-                        const targetOut = this.config.dfg.outgoingEdges(target[0][0]);
-                        if (targetOut) {
-                            const source = targetOut.entries().filter(([t, e]) => edge_1.DfEdge.includesType(e, edge_1.EdgeType.DefinedBy) && t !== call.id).toArray();
-                            if (source.length === 1) {
-                                return this.onAssignmentCall({ call, target: target[0][0], source: source[0][0] });
-                            }
-                        }
-                    }
-                }
-                return this.onAssignmentCall({ call, target: undefined, source: undefined });
-            }
+            case built_in_proc_name_1.BuiltInProcName.TableAssignment:
+                return this.onAssignmentCall({ call, ...this.getSourceAndTarget(call) });
             case built_in_proc_name_1.BuiltInProcName.SpecialBinOp:
                 if (call.args.length !== 2) {
                     return this.onSpecialBinaryOpCall({ call });
@@ -234,22 +220,8 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
                 return this.onRepeatLoopCall({ call, body: call.args[0] });
             case built_in_proc_name_1.BuiltInProcName.WhileLoop:
                 return this.onWhileLoopCall({ call, condition: call.args[0], body: call.args[1] });
-            case built_in_proc_name_1.BuiltInProcName.Replacement: {
-                const outgoing = this.config.dfg.outgoingEdges(call.id);
-                if (outgoing) {
-                    const target = outgoing.entries().filter(([, e]) => edge_1.DfEdge.includesType(e, edge_1.EdgeType.Returns)).toArray();
-                    if (target.length === 1) {
-                        const targetOut = this.config.dfg.outgoingEdges(target[0][0]);
-                        if (targetOut) {
-                            const source = targetOut.entries().filter(([t, e]) => edge_1.DfEdge.includesType(e, edge_1.EdgeType.DefinedBy) && t !== call.id).toArray();
-                            if (source.length === 1) {
-                                return this.onReplacementCall({ call, target: target[0][0], source: source[0][0] });
-                            }
-                        }
-                    }
-                }
-                return this.onReplacementCall({ call, target: undefined, source: undefined });
-            }
+            case built_in_proc_name_1.BuiltInProcName.Replacement:
+                return this.onReplacementCall({ call, ...this.getSourceAndTarget(call) });
             case built_in_proc_name_1.BuiltInProcName.Library:
                 return this.onLibraryCall({ call });
             case built_in_proc_name_1.BuiltInProcName.Try:
@@ -646,6 +618,22 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
      * This event triggers for any purr formula as in `map(df, ~ .x + 1)`
      */
     onPurrFormulaCall(_data) { }
+    getSourceAndTarget(call) {
+        const outgoing = this.config.dfg.outgoingEdges(call.id);
+        if (outgoing !== undefined) {
+            const target = outgoing.entries().filter(([, e]) => edge_1.DfEdge.includesType(e, edge_1.EdgeType.Returns)).toArray();
+            if (target.length === 1) {
+                const targetOut = this.config.dfg.outgoingEdges(target[0][0]);
+                if (targetOut !== undefined) {
+                    const source = targetOut.entries().filter(([t, e]) => edge_1.DfEdge.includesType(e, edge_1.EdgeType.DefinedBy) && t !== call.id).toArray();
+                    if (source.length === 1) {
+                        return { target: target[0][0], source: source[0][0] };
+                    }
+                }
+            }
+        }
+        return { target: undefined, source: undefined };
+    }
 }
 exports.SemanticCfgGuidedVisitor = SemanticCfgGuidedVisitor;
 //# sourceMappingURL=semantic-cfg-guided-visitor.js.map

package/dataflow/environments/default-builtin-config.d.ts

@@ -234,6 +234,16 @@ export declare const DefaultBuiltinConfig: [{
     readonly processor: BuiltInProcName.Eval;
     readonly config: {
         readonly includeFunctionCall: true;
+        readonly supportFunctionCall: false;
+    };
+    readonly assumePrimitive: true;
+}, {
+    readonly type: "function";
+    readonly names: ["evalText"];
+    readonly processor: BuiltInProcName.Eval;
+    readonly config: {
+        readonly includeFunctionCall: true;
+        readonly supportFunctionCall: true;
     };
     readonly assumePrimitive: true;
 }, {

package/dataflow/environments/default-builtin-config.js

@@ -231,7 +231,8 @@ exports.DefaultBuiltinConfig = [
                 '.Fortran': ['.NAME']
             }
         }, assumePrimitive: true },
-    { type: 'function', names: ['eval'], processor: built_in_proc_name_1.BuiltInProcName.Eval, config: { includeFunctionCall: true }, assumePrimitive: true },
+    { type: 'function', names: ['eval'], processor: built_in_proc_name_1.BuiltInProcName.Eval, config: { includeFunctionCall: true, supportFunctionCall: false }, assumePrimitive: true },
+    { type: 'function', names: ['evalText'], processor: built_in_proc_name_1.BuiltInProcName.Eval, config: { includeFunctionCall: true, supportFunctionCall: true }, assumePrimitive: true },
     { type: 'function', names: ['cat'], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
     { type: 'function', names: ['switch'], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { forceArgs: [true] }, assumePrimitive: false },
     { type: 'function', names: ['return'], processor: built_in_proc_name_1.BuiltInProcName.Default, config: { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */, useAsProcessor: built_in_proc_name_1.BuiltInProcName.Return }, assumePrimitive: true },

package/dataflow/internal/process/functions/call/built-in/built-in-eval.d.ts

@@ -10,4 +10,6 @@ import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/proce
 export declare function processEvalCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     /** should this produce an explicit source function call in the graph? */
     includeFunctionCall?: boolean;
+    /** if selected processes evalText function call, else processes eval*/
+    supportFunctionCall?: boolean;
 }): DataflowInformation;

package/dataflow/internal/process/functions/call/built-in/built-in-eval.js

@@ -40,7 +40,7 @@ function processEvalCall(name, args, rootId, data, config) {
         (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
         return information;
     }
-    const code = resolveEvalToCode(evalArgument.value, data.environment, data.completeAst.idMap, data.ctx);
+    const code = resolveEvalToCode(evalArgument.value, config, data);
     if (code) {
         const idGenerator = (0, decorate_1.sourcedDeterministicCountingIdGenerator)(name.lexeme + '::' + rootId, name.location);
         data = {
@@ -73,35 +73,52 @@ function processEvalCall(name, args, rootId, data, config) {
     (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
     return information;
 }
-function resolveEvalToCode(evalArgument, env, idMap, ctx) {
+function resolveEvalToCode(evalArgument, config, data) {
+    const ctx = data.ctx;
+    const env = data.environment;
+    const idMap = data.completeAst.idMap;
     const val = evalArgument;
-    if (val.type === type_1.RType.FunctionCall && val.named && val.functionName.content === 'parse') {
-        const arg = val.arguments.find(v => v !== r_function_call_1.EmptyArgument && v.name?.content === 'text');
-        const nArg = val.arguments.find(v => v !== r_function_call_1.EmptyArgument && v.name?.content === 'n');
-        if (nArg !== undefined || arg === undefined || arg === r_function_call_1.EmptyArgument) {
-            return undefined;
-        }
-        if (arg.value?.type === type_1.RType.String) {
-            return [arg.value.content.str];
+    if (config.supportFunctionCall) {
+        if (val.type === type_1.RType.String) {
+            return [val.content.str];
         }
-        else if (arg.value?.type === type_1.RType.Symbol) {
-            const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(arg.value.info.id, { environment: env, idMap: idMap, resolve: ctx.config.solver.variables, ctx }));
+        else if (val.type === type_1.RType.Symbol) {
+            const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(val.info.id, { environment: env, idMap: idMap, resolve: ctx.config.solver.variables, ctx }));
             if (resolved) {
                 return (0, string_constants_1.collectStrings)(resolved.elements);
             }
         }
-        else if (arg.value?.type === type_1.RType.FunctionCall && arg.value.named && ['paste', 'paste0'].includes(identifier_1.Identifier.getName(arg.value.functionName.content))) {
-            return handlePaste(ctx.config, arg.value.arguments, env, idMap, arg.value.functionName.content === 'paste' ? [' '] : [''], ctx);
-        }
-        return undefined;
-    }
-    else if (val.type === type_1.RType.Symbol) {
-        // const resolved = resolveValueOfVariable(val.content, env);
-        // see https://github.com/flowr-analysis/flowr/pull/1467
         return undefined;
     }
     else {
-        return undefined;
+        if (val.type === type_1.RType.FunctionCall && val.named && val.functionName.content === 'parse') {
+            const arg = val.arguments.find(v => v !== r_function_call_1.EmptyArgument && v.name?.content === 'text');
+            const nArg = val.arguments.find(v => v !== r_function_call_1.EmptyArgument && v.name?.content === 'n');
+            if (nArg !== undefined || arg === undefined || arg === r_function_call_1.EmptyArgument) {
+                return undefined;
+            }
+            if (arg.value?.type === type_1.RType.String) {
+                return [arg.value.content.str];
+            }
+            else if (arg.value?.type === type_1.RType.Symbol) {
+                const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(arg.value.info.id, { environment: env, idMap: idMap, resolve: ctx.config.solver.variables, ctx }));
+                if (resolved) {
+                    return (0, string_constants_1.collectStrings)(resolved.elements);
+                }
+            }
+            else if (arg.value?.type === type_1.RType.FunctionCall && arg.value.named && ['paste', 'paste0'].includes(identifier_1.Identifier.getName(arg.value.functionName.content))) {
+                return handlePaste(ctx.config, arg.value.arguments, env, idMap, arg.value.functionName.content === 'paste' ? [' '] : [''], ctx);
+            }
+            return undefined;
+        }
+        else if (val.type === type_1.RType.Symbol) {
+            // const resolved = resolveValueOfVariable(val.content, env);
+            // see https://github.com/flowr-analysis/flowr/pull/1467
+            return undefined;
+        }
+        else {
+            return undefined;
+        }
     }
 }
 function getAsString(config, val, env, idMap, ctx) {

package/documentation/doc-readme.js

@@ -17,9 +17,20 @@ const doc_issue_1 = require("./doc-util/doc-issue");
 const strings_1 = require("../util/text/strings");
 const doc_maker_1 = require("./wiki-mk/doc-maker");
 const PublicationsMain = [
+    {
+        header: 'Supporting the Comprehension of Data Analysis Scripts (FSE \'25, Tool)',
+        description: 'This refers to an updated tool demonstration of the framework. Preprint available at <a href="https://doi.org/10.48550/arXiv.2604.15963" target="_blank">arXiv:2604.15963</a>.',
+        doi: 'https://doi.org/10.1145/3803437.3806402',
+        bibtex: String.raw `@article{10.1145/3803437.3806402,
+	author = {Sihler, Florian and Gerstl, Oliver and Pfrenger, Lars and Schubert, Julian and Tichy, Matthias},
+	title = {Supporting the Comprehension of Data Analysis Scripts},
+	year = {2026},
+	doi = {10.1145/3803437.3806402}
+}`
+    },
     {
         header: 'Statically Analyzing the Dataflow of R Programs (OOPSLA \'25)',
-        description: 'Please cite this paper if you are using flowR in your research.',
+        description: '**Please cite this paper if you are using flowR in your research.**',
         doi: 'https://doi.org/10.1145/3763087',
         bibtex: String.raw `@article{10.1145/3763087,
 	author = {Sihler, Florian and Tichy, Matthias},
@@ -42,7 +53,7 @@ const PublicationsMain = [
     },
     {
         header: 'flowR: A Static Program Slicer for R (ASE \'24, Tool)',
-        description: `This refers to the tool-demonstration of the <a href="${doc_files_1.FlowrVsCode}">VS Code Extension</a>.`,
+        description: `This refers to the tool-demonstration of the <a href="${doc_files_1.FlowrVsCode}" target="_blank">VS Code Extension</a>.`,
         doi: 'https://doi.org/10.1145/3691620.3695359',
         bibtex: `@inproceedings{DBLP:conf/kbse/SihlerT24,
   author       = {Florian Sihler and

package/documentation/wiki-absint.d.ts

@@ -1,5 +1,4 @@
-import type { DocMakerArgs } from './wiki-mk/doc-maker';
-import { DocMaker } from './wiki-mk/doc-maker';
+import { DocMaker, type DocMakerArgs } from './wiki-mk/doc-maker';
 export declare class WikiAbsint extends DocMaker<'wiki/Abstract Interpretation.md'> {
     constructor();
     protected text({ ctx }: DocMakerArgs): Promise<string>;