@eagleoutice/flowr 2.9.9 → 2.9.11

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

@@ -7,10 +7,10 @@ const known_call_handling_1 = require("../known-call-handling");
 const linker_1 = require("../../../../linker");
 const common_1 = require("../common");
 const unpack_argument_1 = require("../argument/unpack-argument");
-const r_argument_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument");
 const scoping_1 = require("../../../../../environments/scoping");
 const built_in_1 = require("../../../../../environments/built-in");
 const identifier_1 = require("../../../../../environments/identifier");
+const r_argument_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument");
 /**
  * Processes a built-in 'local' function call.
  */
@@ -24,8 +24,8 @@ function processLocal(name, args, rootId, data, config) {
         '...': '...'
     };
     const argMaps = (0, linker_1.invertArgumentMap)((0, linker_1.pMatch)((0, common_1.convertFnArguments)(args), params));
-    const env = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('env')?.[0]));
-    const expr = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('expr')?.[0]));
+    const env = (0, unpack_argument_1.unpackArg)(r_argument_1.RArgument.getWithId(args, argMaps.get('env')?.[0]));
+    const expr = (0, unpack_argument_1.unpackArg)(r_argument_1.RArgument.getWithId(args, argMaps.get('expr')?.[0]));
     if (!expr) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }

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

@@ -41,8 +41,8 @@ function processRepeatLoop(name, args, rootId, data) {
     });
     const body = processedArguments[0];
     (0, assert_1.guard)(body !== undefined, () => `Repeat-Loop ${identifier_1.Identifier.toString(name.content)} has no body, impossible!`);
-    (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph, [])), body.out);
-    (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences));
+    (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph)), body.out);
+    (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences), information.graph);
     information.exitPoints = (0, info_1.filterOutLoopExitPoints)(information.exitPoints);
     return information;
 }

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

