@eagleoutice/flowr 2.0.15 → 2.0.17

package/README.md

@@ -1,20 +1,30 @@
 [![flowR logo](https://raw.githubusercontent.com/wiki/flowr-analysis/flowr/img/flowR.png)](https://github.com/flowr-analysis/flowr/wiki)\
-[![QA (and potentially deploy)](https://github.com/flowr-analysis/flowr/actions/workflows/qa.yaml/badge.svg)](https://github.com/flowr-analysis/flowr/actions/workflows/qa.yaml) [![codecov](https://codecov.io/gh/flowr-analysis/flowr/graph/badge.svg)](https://codecov.io/gh/flowr-analysis/flowr) [![Docker Image Version (latest semver)](https://img.shields.io/docker/v/eagleoutice/flowr?logo=docker&logoColor=white&label=dockerhub)](https://hub.docker.com/r/eagleoutice/flowr) [![latest tag](https://badgen.net/github/tag/flowr-analysis/flowr?label=latest&color=purple)](https://github.com/flowr-analysis/flowr/releases/latest) [![Marketplace](https://badgen.net/vs-marketplace/v/code-inspect.vscode-flowr)](https://marketplace.visualstudio.com/items?itemName=code-inspect.vscode-flowr) [![All Contributors](https://img.shields.io/github/all-contributors/flowr-analysis/flowr)](#contributors) 
+[![QA (and potentially deploy)](https://github.com/flowr-analysis/flowr/actions/workflows/qa.yaml/badge.svg)](https://github.com/flowr-analysis/flowr/actions/workflows/qa.yaml) [![codecov](https://codecov.io/gh/flowr-analysis/flowr/graph/badge.svg)](https://codecov.io/gh/flowr-analysis/flowr) [![Docker Image Version (latest semver)](https://img.shields.io/docker/v/eagleoutice/flowr?logo=docker&logoColor=white&label=dockerhub)](https://hub.docker.com/r/eagleoutice/flowr) [![latest tag](https://badgen.net/github/tag/flowr-analysis/flowr?label=latest&color=purple)](https://github.com/flowr-analysis/flowr/releases/latest) [![Marketplace](https://badgen.net/vs-marketplace/v/code-inspect.vscode-flowr)](https://marketplace.visualstudio.com/items?itemName=code-inspect.vscode-flowr) [![All Contributors](https://img.shields.io/github/all-contributors/flowr-analysis/flowr)](#contributors)
 [![DOI](https://zenodo.org/badge/624819038.svg)](https://zenodo.org/doi/10.5281/zenodo.13319290)
 
-_flowR_ is a static [dataflow analyzer](https://en.wikipedia.org/wiki/Data-flow_analysis) and [program slicer](https://github.com/flowr-analysis/flowr/wiki/Terminology#program-slice) for the [_R_](https://www.r-project.org/) programming language (currently tested for versions `4.x` and `3.6.x`). It is available as a [Visual Studio Code extension](https://marketplace.visualstudio.com/items?itemName=code-inspect.vscode-flowr) and as a [docker image](https://hub.docker.com/r/eagleoutice/flowr).
+_flowR_ is a static [dataflow analyzer](https://en.wikipedia.org/wiki/Data-flow_analysis) and [program slicer](https://github.com/flowr-analysis/flowr/wiki/Terminology#program-slice) for the [_R_](https://www.r-project.org/) programming language (currently tested for versions `4.x` and `3.6.x`). You can get and use _flowR_ as a [Visual Studio Code extension](https://marketplace.visualstudio.com/items?itemName=code-inspect.vscode-flowr), [RStudio Addin](https://github.com/flowr-analysis/rstudio-addin-flowr), [R package](https://github.com/flowr-analysis/flowr-r-adapter), and as a [Docker image](https://hub.docker.com/r/eagleoutice/flowr).
 
 ## ⭐ Getting Started
 
-To get started with _flowR_, please check out the [Overview](https://github.com/flowr-analysis/flowr/wiki/Overview). The [Setup](https://github.com/flowr-analysis/flowr/wiki/Setup) wiki page explains how you can download and setup _flowR_ on your system. For Visual Studio Code, please see the [marketplace entry](https://marketplace.visualstudio.com/items?itemName=code-inspect.vscode-flowr). With docker 🐳️, the following line should be enough (and drop you directly into the REPL):
+To get started with _flowR_ and its features, please check out the [Overview](https://github.com/flowr-analysis/flowr/wiki/Overview) page. The [Setup](https://github.com/flowr-analysis/flowr/wiki/Setup) wiki page explains how you can download and setup _flowR_ on your system. With docker 🐳️, the following line should be enough (and drop you directly into the read-eval-print loop):
 
 ```shell
 docker run -it --rm eagleoutice/flowr
- ```
+```
+
+You can enter `:help` to gain more information on its capabilities.
+
+<details>
+
+<summary>Example REPL session</summary>
+
+![Example of a simple REPL session](wiki/gif/repl-demo.gif)
+
+</details>
 
 ## 📜 More Information
 
-For more details, see the [wiki pages](https://github.com/flowr-analysis/flowr/wiki) and the deployed [code documentation](https://flowr-analysis.github.io/flowr/doc/).
+For more details on how to use _flowR_ please refer to the the [wiki pages](https://github.com/flowr-analysis/flowr/wiki), as well as the deployed [code documentation](https://flowr-analysis.github.io/flowr/doc/).
 
 ## 🚀 Contributing
 

package/cli/repl/commands/commands.js

@@ -14,6 +14,7 @@ const ansi_1 = require("../../../util/ansi");
 const args_1 = require("../../../util/args");
 const assert_1 = require("../../../util/assert");
 const scripts_info_1 = require("../../common/scripts-info");
+const lineage_1 = require("./lineage");
 function printHelpForScript(script, f) {
     const base = `  ${(0, ansi_1.bold)(padCmd(':' + script[0]), f)}${script[1].description}`;
     if (script[1].aliases.length === 0) {
@@ -58,7 +59,8 @@ const _commands = {
     'dataflow': dataflow_1.dataflowCommand,
     'dataflow*': dataflow_1.dataflowStarCommand,
     'controlflow': cfg_1.controlflowCommand,
-    'controlflow*': cfg_1.controlflowStarCommand
+    'controlflow*': cfg_1.controlflowStarCommand,
+    'lineage': lineage_1.getLineageCommand
 };
 let commandsInitialized = false;
 function hasModule(path) {

package/cli/repl/commands/lineage.d.ts

@@ -0,0 +1,15 @@
+import type { ReplCommand } from './main';
+import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { DataflowInformation } from '../../../dataflow/info';
+import type { NormalizedAst } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ * Get the lineage of a node in the dataflow graph
+ *
+ * @param criterion - The criterion to get the lineage of
+ * @param ast       - The normalized AST
+ * @param dfg       - The dataflow graph
+ * @returns The lineage of the node represented as a set of node ids
+ */
+export declare function getLineage(criterion: SingleSlicingCriterion, { idMap }: NormalizedAst, dfg: DataflowInformation): Set<NodeId>;
+export declare const getLineageCommand: ReplCommand;

package/cli/repl/commands/lineage.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLineageCommand = exports.getLineage = void 0;
+const pipeline_executor_1 = require("../../../core/pipeline-executor");
+const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
+const retriever_1 = require("../../../r-bridge/retriever");
+const parse_1 = require("../../../slicing/criterion/parse");
+const edge_1 = require("../../../dataflow/graph/edge");
+const assert_1 = require("../../../util/assert");
+function splitAt(str, idx) {
+    return [str.slice(0, idx), str.slice(idx)];
+}
+async function getDfg(shell, remainingLine) {
+    return await new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_DATAFLOW_PIPELINE, {
+        shell,
+        request: (0, retriever_1.requestFromInput)(remainingLine.trim())
+    }).allRemainingSteps();
+}
+function filterRelevantEdges(edge) {
+    return (0, edge_1.edgeIncludesType)(2 /* EdgeType.DefinedBy */ | 32 /* EdgeType.DefinedByOnCall */ | 8 /* EdgeType.Returns */ | 1 /* EdgeType.Reads */, edge.types);
+}
+function pushRelevantEdges(queue, outgoingEdges) {
+    queue.push(...[...outgoingEdges].filter(([_, edge]) => filterRelevantEdges(edge)));
+}
+/**
+ * Get the lineage of a node in the dataflow graph
+ *
+ * @param criterion - The criterion to get the lineage of
+ * @param ast       - The normalized AST
+ * @param dfg       - The dataflow graph
+ * @returns The lineage of the node represented as a set of node ids
+ */
+function getLineage(criterion, { idMap }, dfg) {
+    const src = dfg.graph.get((0, parse_1.slicingCriterionToId)(criterion, idMap));
+    (0, assert_1.guard)(src !== undefined, 'The ID pointed to by the criterion does not exist in the dataflow graph');
+    const [vertex, outgoingEdges] = src;
+    const result = new Set([vertex.id]);
+    const edgeQueue = [];
+    pushRelevantEdges(edgeQueue, outgoingEdges);
+    while (edgeQueue.length > 0) {
+        const [target] = edgeQueue.shift();
+        if (result.has(target)) {
+            continue;
+        }
+        result.add(target);
+        const outgoingEdges = dfg.graph.outgoingEdges(target);
+        if (outgoingEdges !== undefined) {
+            pushRelevantEdges(edgeQueue, outgoingEdges);
+        }
+    }
+    return result;
+}
+exports.getLineage = getLineage;
+exports.getLineageCommand = {
+    description: 'Get the lineage of an R object',
+    usageExample: ':lineage',
+    aliases: ['lin'],
+    script: false,
+    fn: async (output, shell, remainingLine) => {
+        const [criterion, rest] = splitAt(remainingLine, remainingLine.indexOf(' '));
+        const { dataflow: dfg, normalize: ast } = await getDfg(shell, rest);
+        const lineageIds = getLineage(criterion, ast, dfg);
+        output.stdout([...lineageIds].join('\n'));
+    }
+};
+//# sourceMappingURL=lineage.js.map

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

@@ -22,5 +22,6 @@ export declare class FlowRServerConnection {
     private createPipelineExecutorForRequest;
     private handleSliceRequest;
     private handleRepl;
+    private handleLineageRequest;
 }
 export declare function sanitizeAnalysisResults(results: Partial<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE>>): DeepPartial<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE>>;

package/cli/repl/server/connection.js

@@ -48,6 +48,9 @@ const tmp = __importStar(require("tmp"));
 const fs_1 = __importDefault(require("fs"));
 const auto_select_defaults_1 = require("../../../reconstruct/auto-select/auto-select-defaults");
 const magic_comments_1 = require("../../../reconstruct/auto-select/magic-comments");
+const lineage_1 = require("./messages/lineage");
+const lineage_2 = require("../commands/lineage");
+const assert_1 = require("../../../util/assert");
 /**
  * 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.
@@ -97,6 +100,9 @@ class FlowRServerConnection {
             case 'request-repl-execution':
                 this.handleRepl(request.message);
                 break;
+            case 'request-lineage':
+                this.handleLineageRequest(request.message);
+                break;
             default:
                 (0, send_1.sendMessage)(this.socket, {
                     id: request.message.id,
@@ -260,6 +266,34 @@ class FlowRServerConnection {
             });
         });
     }
+    handleLineageRequest(base) {
+        const requestResult = (0, validate_1.validateMessage)(base, lineage_1.requestLineageMessage);
+        if (requestResult.type === 'error') {
+            (0, validate_1.answerForValidationError)(this.socket, requestResult, base.id);
+            return;
+        }
+        const request = requestResult.message;
+        this.logger.info(`[${this.name}] Received lineage request for criterion ${request.criterion}`);
+        const fileInformation = this.fileMap.get(request.filetoken);
+        if (!fileInformation) {
+            (0, send_1.sendMessage)(this.socket, {
+                id: request.id,
+                type: 'error',
+                fatal: false,
+                reason: `The file token ${request.filetoken} has never been analyzed.`
+            });
+            return;
+        }
+        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 lineageIds = (0, lineage_2.getLineage)(request.criterion, ast, dfg);
+        (0, send_1.sendMessage)(this.socket, {
+            type: 'response-lineage',
+            id: request.id,
+            lineage: [...lineageIds]
+        });
+    }
 }
 exports.FlowRServerConnection = FlowRServerConnection;
 function sanitizeAnalysisResults(results) {

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

@@ -0,0 +1,16 @@
+import type { SingleSlicingCriterion } from '../../../../slicing/criterion/parse';
+import type { IdMessageBase, MessageDefinition } from './messages';
+import type { NodeId } from '../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+export interface LineageRequestMessage extends IdMessageBase {
+    type: 'request-lineage';
+    /** The {@link FileAnalysisRequestMessage#filetoken} of the file/data */
+    filetoken: string;
+    /** The criterion to start the lineage from */
+    criterion: SingleSlicingCriterion;
+}
+export declare const requestLineageMessage: MessageDefinition<LineageRequestMessage>;
+export interface LineageResponseMessage extends IdMessageBase {
+    type: 'response-lineage';
+    /** The lineage of the given criterion. With this being the representation of a set, there is no guarantee about order. */
+    lineage: NodeId[];
+}

package/cli/repl/server/messages/lineage.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestLineageMessage = void 0;
+const joi_1 = __importDefault(require("joi"));
+exports.requestLineageMessage = {
+    type: 'request-lineage',
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('request-lineage').required(),
+        id: joi_1.default.string().optional(),
+        filetoken: joi_1.default.string().required(),
+        criterion: joi_1.default.string().required()
+    })
+};
+//# sourceMappingURL=lineage.js.map

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

@@ -9,6 +9,7 @@ import type { FileAnalysisRequestMessage, FileAnalysisResponseMessageJson } from
 import type { ExecuteEndMessage, ExecuteIntermediateResponseMessage, ExecuteRequestMessage } from './repl';
 import type { SliceRequestMessage, SliceResponseMessage } from './slice';
 import type { FlowrErrorMessage } from './error';
+import type { LineageRequestMessage, LineageResponseMessage } from './lineage';
 /**
  * If you send a message it must *not* contain a newline but the message must be terminated by a newline.
  */
@@ -32,4 +33,4 @@ export declare const baseMessage: MessageDefinition<IdMessageBase>;
 /**
  * This is the main message type that should be used to represent a message in *flowR*
  */
-export type FlowrMessage = FlowrHelloResponseMessage | FileAnalysisRequestMessage | FileAnalysisResponseMessageJson | ExecuteRequestMessage | ExecuteIntermediateResponseMessage | ExecuteEndMessage | SliceRequestMessage | SliceResponseMessage | FlowrErrorMessage;
+export type FlowrMessage = FlowrHelloResponseMessage | FileAnalysisRequestMessage | FileAnalysisResponseMessageJson | ExecuteRequestMessage | ExecuteIntermediateResponseMessage | ExecuteEndMessage | SliceRequestMessage | SliceResponseMessage | LineageRequestMessage | LineageResponseMessage | FlowrErrorMessage;

package/dataflow/environments/built-in.js

@@ -2,11 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmptyBuiltInMemory = exports.BuiltInMemory = exports.registerReplacementFunctions = exports.registerBuiltInFunctions = exports.BuiltIn = void 0;
 const known_call_handling_1 = require("../internal/process/functions/call/known-call-handling");
-const built_in_source_1 = require("../internal/process/functions/call/built-in/built-in-source");
 const built_in_access_1 = require("../internal/process/functions/call/built-in/built-in-access");
 const built_in_if_then_else_1 = require("../internal/process/functions/call/built-in/built-in-if-then-else");
 const built_in_assignment_1 = require("../internal/process/functions/call/built-in/built-in-assignment");
-const built_in_logical_bin_op_1 = require("../internal/process/functions/call/built-in/built-in-logical-bin-op");
+const built_in_special_bin_op_1 = require("../internal/process/functions/call/built-in/built-in-special-bin-op");
 const built_in_pipe_1 = require("../internal/process/functions/call/built-in/built-in-pipe");
 const built_in_for_loop_1 = require("../internal/process/functions/call/built-in/built-in-for-loop");
 const built_in_repeat_loop_1 = require("../internal/process/functions/call/built-in/built-in-repeat-loop");
@@ -18,9 +17,10 @@ const built_in_function_definition_1 = require("../internal/process/functions/ca
 const built_in_expression_list_1 = require("../internal/process/functions/call/built-in/built-in-expression-list");
 const built_in_get_1 = require("../internal/process/functions/call/built-in/built-in-get");
 const built_in_library_1 = require("../internal/process/functions/call/built-in/built-in-library");
+const built_in_source_1 = require("../internal/process/functions/call/built-in/built-in-source");
 exports.BuiltIn = 'built-in';
 function defaultBuiltInProcessor(name, args, rootId, data, config) {
-    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data });
+    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs });
     if (config.returnsNthArgument !== undefined) {
         const arg = config.returnsNthArgument === 'last' ? processedArguments[args.length - 1] : processedArguments[config.returnsNthArgument];
         if (arg !== undefined) {
@@ -34,6 +34,9 @@ function defaultBuiltInProcessor(name, args, rootId, data, config) {
             }
         }
     }
+    if (config.hasUnknownSideEffects) {
+        res.graph.markIdForUnknownSideEffects(rootId);
+    }
     if (config.cfg !== undefined) {
         res.exitPoints = [...res.exitPoints, { type: config.cfg, nodeId: rootId, controlDependencies: data.controlDependencies }];
     }
@@ -41,6 +44,7 @@ function defaultBuiltInProcessor(name, args, rootId, data, config) {
 }
 function registerBuiltInFunctions(both, names, processor, config) {
     for (const name of names) {
+        (0, assert_1.guard)(processor !== undefined, `Processor for ${name} is undefined, maybe you have an import loop? You may run 'npm run detect-circular-deps' - although by far not all are bad`);
         (0, assert_1.guard)(!exports.BuiltInMemory.has(name), `Built-in ${name} already defined`);
         const d = [{
                 kind: 'built-in-function',
@@ -101,9 +105,13 @@ registerBuiltInConstant(true, 'TRUE', true);
 registerBuiltInConstant(true, 'T', true);
 registerBuiltInConstant(true, 'FALSE', false);
 registerBuiltInConstant(true, 'F', false);
-registerSimpleFunctions('~', '+', '-', '*', '/', '^', '!', '?', '**', '==', '!=', '>', '<', '>=', '<=', '%%', '%/%', '%*%', '%in%', ':', 'list', 'c', 'rep', 'seq', 'seq_len', 'seq_along', 'seq.int', 'gsub', 'which', 'class', 'dimnames', 'min', 'max', 'intersect', 'subset', 'match', 'sqrt', 'abs', 'round', 'floor', 'ceiling', 'signif', 'trunc', 'log', 'log10', 'log2', 'sum', 'mean', 'unique', 'paste', 'paste0', 'read.csv', 'stop', 'is.null', 'plot', 'numeric', 'as.character', 'as.integer', 'as.logical', 'as.numeric', 'as.matrix', 'apply', 'lapply', 'sapply', 'tapply', 'mapply', 'do.call', 'rbind', 'nrow', 'ncol', 'tryCatch', 'expression', 'factor', 'missing', 'as.data.frame', 'data.frame', 'na.omit', 'rownames', 'names', 'order', 'length', 'any', 'dim', 'matrix', 'cbind', 'nchar', 't');
-registerBuiltInFunctions(true, ['print', '('], defaultBuiltInProcessor, { returnsNthArgument: 0 });
-registerBuiltInFunctions(false, ['cat', 'switch'], defaultBuiltInProcessor, {}); /* returns null */
+registerSimpleFunctions('~', '+', '-', '*', '/', '^', '!', '?', '**', '==', '!=', '>', '<', '>=', '<=', '%%', '%/%', '%*%', '%in%', ':', 'list', 'c', 'rep', 'seq', 'seq_len', 'seq_along', 'seq.int', 'gsub', 'which', 'class', 'dimnames', 'min', 'max', 'intersect', 'subset', 'match', 'sqrt', 'abs', 'round', 'floor', 'ceiling', 'signif', 'trunc', 'log', 'log10', 'log2', 'sum', 'mean', 'unique', 'paste', 'paste0', 'read.csv', 'stop', 'is.null', 'plot', 'numeric', 'as.character', 'as.integer', 'as.logical', 'as.numeric', 'as.matrix', 'do.call', 'rbind', 'nrow', 'ncol', 'tryCatch', 'expression', 'factor', 'missing', 'as.data.frame', 'data.frame', 'na.omit', 'rownames', 'names', 'order', 'length', 'any', 'dim', 'matrix', 'cbind', 'nchar', 't');
+registerBuiltInFunctions(true, ['apply', 'lapply', 'sapply', 'tapply', 'mapply'], defaultBuiltInProcessor, { forceArgs: [false, true] });
+registerBuiltInFunctions(true, ['print'], defaultBuiltInProcessor, { returnsNthArgument: 0, forceArgs: 'all' });
+registerBuiltInFunctions(true, ['('], defaultBuiltInProcessor, { returnsNthArgument: 0 });
+registerBuiltInFunctions(true, ['load', 'load_all', 'setwd', 'set.seed'], defaultBuiltInProcessor, { hasUnknownSideEffects: true, forceArgs: [true] });
+registerBuiltInFunctions(false, ['cat'], defaultBuiltInProcessor, { forceArgs: 'all' }); /* returns null */
+registerBuiltInFunctions(false, ['switch'], defaultBuiltInProcessor, {}); /* returns null */
 registerBuiltInFunctions(true, ['return'], defaultBuiltInProcessor, { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */ });
 registerBuiltInFunctions(true, ['break'], defaultBuiltInProcessor, { cfg: 2 /* ExitPointType.Break */ });
 registerBuiltInFunctions(true, ['next'], defaultBuiltInProcessor, { cfg: 3 /* ExitPointType.Next */ });
@@ -120,14 +128,16 @@ registerBuiltInFunctions(true, ['delayedAssign'], built_in_assignment_1.processA
 registerBuiltInFunctions(true, ['<<-'], built_in_assignment_1.processAssignment, { superAssignment: true, canBeReplacement: true });
 registerBuiltInFunctions(true, ['->'], built_in_assignment_1.processAssignment, { swapSourceAndTarget: true, canBeReplacement: true });
 registerBuiltInFunctions(true, ['->>'], built_in_assignment_1.processAssignment, { superAssignment: true, swapSourceAndTarget: true, canBeReplacement: true });
-registerBuiltInFunctions(true, ['&&', '&'], built_in_logical_bin_op_1.processSpecialBinOp, { lazy: true, evalRhsWhen: true });
-registerBuiltInFunctions(true, ['||', '|'], built_in_logical_bin_op_1.processSpecialBinOp, { lazy: true, evalRhsWhen: false });
+registerBuiltInFunctions(true, ['&&', '&'], built_in_special_bin_op_1.processSpecialBinOp, { lazy: true, evalRhsWhen: true });
+registerBuiltInFunctions(true, ['||', '|'], built_in_special_bin_op_1.processSpecialBinOp, { lazy: true, evalRhsWhen: false });
 registerBuiltInFunctions(true, ['|>', '%>%'], built_in_pipe_1.processPipe, {});
 registerBuiltInFunctions(true, ['function', '\\'], built_in_function_definition_1.processFunctionDefinition, {});
 registerBuiltInFunctions(true, ['quote', 'substitute', 'bquote'], built_in_quote_1.processQuote, { quoteArgumentsWithIndex: 0 });
 registerBuiltInFunctions(true, ['for'], built_in_for_loop_1.processForLoop, {});
 registerBuiltInFunctions(true, ['repeat'], built_in_repeat_loop_1.processRepeatLoop, {});
 registerBuiltInFunctions(true, ['while'], built_in_while_loop_1.processWhileLoop, {});
+registerBuiltInFunctions(true, ['options'], defaultBuiltInProcessor, { hasUnknownSideEffects: true, forceArgs: 'all' });
+registerBuiltInFunctions(true, ['on.exit', 'sys.on.exit'], defaultBuiltInProcessor, { hasUnknownSideEffects: true });
 /* they are all mapped to `<-` but we separate super assignments */
 registerReplacementFunctions({ makeMaybe: true }, ['<-', '<<-'], '[', '[[', '$', '@', 'names', 'dimnames', 'attributes', 'attr', 'class', 'levels', 'rownames', 'colnames');
 //# sourceMappingURL=built-in.js.map

package/dataflow/environments/environment.js

@@ -20,11 +20,12 @@ function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = u
         }
     }
     if (node) {
-        if (node[0].controlDependencies && defaultCd && !node[0].controlDependencies.includes(defaultCd)) {
-            node[0].controlDependencies.push(defaultCd);
+        const [fst] = node;
+        if (fst.controlDependencies && defaultCd && !fst.controlDependencies.includes(defaultCd)) {
+            fst.controlDependencies.push(defaultCd);
         }
         else {
-            node[0].controlDependencies = defaultCd ? [defaultCd] : [];
+            fst.controlDependencies = defaultCd ? [defaultCd] : [];
         }
     }
     return { ...ref, controlDependencies: [...ref.controlDependencies ?? [], ...(defaultCd ? [defaultCd] : [])] };

package/dataflow/environments/resolve-by-name.d.ts

@@ -1,5 +1,5 @@
 import type { REnvironmentInformation } from './environment';
-import type { Ternary } from '../../util/logic';
+import { Ternary } from '../../util/logic';
 import type { Identifier, IdentifierDefinition } from './identifier';
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.

package/dataflow/environments/resolve-by-name.js

@@ -24,11 +24,11 @@ function resolveByName(name, environment) {
 exports.resolveByName = resolveByName;
 function resolvesToBuiltInConstant(name, environment, wantedValue) {
     if (name === undefined) {
-        return 'never';
+        return 2 /* Ternary.Never */;
     }
     const definition = resolveByName(name, environment);
     if (definition === undefined) {
-        return 'never';
+        return 2 /* Ternary.Never */;
     }
     let all = true;
     let some = false;
@@ -41,10 +41,10 @@ function resolvesToBuiltInConstant(name, environment, wantedValue) {
         }
     }
     if (all) {
-        return 'always';
+        return 0 /* Ternary.Always */;
     }
     else {
-        return some ? 'maybe' : 'never';
+        return some ? 1 /* Ternary.Maybe */ : 2 /* Ternary.Never */;
     }
 }
 exports.resolvesToBuiltInConstant = resolvesToBuiltInConstant;

package/dataflow/graph/diff.js

@@ -94,6 +94,7 @@ function diffOutgoingEdges(ctx) {
 }
 function diffRootVertices(ctx) {
     (0, diff_1.setDifference)(ctx.left.rootIds(), ctx.right.rootIds(), { ...ctx, position: `${ctx.position}Root vertices differ in graphs. ` });
+    (0, diff_1.setDifference)(ctx.left.unknownSideEffects, ctx.right.unknownSideEffects, { ...ctx, position: `${ctx.position}Unknown side effects differ in graphs. ` });
 }
 function diffOfDataflowGraphs(left, right, config) {
     if (left.graph === right.graph) {

package/dataflow/graph/graph.d.ts

@@ -1,7 +1,6 @@
 import type { DataflowGraphEdge } from './edge';
 import { EdgeType } from './edge';
 import type { DataflowInformation } from '../info';
-import type { DataflowDifferenceReport } from './diff';
 import type { DataflowGraphVertexArgument, DataflowGraphVertexInfo } from './vertex';
 import { EmptyArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { IdentifierDefinition, IdentifierReference } from '../environments/identifier';
@@ -47,10 +46,10 @@ type EdgeData<Edge extends DataflowGraphEdge> = Omit<Edge, 'from' | 'to' | 'type
 export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = DataflowGraphVertexInfo, Edge extends DataflowGraphEdge = DataflowGraphEdge> {
     private static DEFAULT_ENVIRONMENT;
     private _idMap;
-    readonly functionCache: Map<NodeId, Set<DataflowGraphVertexInfo>>;
+    private _unknownSideEffects;
     constructor(idMap: AstIdMap | undefined);
     /** Contains the vertices of the root level graph (i.e., included those vertices from the complete graph, that are nested within function definitions) */
-    private rootVertices;
+    protected rootVertices: Set<NodeId>;
     /** All vertices in the complete graph (including those nested in function definition) */
     private vertexInformation;
     /** All edges in the complete graph (including those nested in function definition) */
@@ -79,14 +78,18 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     ingoingEdges(id: NodeId): IngoingEdges | undefined;
     /** Retrieves the id-map to the normalized AST attached to the dataflow graph */
     get idMap(): AstIdMap | undefined;
+    /**
+     * Retrieves the set of vertices which have side effects that we do not know anything about.
+     */
+    get unknownSideEffects(): ReadonlySet<NodeId>;
     /** Allows setting the id-map explicitly (which should only be used when, e.g., you plan to compare two dataflow graphs on the same AST-basis) */
     setIdMap(idMap: AstIdMap): void;
     /**
-   * @param includeDefinedFunctions - If true this will iterate over function definitions as well and not just the toplevel
-   * @returns the ids of all toplevel vertices in the graph together with their vertex information
+     * @param includeDefinedFunctions - If true this will iterate over function definitions as well and not just the toplevel
+     * @returns the ids of all toplevel vertices in the graph together with their vertex information
      *
      * @see #edges
-   */
+     */
     vertices(includeDefinedFunctions: boolean): IterableIterator<[NodeId, Vertex]>;
     /**
      * @returns the ids of all edges in the graph together with their edge information
@@ -107,15 +110,15 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     isRoot(id: NodeId): boolean;
     rootIds(): ReadonlySet<NodeId>;
     /**
-   * Adds a new vertex to the graph, for ease of use, some arguments are optional and filled automatically.
-   *
+     * Adds a new vertex to the graph, for ease of use, some arguments are optional and filled automatically.
+     *
      * @param vertex - The vertex to add
      * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds|root vertices} of the graph.
      *                 This is probably only of use, when you construct dataflow graphs for tests.
      *
-   * @see DataflowGraphVertexInfo
-   * @see DataflowGraphVertexArgument
-   */
+     * @see DataflowGraphVertexInfo
+     * @see DataflowGraphVertexArgument
+     */
     addVertex(vertex: DataflowGraphVertexArgument & Omit<Vertex, keyof DataflowGraphVertexArgument>, asRoot?: boolean): this;
     /** {@inheritDoc} */
     addEdge(from: NodeId, to: NodeId, edgeInfo: EdgeData<Edge>): this;
@@ -133,18 +136,14 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
      */
     mergeWith(otherGraph: DataflowGraph<Vertex, Edge> | undefined, mergeRootVertices?: boolean): this;
     private mergeEdges;
-    equals(other: DataflowGraph<Vertex, Edge>, diff: true, names?: {
-        left: string;
-        right: string;
-    }): DataflowDifferenceReport;
-    equals(other: DataflowGraph<Vertex, Edge>, diff?: false, names?: {
-        left: string;
-        right: string;
-    }): boolean;
     /**
      * Marks a vertex in the graph to be a definition
      * @param reference - The reference to the vertex to mark as definition
      */
     setDefinitionOfVertex(reference: IdentifierReference): void;
+    /** If you do not pass the `to` node, this will just mark the node as maybe */
+    addControlDependency(from: NodeId, to?: NodeId, when?: boolean): this;
+    /** Marks the given node as having unknown side effects */
+    markIdForUnknownSideEffects(id: NodeId): this;
 }
 export {};

package/dataflow/graph/graph.js

@@ -5,6 +5,7 @@ const assert_1 = require("../../util/assert");
 const diff_1 = require("./diff");
 const arrays_1 = require("../../util/arrays");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const environment_1 = require("../environments/environment");
 const clone_1 = require("../environments/clone");
 const built_in_1 = require("../environments/built-in");
@@ -42,8 +43,8 @@ function extractEdgeIds(from, to) {
 class DataflowGraph {
     static DEFAULT_ENVIRONMENT = undefined;
     _idMap;
-    // this should be linked separately
-    functionCache = new Map();
+    /* Set of vertices which have sideEffects that we do not know anything about */
+    _unknownSideEffects = new Set();
     constructor(idMap) {
         DataflowGraph.DEFAULT_ENVIRONMENT ??= (0, environment_1.initializeCleanEnvironments)();
         this._idMap = idMap;
@@ -96,16 +97,22 @@ class DataflowGraph {
     get idMap() {
         return this._idMap;
     }
+    /**
+     * Retrieves the set of vertices which have side effects that we do not know anything about.
+     */
+    get unknownSideEffects() {
+        return this._unknownSideEffects;
+    }
     /** Allows setting the id-map explicitly (which should only be used when, e.g., you plan to compare two dataflow graphs on the same AST-basis) */
     setIdMap(idMap) {
         this._idMap = idMap;
     }
     /**
-   * @param includeDefinedFunctions - If true this will iterate over function definitions as well and not just the toplevel
-   * @returns the ids of all toplevel vertices in the graph together with their vertex information
+     * @param includeDefinedFunctions - If true this will iterate over function definitions as well and not just the toplevel
+     * @returns the ids of all toplevel vertices in the graph together with their vertex information
      *
      * @see #edges
-   */
+     */
     *vertices(includeDefinedFunctions) {
         if (includeDefinedFunctions) {
             yield* this.vertexInformation.entries();
@@ -143,15 +150,15 @@ class DataflowGraph {
         return this.rootVertices;
     }
     /**
-   * Adds a new vertex to the graph, for ease of use, some arguments are optional and filled automatically.
-   *
+     * Adds a new vertex to the graph, for ease of use, some arguments are optional and filled automatically.
+     *
      * @param vertex - The vertex to add
      * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds|root vertices} of the graph.
      *                 This is probably only of use, when you construct dataflow graphs for tests.
      *
-   * @see DataflowGraphVertexInfo
-   * @see DataflowGraphVertexArgument
-   */
+     * @see DataflowGraphVertexInfo
+     * @see DataflowGraphVertexArgument
+     */
     addVertex(vertex, asRoot = true) {
         const oldVertex = this.vertexInformation.get(vertex.id);
         if (oldVertex !== undefined) {
@@ -170,11 +177,11 @@ class DataflowGraph {
         return this;
     }
     /**
-   * Will insert a new edge into the graph,
-   * if the direction of the edge is of no importance (`same-read-read` or `same-def-def`), source
-   * and target will be sorted so that `from` has the lower, and `to` the higher id (default ordering).
-    * Please note, that this will never make edges to {@link BuiltIn} as they are not part of the graph.
-   */
+     * Will insert a new edge into the graph,
+     * if the direction of the edge is of no importance (`same-read-read` or `same-def-def`), source
+     * and target will be sorted so that `from` has the lower, and `to` the higher id (default ordering).
+     * Please note that this will never make edges to {@link BuiltIn} as they are not part of the graph.
+     */
     addEdge(from, to, edgeInfo) {
         const { fromId, toId } = extractEdgeIds(from, to);
         const { type, ...rest } = edgeInfo;
@@ -232,6 +239,9 @@ class DataflowGraph {
                 this.rootVertices.add(root);
             }
         }
+        for (const unknown of otherGraph.unknownSideEffects) {
+            this._unknownSideEffects.add(unknown);
+        }
         for (const [id, info] of otherGraph.vertexInformation) {
             const currentInfo = this.vertexInformation.get(id);
             this.vertexInformation.set(id, currentInfo === undefined ? info : mergeNodeInfos(currentInfo, info));
@@ -258,15 +268,6 @@ class DataflowGraph {
             }
         }
     }
-    equals(other, diff = false, names = { left: 'left', right: 'right' }) {
-        const report = (0, diff_1.diffOfDataflowGraphs)({ name: names.left, graph: this }, { name: names.right, graph: other });
-        if (diff) {
-            return report;
-        }
-        else {
-            return report.isEqual();
-        }
-    }
     /**
      * Marks a vertex in the graph to be a definition
      * @param reference - The reference to the vertex to mark as definition
@@ -281,6 +282,22 @@ class DataflowGraph {
             this.vertexInformation.set(reference.nodeId, { ...vertex, tag: 'variable-definition' });
         }
     }
+    /** If you do not pass the `to` node, this will just mark the node as maybe */
+    addControlDependency(from, to, when) {
+        to = to ? (0, node_id_1.normalizeIdToNumberIfPossible)(to) : undefined;
+        const vertex = this.getVertex(from, true);
+        (0, assert_1.guard)(vertex !== undefined, () => `node must be defined for ${from} to add control dependency`);
+        vertex.controlDependencies ??= [];
+        if (to && vertex.controlDependencies.every(({ id, when: cond }) => id !== to && when !== cond)) {
+            vertex.controlDependencies.push({ id: to, when });
+        }
+        return this;
+    }
+    /** Marks the given node as having unknown side effects */
+    markIdForUnknownSideEffects(id) {
+        this._unknownSideEffects.add((0, node_id_1.normalizeIdToNumberIfPossible)(id));
+        return this;
+    }
 }
 exports.DataflowGraph = DataflowGraph;
 function mergeNodeInfos(current, next) {