@eagleoutice/flowr 2.0.16 → 2.0.18

package/README.md

@@ -16,7 +16,7 @@ You can enter `:help` to gain more information on its capabilities.
 
 <details>
 
-<summary>Example REPL session.</summary>
+<summary>Example REPL session</summary>
 
 ![Example of a simple REPL session](wiki/gif/repl-demo.gif)
 

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

@@ -46,8 +46,11 @@ const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipeli
 const graph_1 = require("../../../dataflow/graph/graph");
 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");
+const auto_select_defaults_1 = require("../../../reconstruct/auto-select/auto-select-defaults");
 /**
  * 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,
@@ -215,7 +221,7 @@ class FlowRServerConnection {
         }
         fileInformation.pipeline.updateRequest({
             criterion: request.criterion,
-            autoSelectIf: request.noMagicComments ? auto_select_defaults_1.autoSelectLibrary : (0, magic_comments_1.makeMagicCommentHandler)(auto_select_defaults_1.autoSelectLibrary)
+            autoSelectIf: request.noMagicComments ? auto_select_defaults_1.doNotAutoSelect : (0, magic_comments_1.makeMagicCommentHandler)(auto_select_defaults_1.doNotAutoSelect)
         });
         void fileInformation.pipeline.allRemainingSteps(true).then(results => {
             (0, send_1.sendMessage)(this.socket, {
@@ -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/cli/slicer-app.js

@@ -12,8 +12,8 @@ const json_1 = require("../util/json");
 const script_1 = require("./common/script");
 const slicer_1 = require("../benchmark/slicer");
 const print_1 = require("../benchmark/stats/print");
-const auto_select_defaults_1 = require("../reconstruct/auto-select/auto-select-defaults");
 const magic_comments_1 = require("../reconstruct/auto-select/magic-comments");
+const auto_select_defaults_1 = require("../reconstruct/auto-select/auto-select-defaults");
 const options = (0, script_1.processCommandLineArgs)('slicer', ['input', 'criterion'], {
     subtitle: 'Slice R code based on a given slicing criterion',
     examples: [
@@ -30,7 +30,7 @@ async function getSlice() {
     (0, assert_1.guard)(options.criterion !== undefined, 'a slicing criterion must be given');
     await slicer.init(options['input-is-text']
         ? { request: 'text', content: options.input }
-        : { request: 'file', content: options.input }, options['no-magic-comments'] ? auto_select_defaults_1.autoSelectLibrary : (0, magic_comments_1.makeMagicCommentHandler)(auto_select_defaults_1.autoSelectLibrary));
+        : { request: 'file', content: options.input }, 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() !== '';

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,11 @@ 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");
+const built_in_apply_1 = require("../internal/process/functions/call/built-in/built-in-apply");
 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 +35,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 +45,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 +106,16 @@ 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, ['lapply', 'sapply', 'vapply', 'mapply'], built_in_apply_1.processApply, { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' });
+/* functool wrappers */
+registerBuiltInFunctions(true, ['Lapply', 'Sapply', 'Vapply', 'Mapply'], built_in_apply_1.processApply, { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' });
+registerBuiltInFunctions(true, ['apply', 'tapply', 'Tapply'], built_in_apply_1.processApply, { indexOfFunction: 2, nameOfFunctionArgument: 'FUN' });
+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 */ });
@@ -113,21 +125,29 @@ registerBuiltInFunctions(true, ['[', '[['], built_in_access_1.processAccess, { t
 registerBuiltInFunctions(true, ['$', '@'], built_in_access_1.processAccess, { treatIndicesAsString: true });
 registerBuiltInFunctions(true, ['if', 'ifelse'], built_in_if_then_else_1.processIfThenElse, {});
 registerBuiltInFunctions(true, ['get'], built_in_get_1.processGet, {});
-registerBuiltInFunctions(false, ['library'], built_in_library_1.processLibrary, {});
+registerBuiltInFunctions(false, ['library', 'require'], built_in_library_1.processLibrary, {});
 registerBuiltInFunctions(true, ['<-', '='], built_in_assignment_1.processAssignment, { canBeReplacement: true });
 registerBuiltInFunctions(true, [':=', 'assign'], built_in_assignment_1.processAssignment, {});
 registerBuiltInFunctions(true, ['delayedAssign'], built_in_assignment_1.processAssignment, { quoteSource: true });
 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 });
+/* library and require is handled above */
+registerBuiltInFunctions(true, ['requireNamespace', 'loadNamespace', 'attachNamespace', 'asNamespace'], defaultBuiltInProcessor, { hasUnknownSideEffects: true });
+/* downloader and installer functions (R, devtools, BiocManager) */
+registerBuiltInFunctions(true, ['library.dynam', 'install.packages', 'install', 'install_github', 'install_gitlab', 'install_bitbucket', 'install_url', 'install_git', 'install_svn', 'install_local', 'install_version', 'update_packages'], defaultBuiltInProcessor, { hasUnknownSideEffects: true });
+/* weird env attachments */
+registerBuiltInFunctions(true, ['attach'], 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,8 +1,7 @@
 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 type { DataflowGraphVertexArgument, DataflowGraphVertexFunctionCall, DataflowGraphVertexInfo } from './vertex';
 import { EmptyArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { IdentifierDefinition, IdentifierReference } from '../environments/identifier';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
@@ -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,19 @@ 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;
+    /**
+     * Marks a vertex in the graph to be a function call with the new information
+     * @param info - The information about the new function call node
+     */
+    updateToFunctionCall(info: DataflowGraphVertexFunctionCall): 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 {};