@@ -4,7 +4,7 @@ import { type ForceArguments } from '../common';
 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 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 { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 /**
  * Process a replacement function call like `<-`, `[[<-`, `$<-`, etc.
  * These are automatically created when doing assignments like `x[y] <- value` or in general `fun(x) <- value` will call `fun<- (x, value)`.

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

@@ -6,6 +6,7 @@ const known_call_handling_1 = require("../known-call-handling");
 const log_1 = require("../../../../../../util/log");
 const common_1 = require("../common");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const node_id_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const logger_1 = require("../../../../../logger");
 const vertex_1 = require("../../../../../graph/vertex");
 const edge_1 = require("../../../../../graph/edge");
@@ -110,7 +111,7 @@ args, rootId, data, config) {
         fn.type = identifier_1.ReferenceType.S3MethodPrefix;
     }
     // link the built-in replacement op
-    res.graph.addEdge(rootId, (0, built_in_1.builtInId)(identifier_1.Identifier.getName(name.content)), edge_1.EdgeType.Calls | edge_1.EdgeType.Reads);
+    res.graph.addEdge(rootId, node_id_1.NodeId.toBuiltIn(identifier_1.Identifier.getName(name.content)), edge_1.EdgeType.Calls | edge_1.EdgeType.Reads);
     return res;
 }
 //# sourceMappingURL=built-in-replacement.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-s-seven-new-generic.js

@@ -33,7 +33,7 @@ function processS7NewGeneric(name, args, rootId, data, config) {
     params[config.args.fun] = 'fun';
     params['...'] = '...';
     const argMaps = (0, linker_1.invertArgumentMap)((0, linker_1.pMatch)((0, common_1.convertFnArguments)(args), params));
-    const genName = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('name')?.[0]));
+    const genName = (0, unpack_argument_1.unpackArg)(r_argument_1.RArgument.getWithId(args, argMaps.get('name')?.[0]));
     if (!genName) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
@@ -51,10 +51,10 @@ function processS7NewGeneric(name, args, rootId, data, config) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     data = { ...data, currentS7name: accessedIdentifiers };
-    let funArg = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('fun')?.[0]))?.info.id;
+    let funArg = (0, unpack_argument_1.unpackArg)(r_argument_1.RArgument.getWithId(args, argMaps.get('fun')?.[0]))?.info.id;
     const effectiveArgs = args.slice();
     if (!funArg) {
-        const dispatchArg = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('dispatchArg')?.[0]));
+        const dispatchArg = (0, unpack_argument_1.unpackArg)(r_argument_1.RArgument.getWithId(args, argMaps.get('dispatchArg')?.[0]));
         const newFun = makeS7DispatchFDef(name, [dispatchArg?.lexeme ?? undefined], rootId, args.length, data.completeAst.idMap);
         // fake it 'function([dispatch_args],...) S7_dispatch()'
         effectiveArgs.push(newFun[0]);
@@ -80,7 +80,7 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
         info: {
             id: argNameId,
             nesting: name.info.nesting,
-            role: "arg-name" /* RoleInParent.ArgumentName */,
+            role: "arg-n" /* RoleInParent.ArgumentName */,
             fullRange: r,
             adToks: undefined,
             file: name.info.file,
@@ -117,7 +117,7 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
         info: {
             id: rootId + '-s7-new-generic-fun-body',
             nesting: name.info.nesting,
-            role: "fun-body" /* RoleInParent.FunctionDefinitionBody */,
+            role: "fun-b" /* RoleInParent.FunctionDefinitionBody */,
             fullRange: r,
             adToks: undefined,
             file: name.info.file,
@@ -132,7 +132,7 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
             file: name.info.file,
             id: fdefId,
             nesting: name.info.nesting,
-            role: "arg-value" /* RoleInParent.ArgumentValue */,
+            role: "arg-v" /* RoleInParent.ArgumentValue */,
             parent: rootId,
             index: args + 1,
             adToks: undefined,
@@ -150,7 +150,7 @@ function makeS7DispatchFDef(name, names, rootId, args, idMap) {
                 info: {
                     id: paramNameId,
                     nesting: name.info.nesting,
-                    role: "param-name" /* RoleInParent.ParameterName */,
+                    role: "param-n" /* RoleInParent.ParameterName */,
                     fullRange: r,
                     adToks: undefined,
                     file: name.info.file,

package/dataflow/internal/process/functions/call/built-in/built-in-s-three-dispatch.js

@@ -8,13 +8,13 @@ const logger_1 = require("../../../../../logger");
 const built_in_1 = require("../../../../../environments/built-in");
 const linker_1 = require("../../../../linker");
 const common_1 = require("../common");
-const r_argument_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument");
 const unpack_argument_1 = require("../argument/unpack-argument");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 const r_value_1 = require("../../../../../eval/values/r-value");
 const identifier_1 = require("../../../../../environments/identifier");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const range_1 = require("../../../../../../util/range");
+const r_argument_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument");
 /**
  * Process an S3 dispatch call like `UseMethod`.
  */
@@ -29,11 +29,11 @@ function processS3Dispatch(name, args, rootId, data, config) {
         '...': '...'
     };
     const argMaps = (0, linker_1.invertArgumentMap)((0, linker_1.pMatch)((0, common_1.convertFnArguments)(args), params));
-    const generic = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('generic')?.[0]));
+    const generic = (0, unpack_argument_1.unpackArg)(r_argument_1.RArgument.getWithId(args, argMaps.get('generic')?.[0]));
     if (!generic && !config.inferFromClosure) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
-    const obj = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('object')?.[0]));
+    const obj = (0, unpack_argument_1.unpackArg)(r_argument_1.RArgument.getWithId(args, argMaps.get('object')?.[0]));
     const dfObj = obj ? (0, processor_1.processDataflowFor)(obj, data) : (0, info_1.initializeCleanDataflowInformation)(rootId, data);
     if ((0, info_1.alwaysExits)(dfObj)) {
         (0, common_1.patchFunctionCall)({

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

@@ -155,19 +155,30 @@ function processSourceCall(name, args, rootId, data, config) {
     if (sourceFile?.length === 1) {
         const path = (0, retriever_1.removeRQuotes)(sourceFile[0]);
         let filepath = path ? findSource(data.ctx.config.solver.resolveSource, path, data) : path;
-        if (Array.isArray(filepath)) {
-            filepath = filepath?.[0];
+        if (!Array.isArray(filepath)) {
+            filepath = filepath ? [filepath] : undefined;
         }
-        if (filepath !== undefined) {
-            // check if the sourced file has already been dataflow analyzed, and if so, skip it
-            const limit = data.ctx.config.solver.resolveSource?.repeatedSourceLimit ?? 0;
-            const findCount = data.referenceChain.filter(e => e !== undefined && filepath === e).length;
-            if (findCount > limit) {
-                logger_1.dataflowLogger.warn(`Found cycle (>=${limit + 1}) in dataflow analysis for ${JSON.stringify(filepath)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
-                (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
-                return information;
+        if (filepath !== undefined && filepath.length > 0) {
+            let result = information;
+            const origCds = data.cds?.slice() ?? [];
+            for (const f of filepath) {
+                // check if the sourced file has already been dataflow analyzed, and if so, skip it
+                const limit = data.ctx.config.solver.resolveSource?.repeatedSourceLimit ?? 0;
+                const findCount = data.referenceChain.filter(e => e !== undefined && f === e).length;
+                if (findCount > limit) {
+                    logger_1.dataflowLogger.warn(`Found cycle (>=${limit + 1}) in dataflow analysis for ${JSON.stringify(filepath)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
+                    (0, unknown_side_effect_1.handleUnknownSideEffect)(result.graph, result.environment, rootId);
+                    continue;
+                }
+                if (filepath.length > 1) {
+                    data = { ...data, cds: [...origCds, { id: rootId, when: true, file: f }] };
+                }
+                result = sourceRequest(rootId, {
+                    request: 'file',
+                    content: f
+                }, data, result, (0, decorate_1.sourcedDeterministicCountingIdGenerator)((findCount > 0 ? findCount + '::' : '') + f, name.location));
             }
-            return sourceRequest(rootId, { request: 'file', content: filepath }, data, information, (0, decorate_1.sourcedDeterministicCountingIdGenerator)((findCount > 0 ? findCount + '::' : '') + path, name.location));
+            return result;
         }
     }
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Non-constant argument ${JSON.stringify(sourceFile)} for source is currently not supported, skipping`);

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

@@ -14,6 +14,7 @@ const general_1 = require("../../../../../eval/values/general");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 const reference_to_maybe_1 = require("../../../../../environments/reference-to-maybe");
 const built_in_1 = require("../../../../../environments/built-in");
+const append_1 = require("../../../../../environments/append");
 /**
  * Process a while loop like `while(cond) { ... }`.
  */
@@ -27,6 +28,8 @@ function processWhileLoop(name, args, rootId, data) {
         logger_1.dataflowLogger.warn(`While-Loop ${identifier_1.Identifier.toString(name.content)} has empty arguments in ${JSON.stringify(args)}, skipping`);
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
+    const nameId = name.info.id;
+    const origEnv = data.environment;
     // we should defer this to the abstract interpretation
     const values = (0, alias_tracking_1.resolveIdToValue)(unpackedArgs[0]?.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.ctx.config.solver.variables, ctx: data.ctx });
     const conditionIsAlwaysFalse = (0, general_1.valueSetGuard)(values)?.elements.every(d => d.type === 'logical' && d.value === false) ?? false;
@@ -41,49 +44,49 @@ function processWhileLoop(name, args, rootId, data) {
         rootId,
         data,
         markAsNSE: [1],
-        patchData: (d, i) => {
-            if (i === 1) {
-                return { ...d, cds: [...d.cds ?? [], { id: name.info.id, when: true }] };
-            }
-            return d;
-        }, origin: built_in_1.BuiltInProcName.WhileLoop
+        origin: built_in_1.BuiltInProcName.WhileLoop
     });
     const [condition, body] = processedArguments;
     // If the condition is always false, we don't include the body
     if (condition !== undefined && conditionIsAlwaysFalse) {
-        information.graph.addEdge(name.info.id, condition.entryPoint, edge_1.EdgeType.Reads);
+        information.graph.addEdge(nameId, condition.entryPoint, edge_1.EdgeType.Reads);
         return {
             unknownReferences: [],
-            in: [{ nodeId: name.info.id, name: name.lexeme, cds: data.cds, type: identifier_1.ReferenceType.Function }],
+            in: [{ nodeId: nameId, name: name.lexeme, cds: data.cds, type: identifier_1.ReferenceType.Function }],
             out: condition.out,
-            entryPoint: name.info.id,
+            entryPoint: nameId,
             exitPoints: [],
             graph: information.graph,
             environment: information.environment,
             hooks: condition.hooks
         };
     }
+    const conditionIsAlwaysTrue = (0, general_1.valueSetGuard)(values)?.elements.every(d => d.type === 'logical' && d.value === true) ?? false;
     (0, assert_1.guard)(condition !== undefined && body !== undefined, () => `While-Loop ${identifier_1.Identifier.toString(name.content)} has no condition or body, impossible!`);
     const originalDependency = data.cds;
     if ((0, info_1.alwaysExits)(condition)) {
         logger_1.dataflowLogger.warn(`While-Loop ${rootId} forces exit in condition, skipping rest`);
-        information.graph.addEdge(name.info.id, condition.entryPoint, edge_1.EdgeType.Reads);
+        information.graph.addEdge(nameId, condition.entryPoint, edge_1.EdgeType.Reads);
         return condition;
     }
-    const cdTrue = [{ id: name.info.id, when: true }];
-    const remainingInputs = (0, linker_1.linkInputs)((0, reference_to_maybe_1.makeAllMaybe)(body.unknownReferences, information.graph, information.environment, false, cdTrue).concat((0, reference_to_maybe_1.makeAllMaybe)(body.in, information.graph, information.environment, false, cdTrue)), information.environment, condition.in.concat(condition.unknownReferences), information.graph, true);
-    (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph, condition.in)), body.out);
-    (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences));
+    const cdTrue = [{ id: nameId, when: true }];
+    const bodyRead = body.in.concat(body.unknownReferences);
+    (0, reference_to_maybe_1.applyCdsToAllInGraphButConstants)(body.graph, bodyRead, cdTrue);
+    const remainingInputs = (0, linker_1.linkInputs)(bodyRead, information.environment, condition.in.concat(condition.unknownReferences), information.graph, true);
+    (0, reference_to_maybe_1.applyCdToReferences)(body.out, cdTrue);
+    (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph, new Set(condition.in.map(i => i.nodeId)))), body.out);
+    (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences), information.graph);
     // as the while-loop always evaluates its condition
-    information.graph.addEdge(name.info.id, condition.entryPoint, edge_1.EdgeType.Reads);
+    information.graph.addEdge(nameId, condition.entryPoint, edge_1.EdgeType.Reads);
     return {
         unknownReferences: [],
-        in: [{ nodeId: name.info.id, name: name.lexeme, cds: originalDependency, type: identifier_1.ReferenceType.Function }, ...remainingInputs],
-        out: condition.out.concat((0, reference_to_maybe_1.makeAllMaybe)(body.out, information.graph, information.environment, true, cdTrue)),
-        entryPoint: name.info.id,
+        in: [{ nodeId: nameId, name: name.lexeme, cds: originalDependency, type: identifier_1.ReferenceType.Function }, ...remainingInputs],
+        out: condition.out.concat(body.out),
+        entryPoint: nameId,
         exitPoints: (0, info_1.filterOutLoopExitPoints)(body.exitPoints),
         graph: information.graph,
-        environment: information.environment,
+        // as we do not know whether the loop executes at all, we have to merge the environments of the condition and the body, as both may be relevant
+        environment: conditionIsAlwaysTrue ? information.environment : (0, append_1.appendEnvironment)(origEnv, information.environment),
         hooks: condition.hooks.concat(body.hooks)
     };
 }

package/dataflow/internal/process/functions/call/common.d.ts

@@ -40,7 +40,7 @@ export declare function convertFnArguments<OtherInfo>(args: readonly (typeof Emp
  * Transforms a function argument into a function argument reference for a function call vertex.
  * Please be aware, that the ids here are those inferred from the AST, not from the dataflow graph!
  */
-export declare function convertFnArgument<OtherInfo>(arg: typeof EmptyArgument | RNode<OtherInfo & ParentInformation>): FunctionArgument;
+export declare function convertFnArgument<OtherInfo>(this: void, arg: typeof EmptyArgument | RNode<OtherInfo & ParentInformation>): FunctionArgument;
 /**
  * Processes all arguments for a function call, updating the given final graph and environment.
  */

package/dataflow/internal/process/functions/call/common.js

@@ -6,6 +6,7 @@ exports.processAllArguments = processAllArguments;
 exports.patchFunctionCall = patchFunctionCall;
 const info_1 = require("../../../../info");
 const processor_1 = require("../../../../processor");
+const model_1 = require("../../../../../r-bridge/lang-4.x/ast/model/model");
 const r_function_call_1 = require("../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const identifier_1 = require("../../../../environments/identifier");
 const overwrite_1 = require("../../../../environments/overwrite");
@@ -13,33 +14,34 @@ const resolve_by_name_1 = require("../../../../environments/resolve-by-name");
 const type_1 = require("../../../../../r-bridge/lang-4.x/ast/model/type");
 const vertex_1 = require("../../../../graph/vertex");
 const edge_1 = require("../../../../graph/edge");
+const r_argument_1 = require("../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument");
 function forceVertexArgumentValueReferences(rootId, value, graph, env) {
     const valueVertex = graph.getVertex(value.entryPoint);
     if (!valueVertex) {
         return;
     }
     // link read if it is function definition directly and reference the exit point
-    if (valueVertex.tag !== vertex_1.VertexType.Value) {
-        if (valueVertex.tag === vertex_1.VertexType.FunctionDefinition) {
-            for (const exit of valueVertex.exitPoints) {
-                graph.addEdge(rootId, exit.nodeId, edge_1.EdgeType.Reads);
-            }
+    if (valueVertex.tag === vertex_1.VertexType.FunctionDefinition) {
+        for (const exit of valueVertex.exitPoints) {
+            graph.addEdge(rootId, exit.nodeId, edge_1.EdgeType.Reads);
         }
-        else {
-            for (const exit of value.exitPoints) {
-                graph.addEdge(rootId, exit.nodeId, edge_1.EdgeType.Reads);
-            }
+    }
+    else if (valueVertex.tag !== vertex_1.VertexType.Value) {
+        for (const exit of value.exitPoints) {
+            graph.addEdge(rootId, exit.nodeId, edge_1.EdgeType.Reads);
         }
     }
     const containedSubflowIn = graph.verticesOfType(vertex_1.VertexType.FunctionDefinition)
-        .flatMap(([, info]) => info.subflow.in)
-        .toArray();
+        .flatMap(([, info]) => info.subflow.in);
     // try to resolve them against the current environment
-    for (const ref of value.in.concat(containedSubflowIn)) {
-        if (ref.name) {
-            const resolved = ref.name ? (0, resolve_by_name_1.resolveByName)(ref.name, env, ref.type) ?? [] : [];
-            for (const resolve of resolved) {
-                graph.addEdge(ref.nodeId, resolve.nodeId, edge_1.EdgeType.Reads);
+    for (const l of [value.in, containedSubflowIn]) {
+        for (const ref of l) {
+            if (ref.name) {
+                const refId = ref.nodeId;
+                const resolved = (0, resolve_by_name_1.resolveByName)(ref.name, env, ref.type) ?? [];
+                for (const resolve of resolved) {
+                    graph.addEdge(refId, resolve.nodeId, edge_1.EdgeType.Reads);
+                }
             }
         }
     }
@@ -51,7 +53,7 @@ function forceVertexArgumentValueReferences(rootId, value, graph, env) {
  * @see convertFnArgument
  */
 function convertFnArguments(args) {
-    return args.map(arg => convertFnArgument(arg));
+    return args.map(convertFnArgument);
 }
 /**
  * Transforms a function argument into a function argument reference for a function call vertex.
@@ -93,32 +95,38 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
             continue;
         }
         const processed = (0, processor_1.processDataflowFor)(arg, { ...data, environment: argEnv });
-        if (arg.type === type_1.RType.Argument && arg.value && (forceArgs === 'all' || forceArgs[i]) && arg.value.type !== type_1.RType.Number && arg.value.type !== type_1.RType.String && arg.value.type !== type_1.RType.Logical) {
+        if (r_argument_1.RArgument.isWithValue(arg) && (forceArgs === 'all' || forceArgs[i]) && !model_1.RConstant.is(arg.value)) {
             forceVertexArgumentValueReferences(functionRootId, processed, processed.graph, argEnv);
         }
         processedArguments.push(processed);
         finalEnv = (0, overwrite_1.overwriteEnvironment)(finalEnv, processed.environment);
         finalGraph.mergeWith(processed.graph);
         // resolve reads within argument, we resolve before adding the `processed.environment` to avoid cyclic dependencies
-        for (const ingoing of processed.in.concat(processed.unknownReferences)) {
-            // check if it is called directly
-            const vtx = finalGraph.getVertex(ingoing.nodeId);
-            const tryToResolve = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, argEnv, vtx?.tag === vertex_1.VertexType.FunctionCall ? identifier_1.ReferenceType.Function : identifier_1.ReferenceType.Unknown) : undefined;
-            if (tryToResolve === undefined) {
-                remainingReadInArgs.push(ingoing);
-            }
-            else {
-                /* maybe all targets are not definitely of the current scope and should be still kept */
-                let assumeItMayHaveAHigherTarget = true;
-                for (const resolved of tryToResolve) {
-                    if ((0, info_1.happensInEveryBranch)(resolved.cds) && !(0, identifier_1.isReferenceType)(resolved.type, identifier_1.ReferenceType.BuiltInFunction | identifier_1.ReferenceType.BuiltInConstant)) {
-                        assumeItMayHaveAHigherTarget = false;
-                    }
-                    finalGraph.addEdge(ingoing.nodeId, resolved.nodeId, edge_1.EdgeType.Reads);
-                }
-                if (assumeItMayHaveAHigherTarget) {
+        for (const l of [processed.in, processed.unknownReferences]) {
+            for (const ingoing of l) {
+                // check if it is called directly
+                const inId = ingoing.nodeId;
+                const refType = finalGraph.getVertex(inId)?.tag === vertex_1.VertexType.FunctionCall ? identifier_1.ReferenceType.Function : identifier_1.ReferenceType.Unknown;
+                const tryToResolve = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, argEnv, refType) : undefined;
+                if (tryToResolve === undefined) {
                     remainingReadInArgs.push(ingoing);
                 }
+                else {
+                    /* maybe all targets are not definitely of the current scope and should be still kept */
+                    let assumeItMayHaveAHigherTarget = true;
+                    for (const resolved of tryToResolve) {
+                        if ((0, identifier_1.isReferenceType)(resolved.type, identifier_1.ReferenceType.BuiltInFunction | identifier_1.ReferenceType.BuiltInConstant)) {
+                            continue;
+                        }
+                        else if ((0, info_1.happensInEveryBranch)(resolved.cds)) {
+                            assumeItMayHaveAHigherTarget = false;
+                        }
+                        finalGraph.addEdge(inId, resolved.nodeId, edge_1.EdgeType.Reads);
+                    }
+                    if (assumeItMayHaveAHigherTarget) {
+                        remainingReadInArgs.push(ingoing);
+                    }
+                }
             }
         }
         argEnv = (0, overwrite_1.overwriteEnvironment)(argEnv, processed.environment);

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

@@ -9,7 +9,6 @@ const graph_1 = require("../../../../graph/graph");
 const edge_1 = require("../../../../graph/edge");
 const logger_1 = require("../../../../logger");
 const vertex_1 = require("../../../../graph/vertex");
-const log_1 = require("../../../../../util/log");
 const unknown_side_effect_1 = require("../../../../graph/unknown-side-effect");
 const built_in_1 = require("../../../../environments/built-in");
 /**
@@ -36,7 +35,6 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
     const functionName = (0, processor_1.processDataflowFor)(name, data);
     const finalGraph = new graph_1.DataflowGraph(data.completeAst.idMap);
     const functionCallName = name.content;
-    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Processing known function call ${identifier_1.Identifier.toString(functionCallName)} with ${args.length} arguments`);
     const processArgs = reverseOrder ? args.toReversed() : args;
     const { finalEnv, callArgs, remainingReadInArgs, processedArguments } = (0, common_1.processAllArguments)({ functionName, args: processArgs, data, finalGraph, functionRootId: rootId, patchData, forceArgs });
     if (markAsNSE) {

package/dataflow/internal/process/functions/process-argument.d.ts

@@ -1,7 +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 { RNode } from '../../../../r-bridge/lang-4.x/ast/model/model';
+import { RNode } from '../../../../r-bridge/lang-4.x/ast/model/model';
 import type { IdentifierReference } from '../../../environments/identifier';
 import { DataflowGraph } from '../../../graph/graph';
 import type { RArgument } from '../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument';

package/dataflow/internal/process/functions/process-argument.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.linkReadsForArgument = linkReadsForArgument;
 exports.processFunctionArgument = processFunctionArgument;
 const processor_1 = require("../../../processor");
-const collect_1 = require("../../../../r-bridge/lang-4.x/ast/model/collect");
+const model_1 = require("../../../../r-bridge/lang-4.x/ast/model/model");
 const graph_1 = require("../../../graph/graph");
 const type_1 = require("../../../../r-bridge/lang-4.x/ast/model/type");
 const edge_1 = require("../../../graph/edge");
@@ -12,9 +12,9 @@ const vertex_1 = require("../../../graph/vertex");
  * Links all reads that occur before the argument to the argument root node.
  */
 function linkReadsForArgument(root, ingoingRefs, graph) {
-    const allIdsBeforeArguments = new Set((0, collect_1.collectAllIds)(root, n => n.type === type_1.RType.Argument && n.info.id !== root.info.id));
-    const ingoingBeforeArgs = ingoingRefs.filter(r => allIdsBeforeArguments.has(r.nodeId));
     const rid = root.info.id;
+    const allIdsBeforeArguments = new Set(model_1.RNode.collectAllIdsWithStop(root, n => n.type === type_1.RType.Argument && n.info.id !== rid));
+    const ingoingBeforeArgs = ingoingRefs.filter(r => allIdsBeforeArguments.has(r.nodeId));
     for (const ref of ingoingBeforeArgs) {
         // link against the root reference currently I do not know how to deal with nested function calls otherwise
         graph.addEdge(rid, ref.nodeId, edge_1.EdgeType.Reads);

package/dataflow/internal/process/functions/process-parameter.js

@@ -5,8 +5,8 @@ const processor_1 = require("../../../processor");
 const log_1 = require("../../../../util/log");
 const identifier_1 = require("../../../environments/identifier");
 const define_1 = require("../../../environments/define");
-const type_1 = require("../../../../r-bridge/lang-4.x/ast/model/type");
 const edge_1 = require("../../../graph/edge");
+const r_function_definition_1 = require("../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-definition");
 /**
  *
  */
@@ -26,7 +26,7 @@ function processFunctionParameter(parameter, data) {
         graph.setDefinitionOfVertex(writtenNode);
         environment = (0, define_1.define)(writtenNode, false, environment);
         if (defaultValue !== undefined) {
-            if (parameter.defaultValue?.type === type_1.RType.FunctionDefinition) {
+            if (r_function_definition_1.RFunctionDefinition.is(parameter.defaultValue)) {
                 graph.addEdge(wid, parameter.defaultValue.info.id, edge_1.EdgeType.DefinedBy);
             }
             else {

package/dataflow/origin/dfg-get-origin.d.ts

@@ -1,4 +1,4 @@
-import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { DataflowGraph } from '../graph/graph';
 import type { Identifier } from '../environments/identifier';
 export declare const enum OriginType {

package/dataflow/origin/dfg-get-origin.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOriginInDfg = getOriginInDfg;
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const vertex_1 = require("../graph/vertex");
 const edge_1 = require("../graph/edge");
 const linker_1 = require("../internal/linker");
 const assert_1 = require("../../util/assert");
-const built_in_1 = require("../environments/built-in");
 /**
  * Obtain the (dataflow) origin of a given node in the dfg.
  * @example consider the following code:
@@ -95,7 +95,7 @@ function getCallTarget(dfg, call) {
         return origins?.length === 0 ? getVariableUseOrigin(dfg, call) : origins;
     }
     origins = (origins ?? []).concat([...targets].map(target => {
-        if ((0, built_in_1.isBuiltIn)(target)) {
+        if (node_id_1.NodeId.isBuiltIn(target)) {
             return {
                 type: 3 /* OriginType.BuiltInFunctionOrigin */,
                 fn: { name: call.name },

package/documentation/doc-util/doc-types.js

@@ -517,7 +517,7 @@ function printHierarchy({ program, info, root, ignoredTypes, collapseFromNesting
         if (exports.mermaidHide.includes(baseType) || ignoredTypes?.includes(baseType)) {
             continue;
         }
-        const res = printHierarchy({ program, info, root: baseType, collapseFromNesting, initialNesting: initialNesting + 1, maxDepth, skipNesting, showImplSnippet, reverse });
+        const res = printHierarchy({ program, info, root: baseType, ignoredTypes, collapseFromNesting, initialNesting: initialNesting + 1, maxDepth, skipNesting, showImplSnippet, reverse });
         result.push(res);
     }
     const out = result.join('\n');

package/documentation/wiki-absint.js

@@ -17,7 +17,7 @@ class IntervalInferenceVisitor extends absint_visitor_1.AbstractInterpretationVi
     onNumberConstant({ vertex, node }) {
         super.onNumberConstant({ vertex, node });
         const interval = new interval_domain_1.IntervalDomain([node.content.num, node.content.num]);
-        this.currentState.set(node.info.id, interval);
+        this.updateState(node.info.id, interval);
     }
     onFunctionCall({ call }) {
         super.onFunctionCall({ call });
@@ -31,9 +31,9 @@ class IntervalInferenceVisitor extends absint_visitor_1.AbstractInterpretationVi
             // We map the numerical operation to the resulting interval after applying the abstract semantics of the operation
             switch (identifier_1.Identifier.getName(call.name)) {
                 case '+':
-                    return this.currentState.set(call.id, left.add(right));
+                    return this.updateState(call.id, left.add(right));
                 case '-':
-                    return this.currentState.set(call.id, left.subtract(right));
+                    return this.updateState(call.id, left.subtract(right));
             }
         }
     }
@@ -51,8 +51,7 @@ async function inferIntervals() {
     const dfg = (await analyzer.dataflow()).graph;
     const cfg = await analyzer.controlflow(undefined, cfg_kind_1.CfgKind.NoFunctionDefs);
     const ctx = analyzer.inspectContext();
-    const domain = new state_abstract_domain_1.StateAbstractDomain(new Map());
-    const inference = new IntervalInferenceVisitor({ controlFlow: cfg, dfg: dfg, normalizedAst: ast, ctx: ctx, domain: domain });
+    const inference = new IntervalInferenceVisitor({ controlFlow: cfg, dfg: dfg, normalizedAst: ast, ctx: ctx });
     inference.start();
     const result = inference.getEndState();
     return result.value.entries().toArray()
@@ -128,15 +127,15 @@ For example, if we want to perform a (very basic) interval analysis using abstra
 
 ${ctx.code(IntervalInferenceVisitor)}
 
-The interval inference visitor first overrides the ${ctx.link(`${semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor.name}:::onNumberConstant`)} function to infer intervals for visited control flow vertices that represent numeric constants. For numeric constants, the resulting interval consists just of the number value of the constant. We then update the current abstract state of the visitor by setting the inferred abstract value of the currently visited control flow vertex to the new interval.
+The interval inference visitor first overrides the ${ctx.link(`${semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor.name}:::onNumberConstant`)} function to infer intervals for visited control flow vertices that represent numeric constants. For numeric constants, the resulting interval consists just of the number value of the constant. We then update the current abstract state of the visitor via ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'updateState', { hideClass: true })} by setting the inferred abstract value of the currently visited control flow vertex to the new interval.
 
-In this simple example, we only want to support the addition and subtraction of numeric values. Therefore, we override the ${ctx.link(`${absint_visitor_1.AbstractInterpretationVisitor.name}:::onFunctionCall`)} function to apply the abstract semantics of additions and subtraction with resprect to the interval domain. For the addition and subtraction, we are only interested in function calls with exactly two non-empty arguments. We first resolve the currently inferred abstract value for the left and right operand of the function call. If we have no inferred value for one of the operands, this function call might not be a numeric function call and we ignore it. Otherwise, we check whether the function call represents an addition or subtraction and apply the abstract semantics of the operation to the left and right operand. We then again update the current abstract state of the visitor by setting the inferred abstract value of the currently visited function call vertex to the abstract value resulting from applying the abstract semantics of the operation to the operands.
+In this simple example, we only want to support the addition and subtraction of numeric values. Therefore, we override the ${ctx.link(`${absint_visitor_1.AbstractInterpretationVisitor.name}:::onFunctionCall`)} function to apply the abstract semantics of additions and subtraction with resprect to the interval domain. For the addition and subtraction, we are only interested in function calls with exactly two non-empty arguments. We first resolve the currently inferred abstract value for the left and right operand of the function call. If we have no inferred value for one of the operands, this function call might not be a numeric function call and we ignore it. Otherwise, we check whether the function call represents an addition or subtraction and apply the abstract semantics of the operation to the left and right operand. We then again update the current abstract state of the visitor via ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'updateState', { hideClass: true })} by setting the inferred abstract value of the currently visited function call vertex to the abstract value resulting from applying the abstract semantics of the operation to the operands.
 
 If we now want to run the interval inference, we can write the following code:
 
 ${ctx.code(inferIntervals, { dropLinesStart: 1, dropLinesEnd: 5 })}
 
-We first need a ${ctx.linkPage('wiki/Analyzer', 'flowR analyzer')} (in this case, using the ${ctx.linkPage('wiki/Engines', 'tree-sitter engine')}). In this example, we want to analyze a small example code that assigns \`42\` to the variable \`x\`, randomly assigns \`6\` or \`12\` to the variable \`y\`, and assignes the sum of \`x\` and \`y\` to the variable \`z\`. For the abstract interpretation visitor, we need to retrieve the ${ctx.linkPage('wiki/Normalized AST', 'normalized AST')}, ${ctx.linkPage('wiki/Dataflow Graph', 'dataflow graph')}, ${ctx.linkPage('wiki/Control Flow Graph', 'control flow graph')}, and context of the flowR anaylzer. Additionally, we need to provide a state abstract domain for the visitor -- in this case, a state abstract domain for the interval domain. We then construct a new ${ctx.link(IntervalInferenceVisitor)} using the control flow graph, dataflow graph, normalized AST, analyzer context, and state abstract domain, and start the visitor using ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'start', { hideClass: true })}. After the visitor is finished, we retrieve the inferred abstract state at the end of the program using ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getEndState', { hideClass: true })}.
+We first need a ${ctx.linkPage('wiki/Analyzer', 'flowR analyzer')} (in this case, using the ${ctx.linkPage('wiki/Engines', 'tree-sitter engine')}). In this example, we want to analyze a small example code that assigns \`42\` to the variable \`x\`, randomly assigns \`6\` or \`12\` to the variable \`y\`, and assignes the sum of \`x\` and \`y\` to the variable \`z\`. For the abstract interpretation visitor, we need to retrieve the ${ctx.linkPage('wiki/Normalized AST', 'normalized AST')}, ${ctx.linkPage('wiki/Dataflow Graph', 'dataflow graph')}, ${ctx.linkPage('wiki/Control Flow Graph', 'control flow graph')}, and context of the flowR anaylzer. For performance reasons, we construct the control flow graph without simplification passes, data flow information, and function definitions. We then create a new ${ctx.link(IntervalInferenceVisitor)} using the control flow graph, dataflow graph, normalized AST, and analyzer context, and start the visitor using ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'start', { hideClass: true })}. After the visitor is finished, we retrieve the inferred abstract state at the end of the program using ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getEndState', { hideClass: true })}.
 
 If we now print the inferred abstract state at the end of the program, we get the following output: