@eagleoutice/flowr 2.0.25 → 2.1.0

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

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processPipe = void 0;
+exports.processPipe = processPipe;
 const known_call_handling_1 = require("../known-call-handling");
 const assert_1 = require("../../../../../../util/assert");
 const unpack_argument_1 = require("../argument/unpack-argument");
 const logger_1 = require("../../../../../logger");
+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 identifier_1 = require("../../../../../environments/identifier");
 function processPipe(name, args, rootId, data) {
     const { information } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data });
     if (args.length !== 2) {
@@ -13,23 +17,23 @@ function processPipe(name, args, rootId, data) {
     }
     const [lhs, rhs] = args.map(unpack_argument_1.unpackArgument);
     (0, assert_1.guard)(lhs !== undefined && rhs !== undefined, () => `lhs and rhs must be present, but ${JSON.stringify(lhs)} and ${JSON.stringify(rhs)} were found instead.`);
-    if (rhs.type !== "RFunctionCall" /* RType.FunctionCall */) {
+    if (rhs.type !== type_1.RType.FunctionCall) {
         logger_1.dataflowLogger.warn(`Expected rhs of pipe to be a function call, but got ${rhs.type} instead.`);
     }
     else {
         const functionCallNode = information.graph.getVertex(rhs.info.id, true);
-        (0, assert_1.guard)(functionCallNode?.tag === "function-call" /* VertexType.FunctionCall */, () => `Expected function call node with id ${rhs.info.id} to be a function call node, but got ${functionCallNode?.tag} instead.`);
+        (0, assert_1.guard)(functionCallNode?.tag === vertex_1.VertexType.FunctionCall, () => `Expected function call node with id ${rhs.info.id} to be a function call node, but got ${functionCallNode?.tag} instead.`);
         // make the lhs an argument node:
         const argId = lhs.info.id;
         logger_1.dataflowLogger.trace(`Linking pipe arg ${argId} as first argument of ${rhs.info.id}`);
         functionCallNode.args.unshift({
             name: undefined,
             nodeId: argId,
-            controlDependencies: data.controlDependencies
+            controlDependencies: data.controlDependencies,
+            type: identifier_1.ReferenceType.Function
         });
-        information.graph.addEdge(functionCallNode.id, argId, { type: 64 /* EdgeType.Argument */ });
+        information.graph.addEdge(functionCallNode.id, argId, edge_1.EdgeType.Argument);
     }
     return information;
 }
-exports.processPipe = processPipe;
 //# sourceMappingURL=built-in-pipe.js.map

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

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processQuote = void 0;
+exports.processQuote = processQuote;
 const known_call_handling_1 = require("../known-call-handling");
+const edge_1 = require("../../../../../graph/edge");
 function processQuote(name, args, rootId, data, config) {
     const { information, processedArguments, fnRef } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs });
     const inRefs = [fnRef];
@@ -15,7 +16,11 @@ function processQuote(name, args, rootId, data, config) {
             unknownRefs.push(...processedArg.unknownReferences);
         }
         else if (processedArg) {
-            information.graph.addEdge(rootId, processedArg.entryPoint, { type: 256 /* EdgeType.NonStandardEvaluation */ });
+            information.graph.addEdge(rootId, processedArg.entryPoint, edge_1.EdgeType.NonStandardEvaluation);
+            /* nse actually affects _everything_ within that argument! */
+            for (const [vtx,] of processedArg.graph.vertices(true)) {
+                information.graph.addEdge(rootId, vtx, edge_1.EdgeType.NonStandardEvaluation);
+            }
         }
     }
     return {
@@ -25,5 +30,4 @@ function processQuote(name, args, rootId, data, config) {
         unknownReferences: unknownRefs
     };
 }
-exports.processQuote = processQuote;
 //# sourceMappingURL=built-in-quote.js.map

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processRepeatLoop = void 0;
+exports.processRepeatLoop = processRepeatLoop;
 const info_1 = require("../../../../../info");
 const linker_1 = require("../../../../linker");
 const known_call_handling_1 = require("../known-call-handling");
@@ -29,9 +29,8 @@ function processRepeatLoop(name, args, rootId, data) {
     });
     const body = processedArguments[0];
     (0, assert_1.guard)(body !== undefined, () => `Repeat-Loop ${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.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph, [])), body.out);
     information.exitPoints = (0, info_1.filterOutLoopExitPoints)(information.exitPoints);
     return information;
 }
-exports.processRepeatLoop = processRepeatLoop;
 //# sourceMappingURL=built-in-repeat-loop.js.map

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processReplacementFunction = void 0;
+exports.processReplacementFunction = processReplacementFunction;
 const info_1 = require("../../../../../info");
 const known_call_handling_1 = require("../known-call-handling");
 const log_1 = require("../../../../../../util/log");
@@ -8,7 +8,9 @@ const built_in_assignment_1 = require("./built-in-assignment");
 const common_1 = require("../common");
 const assert_1 = require("../../../../../../util/assert");
 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");
 function processReplacementFunction(name, 
 /** The last one has to be the value */
@@ -31,16 +33,15 @@ args, rootId, data, config) {
         forceArgs: config.forceArgs,
     });
     const fn = res.graph.getVertex(rootId, true);
-    (0, assert_1.guard)(fn?.tag === "function-call" /* 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)}`);
+    (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]];
     /* 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);
         if (ref !== undefined) {
-            res.graph.addEdge(rootId, ref, { type: 1 /* EdgeType.Reads */ });
+            res.graph.addEdge(rootId, ref, edge_1.EdgeType.Reads);
         }
     }
     return res;
 }
-exports.processReplacementFunction = processReplacementFunction;
 //# sourceMappingURL=built-in-replacement.js.map

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.standaloneSourceFile = exports.sourceRequest = exports.processSourceCall = exports.setSourceProvider = void 0;
+exports.setSourceProvider = setSourceProvider;
+exports.processSourceCall = processSourceCall;
+exports.sourceRequest = sourceRequest;
+exports.standaloneSourceFile = standaloneSourceFile;
 const shell_executor_1 = require("../../../../../../r-bridge/shell-executor");
 const processor_1 = require("../../../../../processor");
 const info_1 = require("../../../../../info");
@@ -11,13 +14,13 @@ 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 type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const overwrite_1 = require("../../../../../environments/overwrite");
 const log_1 = require("../../../../../../util/log");
 let sourceProvider = (0, retriever_1.requestProviderFromFile)();
 function setSourceProvider(provider) {
     sourceProvider = provider;
 }
-exports.setSourceProvider = setSourceProvider;
 function processSourceCall(name, args, rootId, data, config) {
     const information = config.includeFunctionCall ?
         (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information
@@ -28,7 +31,7 @@ function processSourceCall(name, args, rootId, data, config) {
         information.graph.markIdForUnknownSideEffects(rootId);
         return information;
     }
-    if (sourceFile !== r_function_call_1.EmptyArgument && sourceFile?.value?.type === "RString" /* RType.String */) {
+    if (sourceFile !== r_function_call_1.EmptyArgument && sourceFile?.value?.type === type_1.RType.String) {
         const path = (0, retriever_1.removeRQuotes)(sourceFile.lexeme);
         const request = sourceProvider.createRequest(path);
         // check if the sourced file has already been dataflow analyzed, and if so, skip it
@@ -45,7 +48,6 @@ function processSourceCall(name, args, rootId, data, config) {
         return information;
     }
 }
-exports.processSourceCall = processSourceCall;
 function sourceRequest(rootId, request, data, information, getId) {
     const executor = new shell_executor_1.RShellExecutor();
     // parse, normalize and dataflow the sourced file
@@ -81,7 +83,6 @@ function sourceRequest(rootId, request, data, information, getId) {
     }
     return newInformation;
 }
-exports.sourceRequest = sourceRequest;
 function standaloneSourceFile(inputRequest, data, uniqueSourceId, information) {
     const path = inputRequest.request === 'file' ? inputRequest.content : '-inline-';
     /* this way we can still pass content */
@@ -100,5 +101,4 @@ function standaloneSourceFile(inputRequest, data, uniqueSourceId, information) {
         referenceChain: [...data.referenceChain, fingerprint]
     }, information, (0, decorate_1.deterministicPrefixIdGenerator)(path + '@' + uniqueSourceId));
 }
-exports.standaloneSourceFile = standaloneSourceFile;
 //# sourceMappingURL=built-in-source.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-special-bin-op.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processSpecialBinOp = void 0;
+exports.processSpecialBinOp = processSpecialBinOp;
 const known_call_handling_1 = require("../known-call-handling");
 const logger_1 = require("../../../../../logger");
+const edge_1 = require("../../../../../graph/edge");
 function processSpecialBinOp(name, args, rootId, data, config) {
     if (!config.lazy) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
@@ -21,7 +22,7 @@ function processSpecialBinOp(name, args, rootId, data, config) {
     });
     for (const arg of processedArguments) {
         if (arg) {
-            information.graph.addEdge(name.info.id, arg.entryPoint, { type: 1 /* EdgeType.Reads */ });
+            information.graph.addEdge(name.info.id, arg.entryPoint, edge_1.EdgeType.Reads);
         }
         // only do first if lazy
         if (config.lazy) {
@@ -30,5 +31,4 @@ function processSpecialBinOp(name, args, rootId, data, config) {
     }
     return information;
 }
-exports.processSpecialBinOp = processSpecialBinOp;
 //# sourceMappingURL=built-in-special-bin-op.js.map

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processWhileLoop = void 0;
+exports.processWhileLoop = processWhileLoop;
 const info_1 = require("../../../../../info");
 const linker_1 = require("../../../../linker");
 const known_call_handling_1 = require("../known-call-handling");
@@ -9,6 +9,8 @@ const unpack_argument_1 = require("../argument/unpack-argument");
 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 edge_1 = require("../../../../../graph/edge");
+const identifier_1 = require("../../../../../environments/identifier");
 function processWhileLoop(name, args, rootId, data) {
     if (args.length !== 2 || args[1] === r_function_call_1.EmptyArgument) {
         logger_1.dataflowLogger.warn(`While-Loop ${name.content} does not have 2 arguments, skipping`);
@@ -44,12 +46,12 @@ function processWhileLoop(name, args, rootId, data) {
         ...(0, environment_1.makeAllMaybe)(body.unknownReferences, information.graph, information.environment, false),
         ...(0, environment_1.makeAllMaybe)(body.in, information.graph, information.environment, false)
     ], information.environment, [...condition.in, ...condition.unknownReferences], information.graph, true);
-    (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph)), body.out);
+    (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(information.graph, condition.in)), body.out);
     // as the while-loop always evaluates its condition
-    information.graph.addEdge(name.info.id, condition.entryPoint, { type: 1 /* EdgeType.Reads */ });
+    information.graph.addEdge(name.info.id, condition.entryPoint, edge_1.EdgeType.Reads);
     return {
         unknownReferences: [],
-        in: [{ nodeId: name.info.id, name: name.lexeme, controlDependencies: originalDependency }, ...remainingInputs],
+        in: [{ nodeId: name.info.id, name: name.lexeme, controlDependencies: originalDependency, type: identifier_1.ReferenceType.Function }, ...remainingInputs],
         out: [...(0, environment_1.makeAllMaybe)(body.out, information.graph, information.environment, true), ...condition.out],
         entryPoint: name.info.id,
         exitPoints: (0, info_1.filterOutLoopExitPoints)(body.exitPoints),
@@ -57,5 +59,4 @@ function processWhileLoop(name, args, rootId, data) {
         environment: information.environment
     };
 }
-exports.processWhileLoop = processWhileLoop;
 //# sourceMappingURL=built-in-while-loop.js.map

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

@@ -1,26 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.patchFunctionCall = exports.processAllArguments = void 0;
+exports.processAllArguments = processAllArguments;
+exports.patchFunctionCall = patchFunctionCall;
+const info_1 = require("../../../../info");
 const processor_1 = require("../../../../processor");
 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");
 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");
 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 !== "value" /* VertexType.Value */) {
-        if (valueVertex.tag === "function-definition" /* VertexType.FunctionDefinition */) {
+    if (valueVertex.tag !== vertex_1.VertexType.Value) {
+        if (valueVertex.tag === vertex_1.VertexType.FunctionDefinition) {
             for (const exit of valueVertex.exitPoints) {
-                graph.addEdge(rootId, exit, { type: 1 /* EdgeType.Reads */ });
+                graph.addEdge(rootId, exit, edge_1.EdgeType.Reads);
             }
         }
         else {
             for (const exit of value.exitPoints) {
-                graph.addEdge(rootId, exit.nodeId, { type: 1 /* EdgeType.Reads */ });
+                graph.addEdge(rootId, exit.nodeId, edge_1.EdgeType.Reads);
             }
         }
     }
@@ -30,9 +35,9 @@ function forceVertexArgumentValueReferences(rootId, value, graph, env) {
     // try to resolve them against the current environment
     for (const ref of [...value.in, ...containedSubflowIn.flatMap(n => n.subflow.in)]) {
         if (ref.name) {
-            const resolved = (0, resolve_by_name_1.resolveByName)(ref.name, env) ?? [];
+            const resolved = (0, resolve_by_name_1.resolveByName)(ref.name, env, ref.type) ?? [];
             for (const resolve of resolved) {
-                graph.addEdge(ref.nodeId, resolve.nodeId, { type: 1 /* EdgeType.Reads */ });
+                graph.addEdge(ref.nodeId, resolve.nodeId, edge_1.EdgeType.Reads);
             }
         }
     }
@@ -54,52 +59,58 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
             continue;
         }
         const processed = (0, processor_1.processDataflowFor)(arg, { ...data, environment: argEnv });
-        if (arg.type === "RArgument" /* RType.Argument */ && arg.value && (forceArgs === 'all' || forceArgs[i]) && arg.value.type !== "RNumber" /* RType.Number */ && arg.value.type !== "RString" /* RType.String */ && arg.value.type !== "RLogical" /* RType.Logical */) {
+        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) {
             forceVertexArgumentValueReferences(functionRootId, processed, processed.graph, argEnv);
         }
         processedArguments.push(processed);
         finalEnv = (0, overwrite_1.overwriteEnvironment)(finalEnv, processed.environment);
         // resolve reads within argument, we resolve before adding the `processed.environment` to avoid cyclic dependencies
         for (const ingoing of [...processed.in, ...processed.unknownReferences]) {
-            const tryToResolve = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, argEnv) : undefined;
+            const tryToResolve = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, argEnv, 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) {
-                    finalGraph.addEdge(ingoing.nodeId, resolved.nodeId, { type: 1 /* EdgeType.Reads */ });
+                    if ((0, info_1.happensInEveryBranch)(resolved.controlDependencies)) {
+                        assumeItMayHaveAHigherTarget = false;
+                    }
+                    finalGraph.addEdge(ingoing.nodeId, resolved.nodeId, edge_1.EdgeType.Reads);
+                }
+                if (assumeItMayHaveAHigherTarget) {
+                    remainingReadInArgs.push(ingoing);
                 }
             }
         }
         argEnv = (0, overwrite_1.overwriteEnvironment)(argEnv, processed.environment);
         finalGraph.mergeWith(processed.graph);
-        if (arg.type !== "RArgument" /* RType.Argument */ || !arg.name) {
-            callArgs.push({ nodeId: processed.entryPoint, controlDependencies: undefined });
+        if (arg.type !== type_1.RType.Argument || !arg.name) {
+            callArgs.push({ nodeId: processed.entryPoint, controlDependencies: undefined, type: identifier_1.ReferenceType.Argument });
         }
         else {
-            callArgs.push({ nodeId: processed.entryPoint, name: arg.name.content, controlDependencies: undefined });
+            callArgs.push({ nodeId: processed.entryPoint, name: arg.name.content, controlDependencies: undefined, type: identifier_1.ReferenceType.Argument });
         }
-        finalGraph.addEdge(functionRootId, processed.entryPoint, { type: 64 /* EdgeType.Argument */ });
+        finalGraph.addEdge(functionRootId, processed.entryPoint, edge_1.EdgeType.Argument);
     }
     return { finalEnv, callArgs, remainingReadInArgs, processedArguments };
 }
-exports.processAllArguments = processAllArguments;
 function patchFunctionCall({ nextGraph, rootId, name, data, argumentProcessResult }) {
     nextGraph.addVertex({
-        tag: "function-call" /* VertexType.FunctionCall */,
+        tag: vertex_1.VertexType.FunctionCall,
         id: rootId,
         name: name.content,
         environment: data.environment,
         /* will be overwritten accordingly */
         onlyBuiltin: false,
         controlDependencies: data.controlDependencies,
-        args: argumentProcessResult.map(arg => arg === undefined ? r_function_call_1.EmptyArgument : { nodeId: arg.entryPoint, controlDependencies: undefined, call: undefined })
+        args: argumentProcessResult.map(arg => arg === undefined ? r_function_call_1.EmptyArgument : { nodeId: arg.entryPoint, controlDependencies: undefined, call: undefined, type: identifier_1.ReferenceType.Argument }),
     });
     for (const arg of argumentProcessResult) {
         if (arg) {
-            nextGraph.addEdge(rootId, arg.entryPoint, { type: 64 /* EdgeType.Argument */ });
+            nextGraph.addEdge(rootId, arg.entryPoint, edge_1.EdgeType.Argument);
         }
     }
 }
-exports.patchFunctionCall = patchFunctionCall;
 //# sourceMappingURL=common.js.map

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processFunctionCall = void 0;
+exports.processFunctionCall = processFunctionCall;
 const named_call_handling_1 = require("./named-call-handling");
 const unnamed_call_handling_1 = require("./unnamed-call-handling");
 function processFunctionCall(functionCall, data) {
@@ -11,5 +11,4 @@ function processFunctionCall(functionCall, data) {
         return (0, unnamed_call_handling_1.processUnnamedFunctionCall)(functionCall, data);
     }
 }
-exports.processFunctionCall = processFunctionCall;
 //# sourceMappingURL=default-call-handling.js.map

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

@@ -1,17 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processKnownFunctionCall = exports.markNonStandardEvaluationEdges = void 0;
+exports.markNonStandardEvaluationEdges = markNonStandardEvaluationEdges;
+exports.processKnownFunctionCall = processKnownFunctionCall;
 const processor_1 = require("../../../../processor");
 const common_1 = require("./common");
+const identifier_1 = require("../../../../environments/identifier");
 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");
 function markNonStandardEvaluationEdges(markAsNSE, callArgs, finalGraph, rootId) {
     for (const nse of markAsNSE) {
         if (nse < callArgs.length) {
             const arg = callArgs[nse];
             if (arg !== undefined) {
-                finalGraph.addEdge(rootId, arg.entryPoint, { type: 256 /* EdgeType.NonStandardEvaluation */ });
+                finalGraph.addEdge(rootId, arg.entryPoint, edge_1.EdgeType.NonStandardEvaluation);
             }
         }
         else {
@@ -19,7 +23,6 @@ function markNonStandardEvaluationEdges(markAsNSE, callArgs, finalGraph, rootId)
         }
     }
 }
-exports.markNonStandardEvaluationEdges = markNonStandardEvaluationEdges;
 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);
@@ -31,7 +34,7 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
         markNonStandardEvaluationEdges(markAsNSE, processedArguments, finalGraph, rootId);
     }
     finalGraph.addVertex({
-        tag: "function-call" /* VertexType.FunctionCall */,
+        tag: vertex_1.VertexType.FunctionCall,
         id: rootId,
         environment: data.environment,
         name: functionCallName,
@@ -44,7 +47,7 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
         finalGraph.markIdForUnknownSideEffects(rootId);
     }
     const inIds = remainingReadInArgs;
-    const fnRef = { nodeId: rootId, name: functionCallName, controlDependencies: data.controlDependencies, call: true };
+    const fnRef = { nodeId: rootId, name: functionCallName, controlDependencies: data.controlDependencies, type: identifier_1.ReferenceType.Function };
     inIds.push(fnRef);
     return {
         information: {
@@ -61,5 +64,4 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
         fnRef
     };
 }
-exports.processKnownFunctionCall = processKnownFunctionCall;
 //# sourceMappingURL=known-call-handling.js.map

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

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processNamedCall = void 0;
+exports.processNamedCall = processNamedCall;
 const info_1 = require("../../../../info");
 const known_call_handling_1 = require("./known-call-handling");
 const append_1 = require("../../../../environments/append");
 const resolve_by_name_1 = require("../../../../environments/resolve-by-name");
+const vertex_1 = require("../../../../graph/vertex");
+const identifier_1 = require("../../../../environments/identifier");
 function mergeInformation(info, newInfo) {
     if (info === undefined) {
         return newInfo;
@@ -20,18 +22,18 @@ function mergeInformation(info, newInfo) {
     };
 }
 function processDefaultFunctionProcessor(information, name, args, rootId, data) {
-    const resolve = (0, resolve_by_name_1.resolveByName)(name.content, data.environment);
+    const resolve = (0, resolve_by_name_1.resolveByName)(name.content, data.environment, identifier_1.ReferenceType.Function);
     /* if we do not know where we land, we force! */
     const call = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: (resolve?.length ?? 0) > 0 ? undefined : 'all' });
     return mergeInformation(information, call.information);
 }
 function processNamedCall(name, args, rootId, data) {
-    const resolved = (0, resolve_by_name_1.resolveByName)(name.content, data.environment) ?? [];
+    const resolved = (0, resolve_by_name_1.resolveByName)(name.content, data.environment, identifier_1.ReferenceType.Function) ?? [];
     let defaultProcessor = resolved.length === 0;
     let information = undefined;
     let builtIn = false;
     for (const resolvedFunction of resolved) {
-        if (resolvedFunction.kind === 'built-in-function') {
+        if (resolvedFunction.type === identifier_1.ReferenceType.BuiltInFunction) {
             builtIn = true;
             information = mergeInformation(information, resolvedFunction.processor(name, args, rootId, data));
         }
@@ -45,12 +47,11 @@ function processNamedCall(name, args, rootId, data) {
     else if (information && builtIn) {
         // mark the function call as built in only
         const v = information.graph.getVertex(rootId);
-        if (v?.tag === "function-call" /* VertexType.FunctionCall */) {
+        if (v?.tag === vertex_1.VertexType.FunctionCall) {
             v.onlyBuiltin = true;
             v.environment = undefined;
         }
     }
     return information ?? (0, info_1.initializeCleanDataflowInformation)(rootId, data);
 }
-exports.processNamedCall = processNamedCall;
 //# sourceMappingURL=named-call-handling.js.map

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

@@ -1,11 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processUnnamedFunctionCall = exports.UnnamedFunctionCallPrefix = void 0;
+exports.UnnamedFunctionCallPrefix = void 0;
+exports.processUnnamedFunctionCall = processUnnamedFunctionCall;
 const processor_1 = require("../../../../processor");
 const common_1 = require("./common");
 const linker_1 = require("../../../linker");
+const edge_1 = require("../../../../graph/edge");
 const graph_1 = require("../../../../graph/graph");
+const vertex_1 = require("../../../../graph/vertex");
+const type_1 = require("../../../../../r-bridge/lang-4.x/ast/model/type");
 const logger_1 = require("../../../../logger");
+const identifier_1 = require("../../../../environments/identifier");
 exports.UnnamedFunctionCallPrefix = 'unnamed-function-call-';
 function processUnnamedFunctionCall(functionCall, data) {
     const calledFunction = (0, processor_1.processDataflowFor)(functionCall.calledFunction, data);
@@ -15,8 +20,8 @@ function processUnnamedFunctionCall(functionCall, data) {
     const functionCallName = `${exports.UnnamedFunctionCallPrefix}${functionRootId}`;
     logger_1.dataflowLogger.debug(`Using ${functionRootId} as root for the unnamed function call`);
     // we know that it calls the toplevel:
-    finalGraph.addEdge(functionRootId, calledRootId, { type: 4 /* EdgeType.Calls */ });
-    finalGraph.addEdge(functionRootId, calledRootId, { type: 1 /* EdgeType.Reads */ });
+    finalGraph.addEdge(functionRootId, calledRootId, edge_1.EdgeType.Calls);
+    finalGraph.addEdge(functionRootId, calledRootId, edge_1.EdgeType.Reads);
     // keep the defined function
     finalGraph.mergeWith(calledFunction.graph);
     const { finalEnv, callArgs, remainingReadInArgs } = (0, common_1.processAllArguments)({
@@ -28,7 +33,7 @@ function processUnnamedFunctionCall(functionCall, data) {
         /* we know the call is right there and fully resolved, there is no need to artificially force arguments as we identify them within the subtree */
     });
     finalGraph.addVertex({
-        tag: "function-call" /* VertexType.FunctionCall */,
+        tag: vertex_1.VertexType.FunctionCall,
         id: functionRootId,
         environment: data.environment,
         name: functionCallName,
@@ -38,8 +43,8 @@ function processUnnamedFunctionCall(functionCall, data) {
         args: callArgs // same reference
     });
     const inIds = remainingReadInArgs;
-    inIds.push({ nodeId: functionRootId, name: functionCallName, controlDependencies: data.controlDependencies });
-    if (functionCall.calledFunction.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
+    inIds.push({ nodeId: functionRootId, name: functionCallName, controlDependencies: data.controlDependencies, type: identifier_1.ReferenceType.Function });
+    if (functionCall.calledFunction.type === type_1.RType.FunctionDefinition) {
         (0, linker_1.linkArgumentsOnCall)(callArgs, functionCall.calledFunction.parameters, finalGraph);
     }
     // push the called function to the ids:
@@ -55,5 +60,4 @@ function processUnnamedFunctionCall(functionCall, data) {
         exitPoints: calledFunction.exitPoints
     };
 }
-exports.processUnnamedFunctionCall = processUnnamedFunctionCall;
 //# sourceMappingURL=unnamed-call-handling.js.map

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

@@ -1,18 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processFunctionArgument = exports.linkReadsForArgument = void 0;
+exports.linkReadsForArgument = linkReadsForArgument;
+exports.processFunctionArgument = processFunctionArgument;
 const processor_1 = require("../../../processor");
 const collect_1 = require("../../../../r-bridge/lang-4.x/ast/model/collect");
 const graph_1 = require("../../../graph/graph");
+const type_1 = require("../../../../r-bridge/lang-4.x/ast/model/type");
+const edge_1 = require("../../../graph/edge");
+const vertex_1 = require("../../../graph/vertex");
 function linkReadsForArgument(root, ingoingRefs, graph) {
-    const allIdsBeforeArguments = new Set((0, collect_1.collectAllIds)(root, n => n.type === "RArgument" /* RType.Argument */ && n.info.id !== root.info.id));
+    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));
     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(root.info.id, ref, { type: 1 /* EdgeType.Reads */ });
+        graph.addEdge(root.info.id, ref, edge_1.EdgeType.Reads);
     }
 }
-exports.linkReadsForArgument = linkReadsForArgument;
 function processFunctionArgument(argument, data) {
     const name = argument.name === undefined ? undefined : (0, processor_1.processDataflowFor)(argument.name, data);
     const value = argument.value === undefined ? undefined : (0, processor_1.processDataflowFor)(argument.value, data);
@@ -22,15 +25,15 @@ function processFunctionArgument(argument, data) {
     let entryPoint = value?.entryPoint;
     if (argumentName) {
         graph.addVertex({
-            tag: "use" /* VertexType.Use */,
+            tag: vertex_1.VertexType.Use,
             id: argument.info.id,
             controlDependencies: data.controlDependencies
         });
         entryPoint = argument.info.id;
     }
     const ingoingRefs = [...value?.unknownReferences ?? [], ...value?.in ?? [], ...(name === undefined ? [] : [...name.in])];
-    if (entryPoint && argument.value?.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
-        graph.addEdge(entryPoint, argument.value.info.id, { type: 1 /* EdgeType.Reads */ });
+    if (entryPoint && argument.value?.type === type_1.RType.FunctionDefinition) {
+        graph.addEdge(entryPoint, argument.value.info.id, edge_1.EdgeType.Reads);
     }
     else if (argumentName) {
         // we only need to link against those which are not already bound to another function call argument
@@ -47,5 +50,4 @@ function processFunctionArgument(argument, data) {
         exitPoints: value?.exitPoints ?? name?.exitPoints ?? [{ nodeId: argument.info.id, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }]
     };
 }
-exports.processFunctionArgument = processFunctionArgument;
 //# sourceMappingURL=process-argument.js.map