@eagleoutice/flowr 2.0.17 → 2.0.19

package/cli/repl/server/connection.js

@@ -46,11 +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.
@@ -221,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, {

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

@@ -18,6 +18,7 @@ const built_in_expression_list_1 = require("../internal/process/functions/call/b
 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, forceArgs: config.forceArgs });
@@ -67,14 +68,16 @@ function registerReplacementFunctions(standardConfig, assignments, ...prefixes)
         for (const prefix of prefixes) {
             const effectiveName = `${prefix}${assignment}`;
             (0, assert_1.guard)(!exports.BuiltInMemory.has(effectiveName), `Built-in ${effectiveName} already defined`);
-            exports.BuiltInMemory.set(effectiveName, [{
+            const d = [{
                     kind: 'built-in-function',
                     definedAt: exports.BuiltIn,
                     processor: (name, args, rootId, data) => (0, built_in_replacement_1.processReplacementFunction)(name, args, rootId, data, { ...standardConfig, assignmentOperator: assignment }),
                     name: effectiveName,
                     controlDependencies: undefined,
                     nodeId: exports.BuiltIn
-                }]);
+                }];
+            exports.BuiltInMemory.set(effectiveName, d);
+            exports.EmptyBuiltInMemory.set(effectiveName, d);
         }
     }
 }
@@ -106,7 +109,10 @@ 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', '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, ['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] });
@@ -121,7 +127,7 @@ 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 });
@@ -138,6 +144,12 @@ registerBuiltInFunctions(true, ['repeat'], built_in_repeat_loop_1.processRepeatL
 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/graph/graph.d.ts

@@ -1,7 +1,7 @@
 import type { DataflowGraphEdge } from './edge';
 import { EdgeType } from './edge';
 import type { DataflowInformation } from '../info';
-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';
@@ -141,6 +141,11 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
      * @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 */

package/dataflow/graph/graph.js

@@ -282,6 +282,16 @@ class DataflowGraph {
             this.vertexInformation.set(reference.nodeId, { ...vertex, tag: 'variable-definition' });
         }
     }
+    /**
+     * 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) {
+        const vertex = this.getVertex(info.id, true);
+        (0, assert_1.guard)(vertex !== undefined, () => `node must be defined for ${JSON.stringify(info.id)} to update it to a function call`);
+        (0, assert_1.guard)(vertex.tag === "use" /* VertexType.Use */, () => `node must be a use node for ${JSON.stringify(info.id)} to update it to a function call`);
+        this.vertexInformation.set(info.id, { ...vertex, ...info, tag: "function-call" /* VertexType.FunctionCall */ });
+    }
     /** 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;

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

@@ -6,6 +6,12 @@ const known_call_handling_1 = require("../known-call-handling");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const logger_1 = require("../../../../../logger");
 const environment_1 = require("../../../../../environments/environment");
+const built_in_1 = require("../../../../../environments/built-in");
+const built_in_assignment_1 = require("./built-in-assignment");
+function tableAssignmentProcessor(name, args, rootId, data, outInfo) {
+    outInfo.definitionRootNodes.push(rootId);
+    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+}
 function processAccess(name, args, rootId, data, config) {
     if (args.length < 2) {
         logger_1.dataflowLogger.warn(`Access ${name.content} has less than 2 arguments, skipping`);
@@ -15,7 +21,26 @@ function processAccess(name, args, rootId, data, config) {
     (0, assert_1.guard)(head !== r_function_call_1.EmptyArgument, () => `Access ${name.content} has no source, impossible!`);
     let fnCall;
     if (!config.treatIndicesAsString) {
+        /* within an access operation which treats its fields, we redefine the table assignment ':=' as a trigger if this is to be treated as a definition */
+        // do we have a local definition that needs to be recovered?
+        const existing = data.environment.current.memory.get(':=');
+        const outInfo = { definitionRootNodes: [] };
+        data.environment.current.memory.set(':=', [{
+                kind: 'built-in-function',
+                definedAt: built_in_1.BuiltIn,
+                controlDependencies: undefined,
+                processor: (name, args, rootId, data) => tableAssignmentProcessor(name, args, rootId, data, outInfo),
+                name: ':=',
+                nodeId: built_in_1.BuiltIn
+            }]);
         fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs });
+        /* recover the environment */
+        if (existing !== undefined) {
+            data.environment.current.memory.set(':=', existing);
+        }
+        if (head.value && outInfo.definitionRootNodes.length > 0) {
+            (0, built_in_assignment_1.markAsAssignment)(fnCall.information, { kind: 'variable', name: head.value.lexeme ?? '', nodeId: head.value.info.id, definedAt: rootId, controlDependencies: [] }, outInfo.definitionRootNodes, rootId);
+        }
     }
     else {
         const newArgs = [...args];
@@ -47,10 +72,7 @@ function processAccess(name, args, rootId, data, config) {
         if (arg !== undefined) {
             info.graph.addEdge(name.info.id, arg.entryPoint, { type: 1 /* EdgeType.Reads */ });
         }
-        if (config.treatIndicesAsString) {
-            // everything but the first is disabled here
-            break;
-        }
+        /* we include the read edges to the constant arguments as well so that they are included if necessary */
     }
     return {
         ...info,

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

@@ -0,0 +1,14 @@
+import type { DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { MergeableRecord } from '../../../../../../util/objects';
+export interface BuiltInApplyConfiguration extends MergeableRecord {
+    /** the 0-based index of the argument which is the actual function passed, defaults to 1 */
+    readonly indexOfFunction?: number;
+    /** does the argument have a name that it can be given by as well? */
+    readonly nameOfFunctionArgument?: string;
+}
+export declare function processApply<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { indexOfFunction, nameOfFunctionArgument }: BuiltInApplyConfiguration): DataflowInformation;

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processApply = void 0;
+const known_call_handling_1 = require("../known-call-handling");
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const logger_1 = require("../../../../../logger");
+function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFunctionArgument }) {
+    /* as the length is one-based and the argument filter mapping is zero-based, we do not have to subtract 1 */
+    const forceArgsMask = new Array(indexOfFunction).fill(false);
+    forceArgsMask.push(true);
+    const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({
+        name, args, rootId, data, forceArgs: forceArgsMask
+    });
+    let index = indexOfFunction;
+    /* search, if one of the arguments actually contains the argument name if given in the config */
+    if (nameOfFunctionArgument !== undefined) {
+        const mayFn = args.findIndex(arg => arg !== r_function_call_1.EmptyArgument && arg.name && arg.name.content === nameOfFunctionArgument);
+        if (mayFn >= 0) {
+            index = mayFn;
+        }
+    }
+    /* validate, that we indeed have so many arguments to fill this one :D */
+    if (index >= args.length) {
+        logger_1.dataflowLogger.warn(`Function argument at index ${index} not found, skipping`);
+        return information;
+    }
+    const arg = args[index];
+    if (arg === r_function_call_1.EmptyArgument || arg?.value?.type !== "RSymbol" /* RType.Symbol */) {
+        logger_1.dataflowLogger.warn(`Expected symbol as argument at index ${index}, but got ${JSON.stringify(arg)} instead.`);
+        return information;
+    }
+    const functionSymbol = arg.value;
+    const allOtherArguments = processedArguments.filter((_, i) => i !== index).map((arg, i) => {
+        const counterpart = args[i];
+        if (arg && counterpart !== r_function_call_1.EmptyArgument && counterpart.name) {
+            return {
+                name: counterpart.name.content,
+                controlDependencies: data.controlDependencies,
+                nodeId: arg.entryPoint
+            };
+        }
+        else {
+            return r_function_call_1.EmptyArgument;
+        }
+    });
+    const applyCallId = functionSymbol.info.id;
+    /* identify it as a full-blown function call :) */
+    information.graph.updateToFunctionCall({
+        tag: "function-call" /* VertexType.FunctionCall */,
+        id: applyCallId,
+        name: functionSymbol.content,
+        args: allOtherArguments,
+        environment: data.environment,
+        onlyBuiltin: false,
+        controlDependencies: data.controlDependencies
+    });
+    for (const arg of processedArguments) {
+        if (arg) {
+            information.graph.addEdge(applyCallId, arg.entryPoint, { type: 64 /* EdgeType.Argument */ });
+        }
+    }
+    return information;
+}
+exports.processApply = processApply;
+//# sourceMappingURL=built-in-apply.js.map

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

@@ -5,7 +5,10 @@ import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model'
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { IdentifierDefinition } from '../../../../../environments/identifier';
 import type { ForceArguments } from '../common';
+import type { REnvironmentInformation } from '../../../../../environments/environment';
+import type { DataflowGraph } from '../../../../../graph/graph';
 export interface AssignmentConfiguration extends ForceArguments {
     readonly superAssignment?: boolean;
     readonly swapSourceAndTarget?: boolean;
@@ -20,7 +23,7 @@ export interface AssignmentConfiguration extends ForceArguments {
  */
 export declare function processAssignment<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: AssignmentConfiguration): DataflowInformation;
 export interface AssignmentToSymbolParameters<OtherInfo> extends AssignmentConfiguration {
-    readonly name: RSymbol<OtherInfo & ParentInformation>;
+    readonly nameOfAssignmentFunction: string;
     readonly source: RNode<OtherInfo & ParentInformation>;
     readonly args: [DataflowInformation, DataflowInformation];
     readonly target: RSymbol<OtherInfo & ParentInformation>;
@@ -28,3 +31,16 @@ export interface AssignmentToSymbolParameters<OtherInfo> extends AssignmentConfi
     readonly data: DataflowProcessorInformation<OtherInfo>;
     readonly information: DataflowInformation;
 }
+/**
+ * Consider a call like `x <- v`
+ * @param information        - the information to define the assignment within
+ * @param nodeToDefine       - `x`
+ * @param sourceIds          - `v`
+ * @param rootIdOfAssignment - `<-`
+ * @param quoteSource        - whether to quote the source (i.e., define `x` without a direct reference to `v`)
+ * @param superAssignment    - whether this is a super assignment (i.e., `<<-`)
+ */
+export declare function markAsAssignment(information: {
+    environment: REnvironmentInformation;
+    graph: DataflowGraph;
+}, nodeToDefine: IdentifierDefinition, sourceIds: readonly NodeId[], rootIdOfAssignment: NodeId, quoteSource?: boolean, superAssignment?: boolean): void;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processAssignment = void 0;
+exports.markAsAssignment = exports.processAssignment = void 0;
 const known_call_handling_1 = require("../known-call-handling");
 const assert_1 = require("../../../../../../util/assert");
 const log_1 = require("../../../../../../util/log");
@@ -15,7 +15,7 @@ function toReplacementSymbol(target, prefix, superAssignment) {
     return {
         type: "RSymbol" /* RType.Symbol */,
         info: target.info,
-        /* they are all mapped to <- in R, but we mark super as well */
+        /* they are all mapped to `<-` in R, but we mark super as well */
         content: `${prefix}${superAssignment ? '<<-' : '<-'}`,
         lexeme: target.lexeme,
         location: target.location,
@@ -44,7 +44,7 @@ args, rootId, data, config) {
         const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, reverseOrder: !config.swapSourceAndTarget, forceArgs: config.forceArgs });
         return processAssignmentToSymbol({
             ...config,
-            name,
+            nameOfAssignmentFunction: name.content,
             source,
             target,
             args: getEffectiveOrder(config, res.processedArguments),
@@ -110,7 +110,7 @@ function processAssignmentToString(target, args, name, rootId, data, config, sou
     });
     return processAssignmentToSymbol({
         ...config,
-        name,
+        nameOfAssignmentFunction: name.content,
         source,
         target: symbol,
         args: getEffectiveOrder(config, res.processedArguments),
@@ -122,10 +122,38 @@ function processAssignmentToString(target, args, name, rootId, data, config, sou
 function checkFunctionDef(source, sourceInfo) {
     return sourceInfo.graph.getVertex(source.info.id)?.tag === "function-definition" /* VertexType.FunctionDefinition */;
 }
+/**
+ * Consider a call like `x <- v`
+ * @param information        - the information to define the assignment within
+ * @param nodeToDefine       - `x`
+ * @param sourceIds          - `v`
+ * @param rootIdOfAssignment - `<-`
+ * @param quoteSource        - whether to quote the source (i.e., define `x` without a direct reference to `v`)
+ * @param superAssignment    - whether this is a super assignment (i.e., `<<-`)
+ */
+function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignment, quoteSource, superAssignment) {
+    information.environment = (0, define_1.define)(nodeToDefine, superAssignment, information.environment);
+    information.graph.setDefinitionOfVertex(nodeToDefine);
+    if (!quoteSource) {
+        for (const sourceId of sourceIds) {
+            information.graph.addEdge(nodeToDefine, sourceId, { type: 2 /* EdgeType.DefinedBy */ });
+        }
+    }
+    information.graph.addEdge(nodeToDefine, rootIdOfAssignment, { type: 2 /* EdgeType.DefinedBy */ });
+    // kinda dirty, but we have to remove existing read edges for the symbol, added by the child
+    const out = information.graph.outgoingEdges(nodeToDefine.nodeId);
+    for (const [id, edge] of (out ?? [])) {
+        edge.types &= ~1 /* EdgeType.Reads */;
+        if (edge.types == 0) {
+            out?.delete(id);
+        }
+    }
+}
+exports.markAsAssignment = markAsAssignment;
 /**
  * Helper function whenever it is known that the _target_ of an assignment is a (single) symbol (i.e. `x <- ...`, but not `names(x) <- ...`).
  */
-function processAssignmentToSymbol({ name, source, args: [targetArg, sourceArg], target, rootId, data, information, superAssignment, makeMaybe, quoteSource }) {
+function processAssignmentToSymbol({ nameOfAssignmentFunction, source, args: [targetArg, sourceArg], target, rootId, data, information, superAssignment, makeMaybe, quoteSource }) {
     const isFunctionDef = checkFunctionDef(source, sourceArg);
     const writeNodes = produceWrittenNodes(rootId, targetArg, isFunctionDef, data, makeMaybe ?? false);
     if (writeNodes.length !== 1 && log_1.log.settings.minLevel <= 4 /* LogLevel.Warn */) {
@@ -133,25 +161,12 @@ function processAssignmentToSymbol({ name, source, args: [targetArg, sourceArg],
     }
     // we drop the first arg which we use to pass along arguments :D
     const readFromSourceWritten = sourceArg.out.slice(1);
-    const readTargets = [{ nodeId: rootId, name: name.content, controlDependencies: data.controlDependencies }, ...sourceArg.unknownReferences, ...sourceArg.in, ...targetArg.in.filter(i => i.nodeId !== target.info.id), ...readFromSourceWritten];
+    const readTargets = [{ nodeId: rootId, name: nameOfAssignmentFunction, controlDependencies: data.controlDependencies }, ...sourceArg.unknownReferences, ...sourceArg.in, ...targetArg.in.filter(i => i.nodeId !== target.info.id), ...readFromSourceWritten];
     const writeTargets = [...writeNodes, ...writeNodes, ...readFromSourceWritten];
     information.environment = (0, overwrite_1.overwriteEnvironment)(targetArg.environment, sourceArg.environment);
     // install assigned variables in environment
     for (const write of writeNodes) {
-        information.environment = (0, define_1.define)(write, superAssignment, information.environment);
-        information.graph.setDefinitionOfVertex(write);
-        if (!quoteSource) {
-            information.graph.addEdge(write, source.info.id, { type: 2 /* EdgeType.DefinedBy */ });
-        }
-        information.graph.addEdge(write, rootId, { type: 2 /* EdgeType.DefinedBy */ });
-        // kinda dirty, but we have to remove existing read edges for the symbol, added by the child
-        const out = information.graph.outgoingEdges(write.nodeId);
-        for (const [id, edge] of (out ?? [])) {
-            edge.types &= ~1 /* EdgeType.Reads */;
-            if (edge.types == 0) {
-                out?.delete(id);
-            }
-        }
+        markAsAssignment(information, write, [source.info.id], rootId, quoteSource, superAssignment);
     }
     information.graph.addEdge(rootId, targetArg.entryPoint, { type: 8 /* EdgeType.Returns */ });
     if (quoteSource) {

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

@@ -5,16 +5,16 @@ const known_call_handling_1 = require("../known-call-handling");
 const logger_1 = require("../../../../../logger");
 const unpack_argument_1 = require("../argument/unpack-argument");
 const make_argument_1 = require("../argument/make-argument");
-/* we currently do not mark this as an unknown side effect, as we can enable/disable this with a toggle */
 function processLibrary(name, args, rootId, data) {
+    /* we do not really know what loading the library does and what side effects it causes, hence we mark it as an unknown side effect */
     if (args.length !== 1) {
         logger_1.dataflowLogger.warn(`Currently only one-arg library-likes are allows (for ${name.content}), skipping`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, hasUnknownSideEffect: true }).information;
     }
     const nameToLoad = (0, unpack_argument_1.unpackArgument)(args[0]);
     if (nameToLoad === undefined || nameToLoad.type !== "RSymbol" /* RType.Symbol */) {
         logger_1.dataflowLogger.warn('No library name provided, skipping');
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, hasUnknownSideEffect: true }).information;
     }
     // treat as a function call but convert the first argument to a string
     const newArg = {
@@ -27,7 +27,10 @@ function processLibrary(name, args, rootId, data) {
             str: nameToLoad.content
         }
     };
-    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args: (0, make_argument_1.wrapArgumentsUnnamed)([newArg], data.completeAst.idMap), rootId, data }).information;
+    return (0, known_call_handling_1.processKnownFunctionCall)({
+        name, args: (0, make_argument_1.wrapArgumentsUnnamed)([newArg], data.completeAst.idMap), rootId, data,
+        hasUnknownSideEffect: true
+    }).information;
 }
 exports.processLibrary = processLibrary;
 //# sourceMappingURL=built-in-library.js.map

package/dataflow/internal/process/functions/call/known-call-handling.d.ts

@@ -13,15 +13,19 @@ export interface ProcessKnownFunctionCallInput<OtherInfo> extends ForceArguments
     readonly args: readonly (RNode<OtherInfo & ParentInformation> | RFunctionArgument<OtherInfo & ParentInformation>)[];
     readonly rootId: NodeId;
     readonly data: DataflowProcessorInformation<OtherInfo & ParentInformation>;
+    /** should arguments be processed from right to left? This does not affect the order recorded in the call but of the environments */
     readonly reverseOrder?: boolean;
     /** which arguments are to be marked as {@link EdgeType#NonStandardEvaluation|non-standard-evaluation}? */
     readonly markAsNSE?: readonly number[];
+    /** allows passing a data processor in-between each argument */
     readonly patchData?: (data: DataflowProcessorInformation<OtherInfo & ParentInformation>, arg: number) => DataflowProcessorInformation<OtherInfo & ParentInformation>;
+    /** Does the call have a side effect that we do not know a lot about which may have further consequences? */
+    readonly hasUnknownSideEffect?: boolean;
 }
 export interface ProcessKnownFunctionCallResult {
     readonly information: DataflowInformation;
     readonly processedArguments: readonly (DataflowInformation | undefined)[];
     readonly fnRef: IdentifierReference;
 }
-export declare function markNonStandardEvaluationEdges(markAsNSE: readonly number[] | undefined, callArgs: readonly (DataflowInformation | undefined)[], finalGraph: DataflowGraph, rootId: NodeId): void;
-export declare function processKnownFunctionCall<OtherInfo>({ name, args, rootId, data, reverseOrder, markAsNSE, forceArgs, patchData }: ProcessKnownFunctionCallInput<OtherInfo>): ProcessKnownFunctionCallResult;
+export declare function markNonStandardEvaluationEdges(markAsNSE: readonly number[], callArgs: readonly (DataflowInformation | undefined)[], finalGraph: DataflowGraph, rootId: NodeId): void;
+export declare function processKnownFunctionCall<OtherInfo>({ name, args, rootId, data, reverseOrder, markAsNSE, forceArgs, patchData, hasUnknownSideEffect }: ProcessKnownFunctionCallInput<OtherInfo>): ProcessKnownFunctionCallResult;

package/dataflow/internal/process/functions/call/known-call-handling.js

@@ -5,10 +5,8 @@ const processor_1 = require("../../../../processor");
 const common_1 = require("./common");
 const graph_1 = require("../../../../graph/graph");
 const logger_1 = require("../../../../logger");
+const log_1 = require("../../../../../util/log");
 function markNonStandardEvaluationEdges(markAsNSE, callArgs, finalGraph, rootId) {
-    if (markAsNSE === undefined) {
-        return;
-    }
     for (const nse of markAsNSE) {
         if (nse < callArgs.length) {
             const arg = callArgs[nse];
@@ -22,14 +20,16 @@ function markNonStandardEvaluationEdges(markAsNSE, callArgs, finalGraph, rootId)
     }
 }
 exports.markNonStandardEvaluationEdges = markNonStandardEvaluationEdges;
-function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = false, markAsNSE = undefined, forceArgs, patchData = d => d }) {
+function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = false, markAsNSE = undefined, forceArgs, patchData = d => d, hasUnknownSideEffect }) {
     const functionName = (0, processor_1.processDataflowFor)(name, data);
     const finalGraph = new graph_1.DataflowGraph(data.completeAst.idMap);
     const functionCallName = name.content;
-    logger_1.dataflowLogger.debug(`Using ${rootId} (name: ${functionCallName}) as root for the named function call`);
+    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Processing known function call ${functionCallName} with ${args.length} arguments`);
     const processArgs = reverseOrder ? [...args].reverse() : args;
     const { finalEnv, callArgs, remainingReadInArgs, processedArguments } = (0, common_1.processAllArguments)({ functionName, args: processArgs, data, finalGraph, functionRootId: rootId, patchData, forceArgs });
-    markNonStandardEvaluationEdges(markAsNSE, processedArguments, finalGraph, rootId);
+    if (markAsNSE) {
+        markNonStandardEvaluationEdges(markAsNSE, processedArguments, finalGraph, rootId);
+    }
     finalGraph.addVertex({
         tag: "function-call" /* VertexType.FunctionCall */,
         id: rootId,
@@ -40,6 +40,9 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
         controlDependencies: data.controlDependencies,
         args: reverseOrder ? [...callArgs].reverse() : callArgs
     });
+    if (hasUnknownSideEffect) {
+        finalGraph.markIdForUnknownSideEffects(rootId);
+    }
     const inIds = remainingReadInArgs;
     const fnRef = { nodeId: rootId, name: functionCallName, controlDependencies: data.controlDependencies, call: true };
     inIds.push(fnRef);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.0.17",
+  "version": "2.0.19",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {

package/r-bridge/data/data.d.ts

@@ -231,6 +231,11 @@ export declare const flowrCapabilities: {
                             readonly id: "local-equal-assignment";
                             readonly supported: "fully";
                             readonly description: "_Handle `x = 3`, `x$y := 3`, ..._";
+                        }, {
+                            readonly name: "Local Table Assignment";
+                            readonly id: "local-table-assignment";
+                            readonly supported: "fully";
+                            readonly description: "_Handle `x[,a:=3,]`, ..._";
                         }, {
                             readonly name: "Super Left Assignment";
                             readonly id: "super-left-assignment";

package/r-bridge/data/data.js

@@ -288,6 +288,12 @@ exports.flowrCapabilities = {
                                                     supported: 'fully',
                                                     description: '_Handle `x = 3`, `x$y := 3`, ..._'
                                                 },
+                                                {
+                                                    name: 'Local Table Assignment',
+                                                    id: 'local-table-assignment',
+                                                    supported: 'fully',
+                                                    description: '_Handle `x[,a:=3,]`, ..._'
+                                                },
                                                 {
                                                     name: 'Super Left Assignment',
                                                     id: 'super-left-assignment',

package/r-bridge/lang-4.x/ast/model/operators.js

@@ -34,7 +34,7 @@ exports.OperatorDatabase = {
     '%in%': { name: 'matching operator', stringUsedInRAst: '%in%', stringUsedInternally: '%in%', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'special-operator', 'function-calls'] },
     /* assignment */
     '<-': { name: 'left assignment', stringUsedInRAst: "LEFT_ASSIGN" /* RawRType.LeftAssign */, stringUsedInternally: '<-', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-left-assignment', 'function-calls'] },
-    ':=': { name: 'left assignment', stringUsedInRAst: "LEFT_ASSIGN" /* RawRType.LeftAssign */, stringUsedInternally: ':=', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-equal-assignment', 'function-calls'] },
+    ':=': { name: 'left assignment', stringUsedInRAst: "LEFT_ASSIGN" /* RawRType.LeftAssign */, stringUsedInternally: ':=', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-table-assignment', 'function-calls'] },
     '<<-': { name: 'left global assignment', stringUsedInRAst: "LEFT_ASSIGN" /* RawRType.LeftAssign */, stringUsedInternally: '<<-', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'super-left-assignment', 'function-calls'] },
     '->': { name: 'right assignment', stringUsedInRAst: "RIGHT_ASSIGN" /* RawRType.RightAssign */, stringUsedInternally: '->', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-right-assignment', 'function-calls'] },
     '->>': { name: 'right global assignment', stringUsedInRAst: "RIGHT_ASSIGN" /* RawRType.RightAssign */, stringUsedInternally: '->>', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'super-right-assignment', 'function-calls'] },

package/reconstruct/auto-select/auto-select-defaults.d.ts

@@ -1,4 +1,4 @@
-import type { NoInfo, RNode } from '../../r-bridge/lang-4.x/ast/model/model';
+import type { RNode } from '../../r-bridge/lang-4.x/ast/model/model';
 import type { ParentInformation, NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 /**
  * The structure of the predicate that should be used to determine
@@ -14,8 +14,3 @@ export type AutoSelectPredicate = (node: RNode<ParentInformation>, fullAst: Norm
  * A variant of the {@link AutoSelectPredicate} which does not select any additional statements (~&gt; false)
  */
 export declare function doNotAutoSelect(_node: RNode): boolean;
-/**
- * A variant of the {@link AutoSelectPredicate} which does its best
- * to select any kind of library import automatically.
- */
-export declare function autoSelectLibrary<Info = NoInfo>(node: RNode<Info>): boolean;

package/reconstruct/auto-select/auto-select-defaults.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.autoSelectLibrary = exports.doNotAutoSelect = void 0;
+exports.doNotAutoSelect = void 0;
 /**
  * A variant of the {@link AutoSelectPredicate} which does not select any additional statements (~> false)
  */
@@ -8,16 +8,4 @@ function doNotAutoSelect(_node) {
     return false;
 }
 exports.doNotAutoSelect = doNotAutoSelect;
-const libraryFunctionCall = /^(library|require|((require|load|attach)Namespace))$/;
-/**
- * A variant of the {@link AutoSelectPredicate} which does its best
- * to select any kind of library import automatically.
- */
-function autoSelectLibrary(node) {
-    if (node.type !== "RFunctionCall" /* RType.FunctionCall */ || !node.named) {
-        return false;
-    }
-    return libraryFunctionCall.test(node.functionName.content);
-}
-exports.autoSelectLibrary = autoSelectLibrary;
 //# sourceMappingURL=auto-select-defaults.js.map

package/reconstruct/reconstruct.js

@@ -424,7 +424,7 @@ function removeOuterExpressionListIfApplicable(result, linesWithAutoSelected) {
  *
  * @returns The number of lines for which `autoSelectIf` triggered, as well as the reconstructed code itself.
  */
-function reconstructToCode(ast, selection, autoSelectIf = auto_select_defaults_1.autoSelectLibrary) {
+function reconstructToCode(ast, selection, autoSelectIf = auto_select_defaults_1.doNotAutoSelect) {
     if (exports.reconstructLogger.settings.minLevel <= 1 /* LogLevel.Trace */) {
         exports.reconstructLogger.trace(`reconstruct ast with ids: ${JSON.stringify([...selection])}`);
     }

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = void 0;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.0.17';
+const version = '2.0.19';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }