@eagleoutice/flowr 2.2.10 → 2.2.12

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

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processEvalCall = processEvalCall;
+const info_1 = require("../../../../../info");
+const config_1 = require("../../../../../../config");
+const known_call_handling_1 = require("../known-call-handling");
+const retriever_1 = require("../../../../../../r-bridge/retriever");
+const decorate_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate");
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const logger_1 = require("../../../../../logger");
+const log_1 = require("../../../../../../util/log");
+const built_in_source_1 = require("./built-in-source");
+const edge_1 = require("../../../../../graph/edge");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
+const append_1 = require("../../../../../environments/append");
+const assert_1 = require("../../../../../../util/assert");
+const arrays_1 = require("../../../../../../util/arrays");
+function processEvalCall(name, args, rootId, data, config) {
+    if (args.length !== 1 || args[0] === r_function_call_1.EmptyArgument || !args[0].value) {
+        logger_1.dataflowLogger.warn(`Expected exactly one argument for eval currently, but got ${args.length} instead, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const information = config.includeFunctionCall ?
+        (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: [true] }).information
+        : (0, info_1.initializeCleanDataflowInformation)(rootId, data);
+    const evalArgument = args[0];
+    if (config.includeFunctionCall) {
+        information.graph.addEdge(rootId, args[0].value.info.id, edge_1.EdgeType.Returns);
+    }
+    if (!(0, config_1.getConfig)().solver.evalStrings) {
+        (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Skipping eval call ${JSON.stringify(evalArgument)} (disabled in config file)`);
+        information.graph.markIdForUnknownSideEffects(rootId);
+        return information;
+    }
+    const code = resolveEvalToCode(evalArgument.value, data.environment, data.completeAst.idMap);
+    if (code) {
+        const idGenerator = (0, decorate_1.sourcedDeterministicCountingIdGenerator)(name.lexeme + '::' + rootId, name.location);
+        data = {
+            ...data,
+            controlDependencies: [...(data.controlDependencies ?? []), { id: rootId, when: true }]
+        };
+        const originalInfo = { ...information };
+        const result = [];
+        for (const c of code) {
+            const codeRequest = (0, retriever_1.requestFromInput)(c);
+            const r = (0, built_in_source_1.sourceRequest)(rootId, codeRequest, data, originalInfo, idGenerator);
+            result.push(r);
+            // add a returns edge from the eval to the result
+            for (const e of r.exitPoints) {
+                information.graph.addEdge(rootId, e, edge_1.EdgeType.Returns);
+            }
+        }
+        return {
+            graph: result.reduce((acc, r) => acc.mergeWith(r.graph), information.graph),
+            environment: result.reduce((acc, r) => (0, append_1.appendEnvironment)(acc, r.environment), information.environment),
+            entryPoint: rootId,
+            out: [...information.out, ...result.flatMap(r => r.out)],
+            in: [...information.in, ...result.flatMap(r => r.in)],
+            unknownReferences: [...information.unknownReferences, ...result.flatMap(r => r.unknownReferences)],
+            exitPoints: [...information.exitPoints, ...result.flatMap(r => r.exitPoints)],
+        };
+    }
+    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Non-constant argument ${JSON.stringify(args)} for eval is currently not supported, skipping`);
+    information.graph.markIdForUnknownSideEffects(rootId);
+    return information;
+}
+function resolveEvalToCode(evalArgument, env, idMap) {
+    const val = evalArgument;
+    if (val.type === type_1.RType.FunctionCall && val.named && val.functionName.content === 'parse') {
+        const arg = val.arguments.find(v => v !== r_function_call_1.EmptyArgument && v.name?.content === 'text');
+        const nArg = val.arguments.find(v => v !== r_function_call_1.EmptyArgument && v.name?.content === 'n');
+        if (nArg !== undefined || arg === undefined || arg === r_function_call_1.EmptyArgument) {
+            return undefined;
+        }
+        if (arg.value?.type === type_1.RType.String) {
+            return [arg.value.content.str];
+        }
+        else if (arg.value?.type === type_1.RType.Symbol) {
+            const resolve = (0, resolve_by_name_1.resolveValueOfVariable)(arg.value.content, env, idMap);
+            if (resolve && resolve.every(r => typeof r === 'object' && r !== null && 'str' in r)) {
+                return resolve.map(r => r.str);
+            }
+        }
+        else if (arg.value?.type === type_1.RType.FunctionCall && arg.value.named && ['paste', 'paste0'].includes(arg.value.functionName.content)) {
+            return handlePaste(arg.value.arguments, env, idMap, arg.value.functionName.content === 'paste' ? [' '] : ['']);
+        }
+        return undefined;
+    }
+    else if (val.type === type_1.RType.Symbol) {
+        // const resolved = resolveValueOfVariable(val.content, env);
+        // see https://github.com/flowr-analysis/flowr/pull/1467
+        return undefined;
+    }
+    else {
+        return undefined;
+    }
+}
+function getAsString(val, env, idMap) {
+    if (!val) {
+        return undefined;
+    }
+    if (val.type === type_1.RType.String) {
+        return [val.content.str];
+    }
+    else if (val.type === type_1.RType.Symbol) {
+        const resolved = (0, resolve_by_name_1.resolveValueOfVariable)(val.content, env, idMap);
+        if (resolved && resolved.every(r => typeof r === 'object' && r !== null && 'str' in r)) {
+            return resolved.map(r => r.str);
+        }
+    }
+    return undefined;
+}
+function handlePaste(args, env, idMap, sepDefault) {
+    const sepArg = args.find(v => v !== r_function_call_1.EmptyArgument && v.name?.content === 'sep');
+    if (sepArg) {
+        const res = sepArg !== r_function_call_1.EmptyArgument && sepArg.value ? getAsString(sepArg.value, env, idMap) : undefined;
+        if (!res) {
+            // sep not resolvable clearly / unknown
+            return undefined;
+        }
+        sepDefault = res;
+    }
+    const allArgs = args
+        .filter(v => v !== r_function_call_1.EmptyArgument && v.name?.content !== 'sep' && v.value)
+        .map(v => getAsString(v.value, env, idMap));
+    if (allArgs.some(assert_1.isUndefined)) {
+        return undefined;
+    }
+    // return all cartesian products using the separator
+    const result = [];
+    const cartesianProducts = (0, arrays_1.cartesianProduct)(...allArgs);
+    for (const sep of sepDefault) {
+        for (const c of cartesianProducts) {
+            result.push(c.join(sep));
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=built-in-eval.js.map

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

@@ -17,6 +17,7 @@ const scoping_1 = require("../../../../../environments/scoping");
 const built_in_1 = require("../../../../../environments/built-in");
 const overwrite_1 = require("../../../../../environments/overwrite");
 const logger_1 = require("../../../../../logger");
+const log_1 = require("../../../../../../util/log");
 const dotDotDotAccess = /^\.\.\d+$/;
 function linkReadNameToWriteIfPossible(read, environments, listEnvironments, remainingRead, nextGraph) {
     const readName = read.name && dotDotDotAccess.test(read.name) ? '...' : read.name;
@@ -83,7 +84,7 @@ function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextG
 }
 function processExpressionList(name, args, rootId, data) {
     const expressions = args.map(e => (0, unpack_argument_1.unpackArgument)(e));
-    logger_1.dataflowLogger.trace(() => `[expr list] with ${expressions.length} expressions`);
+    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `[expr list] with ${expressions.length} expressions`);
     let { environment } = data;
     // used to detect if a "write" happens within the same expression list
     const listEnvironments = new Set();
@@ -95,7 +96,7 @@ function processExpressionList(name, args, rootId, data) {
     const processedExpressions = [];
     let defaultReturnExpr = undefined;
     for (const expression of expressions) {
-        logger_1.dataflowLogger.trace(`processing expression ${++expressionCounter} of ${expressions.length}`);
+        (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `processing expression ${++expressionCounter} of ${expressions.length}`);
         if (expression === undefined) {
             processedExpressions.push(undefined);
             continue;
@@ -115,7 +116,7 @@ function processExpressionList(name, args, rootId, data) {
         }
         (0, info_1.addNonDefaultExitPoints)(exitPoints, processed.exitPoints);
         out.push(...processed.out);
-        logger_1.dataflowLogger.trace(`expression ${expressionCounter} of ${expressions.length} has ${processed.unknownReferences.length} unknown nodes`);
+        (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `expression ${expressionCounter} of ${expressions.length} has ${processed.unknownReferences.length} unknown nodes`);
         processNextExpression(processed, environment, listEnvironments, remainingRead, nextGraph);
         environment = exitPoints.length > 0 ? (0, overwrite_1.overwriteEnvironment)(environment, processed.environment) : processed.environment;
         const calledEnvs = (0, linker_1.linkFunctionCalls)(nextGraph, data.completeAst.idMap, processed.graph);

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

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processList = processList;
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
-const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
 const known_call_handling_1 = require("../known-call-handling");
 const config_1 = require("../../../../../../config");
+const containers_1 = require("../../../../../../util/containers");
 /**
  * Process a list call.
  *
@@ -15,36 +15,70 @@ const config_1 = require("../../../../../../config");
  * ```
  */
 function processList(name, args, rootId, data) {
+    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data });
     if (!(0, config_1.getConfig)().solver.pointerTracking) {
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return fnCall.information;
     }
-    const namedArguments = [];
+    const listArgs = [];
     for (const arg of args) {
         // Skip non named arguments
-        if (arg === r_function_call_1.EmptyArgument || arg.type !== type_1.RType.Argument || arg.name === undefined) {
+        if (arg === r_function_call_1.EmptyArgument || arg.type !== type_1.RType.Argument || arg.value === undefined) {
             continue;
         }
-        let newIndex = {
-            lexeme: arg.name.content,
-            nodeId: arg.info.id,
-        };
-        // Check whether argument value is non-primitive
-        if (arg.value?.type === type_1.RType.Symbol) {
-            const defs = (0, resolve_by_name_1.resolveByName)(arg.value.lexeme, data.environment);
-            const indices = defs?.flatMap(index => index.indicesCollection ?? []);
-            if (indices) {
+        let newIndex;
+        if (arg.name) {
+            // Named argument
+            newIndex = {
+                identifier: {
+                    index: arg.info.index,
+                    lexeme: arg.name.content
+                },
+                nodeId: arg.info.id,
+            };
+        }
+        else {
+            // Unnamed argument
+            newIndex = {
+                identifier: {
+                    index: arg.info.index,
+                },
+                nodeId: arg.value.info.id,
+            };
+        }
+        // Check whether argument value can be resolved
+        if (arg.value.type === type_1.RType.Symbol) {
+            const indicesCollection = (0, containers_1.resolveIndicesByName)(arg.value.lexeme, data.environment);
+            if (indicesCollection) {
                 newIndex = {
                     ...newIndex,
-                    subIndices: indices,
+                    subIndices: indicesCollection,
                 };
             }
         }
-        namedArguments.push(newIndex);
+        else {
+            // Check whether argument is nested container
+            const indicesCollection = fnCall.information.graph.getVertex(arg.value.info.id)?.indicesCollection;
+            if (indicesCollection) {
+                newIndex = {
+                    ...newIndex,
+                    subIndices: indicesCollection,
+                };
+            }
+        }
+        listArgs.push(newIndex);
+    }
+    if ((0, config_1.isOverPointerAnalysisThreshold)(listArgs.length)) {
+        return fnCall.information;
     }
     const indices = {
-        indices: namedArguments,
+        indices: listArgs,
         isContainer: true,
     };
-    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }, [indices]).information;
+    // Add resolved indices to vertex
+    const vertex = fnCall.information.graph.getVertex(rootId);
+    if (vertex) {
+        vertex.indicesCollection = [indices];
+    }
+    return fnCall.information;
 }
 //# sourceMappingURL=built-in-list.js.map

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

@@ -35,11 +35,29 @@ function processPipe(name, args, rootId, data) {
         information.graph.addEdge(functionCallNode.id, argId, edge_1.EdgeType.Argument | edge_1.EdgeType.Reads);
     }
     const firstArgument = processedArguments[0];
+    const uniqueIn = [...information.in];
+    for (const ing of (firstArgument?.in ?? [])) {
+        if (!uniqueIn.find(e => e.nodeId === ing.nodeId)) {
+            uniqueIn.push(ing);
+        }
+    }
+    const uniqueOut = [...information.out];
+    for (const outg of (firstArgument?.out ?? [])) {
+        if (!uniqueOut.find(e => e.nodeId === outg.nodeId)) {
+            uniqueOut.push(outg);
+        }
+    }
+    const uniqueUnknownReferences = [...information.unknownReferences];
+    for (const unknown of (firstArgument?.unknownReferences ?? [])) {
+        if (!uniqueUnknownReferences.find(e => e.nodeId === unknown.nodeId)) {
+            uniqueUnknownReferences.push(unknown);
+        }
+    }
     return {
         ...information,
-        in: [...information.in, ...firstArgument.in],
-        out: [...information.out, ...firstArgument.out],
-        unknownReferences: [...information.unknownReferences, ...firstArgument.unknownReferences],
+        in: uniqueIn,
+        out: uniqueOut,
+        unknownReferences: uniqueUnknownReferences,
         entryPoint: rootId
     };
 }

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

@@ -5,9 +5,12 @@ import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/
 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 { ContainerIndicesCollection } from '../../../../../graph/vertex';
 export declare function processReplacementFunction<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, 
 /** The last one has to be the value */
 args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     makeMaybe?: boolean;
     assignmentOperator?: '<-' | '<<-';
+    readIndices?: boolean;
+    activeIndices?: ContainerIndicesCollection;
 } & ForceArguments): DataflowInformation;

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

@@ -6,16 +6,15 @@ const known_call_handling_1 = require("../known-call-handling");
 const log_1 = require("../../../../../../util/log");
 const built_in_assignment_1 = require("./built-in-assignment");
 const common_1 = require("../common");
-const assert_1 = require("../../../../../../util/assert");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const logger_1 = require("../../../../../logger");
-const vertex_1 = require("../../../../../graph/vertex");
 const graph_1 = require("../../../../../graph/graph");
 const edge_1 = require("../../../../../graph/edge");
-const dfg_1 = require("../../../../../../util/mermaid/dfg");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
-const list_access_1 = require("../../../../../../util/list-access");
+const containers_1 = require("../../../../../../util/containers");
 const config_1 = require("../../../../../../config");
+const unpack_argument_1 = require("../argument/unpack-argument");
+const built_in_access_1 = require("./built-in-access");
 function processReplacementFunction(name, 
 /** The last one has to be the value */
 args, rootId, data, config) {
@@ -25,45 +24,38 @@ args, rootId, data, config) {
     }
     /* we only get here if <-, <<-, ... or whatever is part of the replacement is not overwritten */
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Replacement ${name.content} with ${JSON.stringify(args)}, processing`);
-    let indices = undefined;
-    if (name.content === '$<-' && (0, config_1.getConfig)().solver.pointerTracking) {
-        const nonEmptyArgs = args.filter(arg => arg !== r_function_call_1.EmptyArgument);
-        const accessedArg = nonEmptyArgs.find(arg => arg.info.role === "accessed" /* RoleInParent.Accessed */);
-        const accessArg = nonEmptyArgs.find(arg => arg.info.role === "index-access" /* RoleInParent.IndexAccess */);
-        if (accessArg !== undefined && accessedArg != undefined) {
-            const leafIndex = { lexeme: accessArg.lexeme, nodeId: accessedArg.info.parent ?? '' };
-            const accessIndices = {
-                indices: [leafIndex],
-                isContainer: false
-            };
-            // Check for nested access
-            if (accessedArg.value?.type === type_1.RType.Access) {
-                indices = (0, list_access_1.constructNestedAccess)(accessedArg.value, accessIndices);
-            }
-            else {
-                // use access node as reference to get complete line in slice
-                indices = [accessIndices];
-            }
-        }
+    let indices = config.activeIndices;
+    if ((0, config_1.getConfig)().solver.pointerTracking) {
+        indices ??= constructAccessedIndices(name.content, args);
     }
     /* we assign the first argument by the last for now and maybe mark as maybe!, we can keep the symbol as we now know we have an assignment */
     const res = (0, built_in_assignment_1.processAssignment)(name, [args[0], args[args.length - 1]], rootId, data, {
         superAssignment: config.assignmentOperator === '<<-',
         makeMaybe: indices !== undefined ? false : config.makeMaybe,
-        indicesCollection: indices
+        indicesCollection: indices,
+        canBeReplacement: true
     });
+    const convertedArgs = config.readIndices ? args.slice(1, -1) : (0, built_in_access_1.symbolArgumentsToStrings)(args.slice(1, -1), 0);
     /* now, we soft-inject other arguments, so that calls like `x[y] <- 3` are linked correctly */
     const { callArgs } = (0, common_1.processAllArguments)({
         functionName: (0, info_1.initializeCleanDataflowInformation)(rootId, data),
-        args: args.slice(1, -1),
+        args: convertedArgs,
         data,
         functionRootId: rootId,
         finalGraph: res.graph,
         forceArgs: config.forceArgs,
     });
-    const fn = res.graph.getVertex(rootId, true);
-    (0, assert_1.guard)(fn?.tag === vertex_1.VertexType.FunctionCall && fn.args.length === 2, () => `Function ${rootId} not found in graph or not 2-arg fn-call (${JSON.stringify(fn)}) ${(0, dfg_1.graphToMermaidUrl)(res.graph)}`);
-    fn.args = [fn.args[0], ...callArgs, fn.args[1]];
+    (0, common_1.patchFunctionCall)({
+        nextGraph: res.graph,
+        data,
+        rootId,
+        name,
+        argumentProcessResult: args.map(a => a === r_function_call_1.EmptyArgument ? undefined : { entryPoint: (0, unpack_argument_1.unpackArgument)(a)?.info.id })
+    });
+    const firstArg = (0, unpack_argument_1.unpackArgument)(args[0])?.info.id;
+    if (firstArg) {
+        res.graph.addEdge(firstArg, rootId, edge_1.EdgeType.DefinedBy | edge_1.EdgeType.Reads);
+    }
     /* a replacement reads all of its call args as well, at least as far as I am aware of */
     for (const arg of callArgs) {
         const ref = (0, graph_1.getReferenceOfArgument)(arg);
@@ -73,4 +65,66 @@ args, rootId, data, config) {
     }
     return res;
 }
+/**
+ * Constructs accessed indices of replacement function recursively.
+ *
+ * Example:
+ * ```r
+ * a$b <- 1
+ * # results in index with lexeme b as identifier
+ *
+ * a[[1]]$b
+ * # results in index with index 1 as identifier with a sub-index with lexeme b as identifier
+ * ```
+ *
+ * @param operation - Operation of replacement function e.g. '$\<-', '[\<-', '[[\<-'
+ * @param args      - Arguments of the replacement function
+ * @returns Accessed indices construct
+ */
+function constructAccessedIndices(operation, args) {
+    const { accessedArg, accessArg } = (0, containers_1.getAccessOperands)(args);
+    if (accessedArg === undefined || accessArg?.value === undefined || !isSupportedOperation(operation, accessArg.value)) {
+        return undefined;
+    }
+    const constructIdentifier = getIdentifierBuilder(operation);
+    const leafIndex = {
+        identifier: constructIdentifier(accessArg),
+        nodeId: accessedArg.info.parent ?? ''
+    };
+    const accessIndices = {
+        indices: [leafIndex],
+        isContainer: false
+    };
+    // Check for nested access
+    let indicesCollection = undefined;
+    if (accessedArg.value?.type === type_1.RType.Access) {
+        indicesCollection = (0, containers_1.constructNestedAccess)(accessedArg.value, accessIndices, constructIdentifier);
+    }
+    else {
+        // use access node as reference to get complete line in slice
+        indicesCollection = [accessIndices];
+    }
+    return indicesCollection;
+}
+function isSupportedOperation(operation, value) {
+    const isNameBasedAccess = (operation === '$<-' || operation === '@<-') && value.type === type_1.RType.Symbol;
+    const isNumericalIndexBasedAccess = (operation === '[[<-' || operation === '[<-') && value.type === type_1.RType.Number;
+    return isNameBasedAccess || isNumericalIndexBasedAccess;
+}
+function getIdentifierBuilder(operation) {
+    if (operation === '$<-' || operation == '@<-') {
+        return (arg) => {
+            return {
+                index: undefined,
+                lexeme: arg.lexeme,
+            };
+        };
+    }
+    // [[<- and [<-
+    return (arg) => {
+        return {
+            index: Number(arg.lexeme),
+        };
+    };
+}
 //# sourceMappingURL=built-in-replacement.js.map

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

@@ -0,0 +1,7 @@
+import type { DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+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';
+export declare function processRm<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processRm = processRm;
+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 remove_1 = require("../../../../../environments/remove");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+function processRm(name, args, rootId, data) {
+    if (args.length === 0) {
+        logger_1.dataflowLogger.warn('empty rm, skipping');
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    const names = [];
+    for (const arg of args) {
+        if (arg === r_function_call_1.EmptyArgument) {
+            logger_1.dataflowLogger.warn('empty argument in rm, skipping');
+            continue;
+        }
+        const unpacked = arg.value;
+        if (unpacked === undefined || (unpacked.type !== type_1.RType.Symbol && unpacked.type !== type_1.RType.String)) {
+            logger_1.dataflowLogger.warn(`argument is not a symbol or string, skipping ${JSON.stringify(unpacked)}`);
+        }
+        else if (unpacked.type === type_1.RType.Symbol) {
+            names.push(unpacked.content);
+        }
+        else if (unpacked.type === type_1.RType.String) {
+            names.push(unpacked.content.str);
+        }
+    }
+    let env = res.environment;
+    for (const name of names) {
+        env = (0, remove_1.remove)(name, env);
+    }
+    return {
+        ...res,
+        environment: env
+    };
+}
+//# sourceMappingURL=built-in-rm.js.map

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

@@ -103,6 +103,10 @@ function findSource(seed, data) {
     return found;
 }
 function processSourceCall(name, args, rootId, data, config) {
+    if (args.length !== 1) {
+        logger_1.dataflowLogger.warn(`Expected exactly one argument for source currently, but got ${args.length} instead, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
     const information = config.includeFunctionCall ?
         (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information
         : (0, info_1.initializeCleanDataflowInformation)(rootId, data);
@@ -135,12 +139,14 @@ function processSourceCall(name, args, rootId, data, config) {
         if (filepath !== undefined) {
             const request = sourceProvider.createRequest(filepath);
             // check if the sourced file has already been dataflow analyzed, and if so, skip it
-            if (data.referenceChain.find(e => e.request === request.request && e.content === request.content)) {
-                (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Found loop in dataflow analysis for ${JSON.stringify(request)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
+            const limit = (0, config_1.getConfig)().solver.resolveSource?.repeatedSourceLimit ?? 0;
+            const findCount = data.referenceChain.filter(e => e.request === request.request && e.content === request.content).length;
+            if (findCount > limit) {
+                logger_1.dataflowLogger.warn(`Found cycle (>=${limit + 1}) in dataflow analysis for ${JSON.stringify(request)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
                 information.graph.markIdForUnknownSideEffects(rootId);
                 return information;
             }
-            return sourceRequest(rootId, request, data, information, (0, decorate_1.sourcedDeterministicCountingIdGenerator)(path, name.location));
+            return sourceRequest(rootId, request, data, information, (0, decorate_1.sourcedDeterministicCountingIdGenerator)((findCount > 0 ? findCount + '::' : '') + path, name.location));
         }
     }
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Non-constant argument ${JSON.stringify(sourceFile)} for source is currently not supported, skipping`);
@@ -172,7 +178,8 @@ function sourceRequest(rootId, request, data, information, getId) {
         });
     }
     catch (e) {
-        logger_1.dataflowLogger.warn(`Failed to analyze sourced file ${JSON.stringify(request)}, skipping: ${e.message}`);
+        logger_1.dataflowLogger.error(`Failed to analyze sourced file ${JSON.stringify(request)}, skipping: ${e.message}`);
+        logger_1.dataflowLogger.error(e.stack);
         information.graph.markIdForUnknownSideEffects(rootId);
         return information;
     }
@@ -183,6 +190,7 @@ function sourceRequest(rootId, request, data, information, getId) {
     for (const out of dataflow.out) {
         dataflow.graph.addControlDependency(out.nodeId, rootId, true);
     }
+    dataflow.graph.addFile(request.request === 'file' ? request.content : '<inline>');
     // update our graph with the sourced file's information
     const newInformation = { ...information };
     newInformation.environment = (0, overwrite_1.overwriteEnvironment)(information.environment, dataflow.environment);
@@ -191,7 +199,13 @@ function sourceRequest(rootId, request, data, information, getId) {
     for (const [k, v] of normalized.idMap) {
         data.completeAst.idMap.set(k, v);
     }
-    return newInformation;
+    return {
+        ...newInformation,
+        in: newInformation.in.concat(dataflow.in),
+        out: newInformation.out.concat(dataflow.out),
+        unknownReferences: newInformation.unknownReferences.concat(dataflow.unknownReferences),
+        exitPoints: dataflow.exitPoints
+    };
 }
 function standaloneSourceFile(inputRequest, data, uniqueSourceId, information) {
     const path = inputRequest.request === 'file' ? inputRequest.content : '-inline-';
@@ -208,6 +222,6 @@ function standaloneSourceFile(inputRequest, data, uniqueSourceId, information) {
         currentRequest: request,
         environment: information.environment,
         referenceChain: [...data.referenceChain, inputRequest]
-    }, information, (0, decorate_1.deterministicPrefixIdGenerator)(path + '@' + uniqueSourceId));
+    }, information, (0, decorate_1.deterministicPrefixIdGenerator)(path + '::' + uniqueSourceId));
 }
 //# sourceMappingURL=built-in-source.js.map

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

@@ -0,0 +1,15 @@
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { DataflowInformation } from '../../../../../info';
+import type { DataflowProcessorInformation } from '../../../../../processor';
+/**
+ * Process a vector call.
+ *
+ * Example:
+ * ```r
+ * c(1, 2, 3, 4)
+ * ```
+ */
+export declare function processVector<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;