@eagleoutice/flowr 2.0.25 → 2.1.0

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

@@ -1,19 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.markAsAssignment = exports.processAssignment = void 0;
+exports.processAssignment = processAssignment;
+exports.markAsAssignment = markAsAssignment;
 const known_call_handling_1 = require("../known-call-handling");
 const assert_1 = require("../../../../../../util/assert");
 const log_1 = require("../../../../../../util/log");
 const unpack_argument_1 = require("../argument/unpack-argument");
 const process_named_call_1 = require("../../../process-named-call");
 const make_argument_1 = require("../argument/make-argument");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const logger_1 = require("../../../../../logger");
+const identifier_1 = require("../../../../../environments/identifier");
 const overwrite_1 = require("../../../../../environments/overwrite");
 const retriever_1 = require("../../../../../../r-bridge/retriever");
+const vertex_1 = require("../../../../../graph/vertex");
 const define_1 = require("../../../../../environments/define");
+const edge_1 = require("../../../../../graph/edge");
 function toReplacementSymbol(target, prefix, superAssignment) {
     return {
-        type: "RSymbol" /* RType.Symbol */,
+        type: type_1.RType.Symbol,
         info: target.info,
         /* they are all mapped to `<-` in R, but we mark super as well */
         content: `${prefix}${superAssignment ? '<<-' : '<-'}`,
@@ -27,10 +32,10 @@ function getEffectiveOrder(config, args) {
 }
 function findRootAccess(node) {
     let current = node;
-    while (current.type === "RAccess" /* RType.Access */) {
+    while (current.type === type_1.RType.Access) {
         current = current.accessed;
     }
-    if (current.type === "RSymbol" /* RType.Symbol */) {
+    if (current.type === type_1.RType.Symbol) {
         return current;
     }
     else {
@@ -52,7 +57,7 @@ args, rootId, data, config) {
     const effectiveArgs = getEffectiveOrder(config, args);
     const { target, source } = extractSourceAndTarget(effectiveArgs, name);
     const { type, named } = target;
-    if (type === "RSymbol" /* RType.Symbol */) {
+    if (type === type_1.RType.Symbol) {
         const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, reverseOrder: !config.swapSourceAndTarget, forceArgs: config.forceArgs });
         return processAssignmentToSymbol({
             ...config,
@@ -65,18 +70,18 @@ args, rootId, data, config) {
             information: res.information,
         });
     }
-    else if (config.canBeReplacement && type === "RFunctionCall" /* RType.FunctionCall */ && named) {
+    else if (config.canBeReplacement && type === type_1.RType.FunctionCall && named) {
         /* as replacement functions take precedence over the lhs fn-call (i.e., `names(x) <- ...` is independent from the definition of `names`), we do not have to process the call */
         logger_1.dataflowLogger.debug(`Assignment ${name.content} has a function call as target => replacement function ${target.lexeme}`);
         const replacement = toReplacementSymbol(target, target.functionName.content, config.superAssignment ?? false);
         return (0, process_named_call_1.processAsNamedCall)(replacement, data, replacement.content, [...target.arguments, source]);
     }
-    else if (config.canBeReplacement && type === "RAccess" /* RType.Access */) {
+    else if (config.canBeReplacement && type === type_1.RType.Access) {
         logger_1.dataflowLogger.debug(`Assignment ${name.content} has an access as target => replacement function ${target.lexeme}`);
         const replacement = toReplacementSymbol(target, target.operator, config.superAssignment ?? false);
         return (0, process_named_call_1.processAsNamedCall)(replacement, data, replacement.content, [(0, make_argument_1.toUnnamedArgument)(target.accessed, data.completeAst.idMap), ...target.access, source]);
     }
-    else if (type === "RAccess" /* RType.Access */) {
+    else if (type === type_1.RType.Access) {
         const rootArg = findRootAccess(target);
         if (rootArg) {
             const res = (0, known_call_handling_1.processKnownFunctionCall)({
@@ -99,13 +104,12 @@ args, rootId, data, config) {
             });
         }
     }
-    else if (type === "RString" /* RType.String */) {
+    else if (type === type_1.RType.String) {
         return processAssignmentToString(target, args, name, rootId, data, config, source);
     }
     logger_1.dataflowLogger.warn(`Assignment ${name.content} has an unknown target type ${target.type}, skipping`);
     return (0, known_call_handling_1.processKnownFunctionCall)({ name, args: effectiveArgs, rootId, data, forceArgs: config.forceArgs }).information;
 }
-exports.processAssignment = processAssignment;
 function extractSourceAndTarget(args, name) {
     const source = (0, unpack_argument_1.unpackArgument)(args[1]);
     const target = (0, unpack_argument_1.unpackArgument)(args[0]);
@@ -113,17 +117,17 @@ function extractSourceAndTarget(args, name) {
     (0, assert_1.guard)(target !== undefined, () => `Assignment ${name.content} has no target, impossible!`);
     return { source, target };
 }
-function produceWrittenNodes(rootId, target, isFunctionDef, data, makeMaybe) {
+function produceWrittenNodes(rootId, target, referenceType, data, makeMaybe) {
     return [...target.in, ...target.unknownReferences].map(ref => ({
         ...ref,
-        kind: isFunctionDef ? 'function' : 'variable',
+        type: referenceType,
         definedAt: rootId,
         controlDependencies: data.controlDependencies ?? (makeMaybe ? [] : undefined)
     }));
 }
 function processAssignmentToString(target, args, name, rootId, data, config, source) {
     const symbol = {
-        type: "RSymbol" /* RType.Symbol */,
+        type: type_1.RType.Symbol,
         info: target.info,
         content: (0, retriever_1.removeRQuotes)(target.lexeme),
         lexeme: target.lexeme,
@@ -154,8 +158,17 @@ function processAssignmentToString(target, args, name, rootId, data, config, sou
         information: res.information
     });
 }
-function checkFunctionDef(source, sourceInfo) {
-    return sourceInfo.graph.getVertex(source.info.id)?.tag === "function-definition" /* VertexType.FunctionDefinition */;
+function checkTargetReferenceType(source, sourceInfo) {
+    const vert = sourceInfo.graph.getVertex(source.info.id, true);
+    switch (vert?.tag) {
+        case vertex_1.VertexType.FunctionDefinition:
+            return identifier_1.ReferenceType.Function;
+        case vertex_1.VertexType.Use:
+        case vertex_1.VertexType.FunctionCall:
+            return identifier_1.ReferenceType.Unknown;
+        default:
+            return identifier_1.ReferenceType.Variable;
+    }
 }
 /**
  * Consider a call like `x <- v`
@@ -171,48 +184,49 @@ function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignme
     information.graph.setDefinitionOfVertex(nodeToDefine);
     if (!quoteSource) {
         for (const sourceId of sourceIds) {
-            information.graph.addEdge(nodeToDefine, sourceId, { type: 2 /* EdgeType.DefinedBy */ });
+            information.graph.addEdge(nodeToDefine, sourceId, edge_1.EdgeType.DefinedBy);
         }
     }
-    information.graph.addEdge(nodeToDefine, rootIdOfAssignment, { type: 2 /* EdgeType.DefinedBy */ });
+    information.graph.addEdge(nodeToDefine, rootIdOfAssignment, edge_1.EdgeType.DefinedBy);
     // kinda dirty, but we have to remove existing read edges for the symbol, added by the child
     const out = information.graph.outgoingEdges(nodeToDefine.nodeId);
     for (const [id, edge] of (out ?? [])) {
-        edge.types &= ~1 /* EdgeType.Reads */;
+        edge.types &= ~edge_1.EdgeType.Reads;
         if (edge.types == 0) {
             out?.delete(id);
         }
     }
 }
-exports.markAsAssignment = markAsAssignment;
 /**
  * Helper function whenever it is known that the _target_ of an assignment is a (single) symbol (i.e. `x <- ...`, but not `names(x) <- ...`).
  */
 function processAssignmentToSymbol({ nameOfAssignmentFunction, source, args: [targetArg, sourceArg], target, rootId, data, information, superAssignment, makeMaybe, quoteSource }) {
-    const isFunctionDef = checkFunctionDef(source, sourceArg);
-    const writeNodes = produceWrittenNodes(rootId, targetArg, isFunctionDef, data, makeMaybe ?? false);
+    const referenceType = checkTargetReferenceType(source, sourceArg);
+    const writeNodes = produceWrittenNodes(rootId, targetArg, referenceType, data, makeMaybe ?? false);
     if (writeNodes.length !== 1 && log_1.log.settings.minLevel <= 4 /* LogLevel.Warn */) {
         log_1.log.warn(`Unexpected write number in assignment: ${JSON.stringify(writeNodes)}`);
     }
     // we drop the first arg which we use to pass along arguments :D
     const readFromSourceWritten = sourceArg.out.slice(1);
-    const readTargets = [{ nodeId: rootId, name: nameOfAssignmentFunction, controlDependencies: data.controlDependencies }, ...sourceArg.unknownReferences, ...sourceArg.in, ...targetArg.in.filter(i => i.nodeId !== target.info.id), ...readFromSourceWritten];
-    const writeTargets = [...writeNodes, ...writeNodes, ...readFromSourceWritten];
+    const readTargets = [
+        { nodeId: rootId, name: nameOfAssignmentFunction, controlDependencies: data.controlDependencies, type: identifier_1.ReferenceType.Function },
+        ...sourceArg.unknownReferences, ...sourceArg.in, ...targetArg.in.filter(i => i.nodeId !== target.info.id), ...readFromSourceWritten
+    ];
     information.environment = (0, overwrite_1.overwriteEnvironment)(targetArg.environment, sourceArg.environment);
     // install assigned variables in environment
     for (const write of writeNodes) {
         markAsAssignment(information, write, [source.info.id], rootId, quoteSource, superAssignment);
     }
-    information.graph.addEdge(rootId, targetArg.entryPoint, { type: 8 /* EdgeType.Returns */ });
+    information.graph.addEdge(rootId, targetArg.entryPoint, edge_1.EdgeType.Returns);
     if (quoteSource) {
-        information.graph.addEdge(rootId, source.info.id, { type: 256 /* EdgeType.NonStandardEvaluation */ });
+        information.graph.addEdge(rootId, source.info.id, edge_1.EdgeType.NonStandardEvaluation);
     }
     return {
         ...information,
         unknownReferences: [],
         entryPoint: rootId,
         in: readTargets,
-        out: writeTargets
+        out: [...writeNodes, ...readFromSourceWritten]
     };
 }
 //# sourceMappingURL=built-in-assignment.js.map

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processExpressionList = void 0;
+exports.processExpressionList = processExpressionList;
 const info_1 = require("../../../../../info");
 const processor_1 = require("../../../../../processor");
 const linker_1 = require("../../../../linker");
@@ -9,19 +9,25 @@ const unpack_argument_1 = require("../argument/unpack-argument");
 const common_1 = require("../common");
 const environment_1 = require("../../../../../environments/environment");
 const graph_1 = require("../../../../../graph/graph");
+const identifier_1 = require("../../../../../environments/identifier");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
+const edge_1 = require("../../../../../graph/edge");
+const vertex_1 = require("../../../../../graph/vertex");
 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 dotDotDotAccess = /\.\.\d+/;
+const dotDotDotAccess = /^\.\.\d+$/;
 function linkReadNameToWriteIfPossible(read, environments, listEnvironments, remainingRead, nextGraph) {
     const readName = read.name && dotDotDotAccess.test(read.name) ? '...' : read.name;
-    const probableTarget = readName ? (0, resolve_by_name_1.resolveByName)(readName, environments) : undefined;
+    const probableTarget = readName ? (0, resolve_by_name_1.resolveByName)(readName, environments, read.type) : undefined;
     // record if at least one has not been defined
-    if (probableTarget === undefined || probableTarget.some(t => !listEnvironments.has(t.nodeId))) {
-        if (remainingRead.has(readName)) {
-            remainingRead.get(readName)?.push(read);
+    if (probableTarget === undefined || probableTarget.some(t => !listEnvironments.has(t.nodeId) || !(0, info_1.happensInEveryBranch)(t.controlDependencies))) {
+        const has = remainingRead.get(readName);
+        if (has) {
+            if (!has?.some(h => h.nodeId === read.nodeId && h.name === read.name && h.controlDependencies === read.controlDependencies)) {
+                has.push(read);
+            }
         }
         else {
             remainingRead.set(readName, [read]);
@@ -34,19 +40,20 @@ function linkReadNameToWriteIfPossible(read, environments, listEnvironments, rem
     }
     for (const target of probableTarget) {
         // we can stick with maybe even if readId.attribute is always
-        nextGraph.addEdge(read, target, { type: 1 /* EdgeType.Reads */ });
+        nextGraph.addEdge(read, target, edge_1.EdgeType.Reads);
     }
 }
 function processNextExpression(currentElement, environment, listEnvironments, remainingRead, nextGraph) {
-    // all inputs that have not been written until now, are read!
+    // all inputs that have not been written until now are read!
     for (const read of [...currentElement.in, ...currentElement.unknownReferences]) {
         linkReadNameToWriteIfPossible(read, environment, listEnvironments, remainingRead, nextGraph);
     }
 }
 function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextGraph) {
     for (const { functionCall, called } of calledEnvs) {
+        const callDependencies = nextGraph.getVertex(functionCall, true)?.controlDependencies;
         for (const calledFn of called) {
-            (0, assert_1.guard)(calledFn.tag === 'function-definition', 'called function must call a function definition');
+            (0, assert_1.guard)(calledFn.tag === vertex_1.VertexType.FunctionDefinition, 'called function must call a function definition');
             // only merge the environments they have in common
             let environment = calledFn.environment;
             while (environment.level > inputEnvironment.level) {
@@ -54,26 +61,30 @@ function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextG
             }
             // update alle definitions to be defined at this function call
             let current = environment.current;
-            while (current !== undefined) {
+            let hasUpdate = false;
+            while (current !== undefined && current.id !== environment_1.BuiltInEnvironment.id) {
                 for (const definitions of current.memory.values()) {
                     for (const def of definitions) {
                         if (def.definedAt !== built_in_1.BuiltIn) {
-                            nextGraph.addEdge(def.nodeId, functionCall, { type: 128 /* EdgeType.SideEffectOnCall */ });
+                            hasUpdate = true;
+                            nextGraph.addEdge(def.nodeId, functionCall, edge_1.EdgeType.SideEffectOnCall);
                         }
                     }
                 }
                 current = current.parent;
             }
-            // we update all definitions to be linked with the corresponding function call
-            inputEnvironment = (0, overwrite_1.overwriteEnvironment)(inputEnvironment, environment);
+            if (hasUpdate) {
+                // we update all definitions to be linked with the corresponding function call
+                inputEnvironment = (0, overwrite_1.overwriteEnvironment)(inputEnvironment, environment, callDependencies);
+            }
         }
     }
     return inputEnvironment;
 }
 function processExpressionList(name, args, rootId, data) {
     const expressions = args.map(unpack_argument_1.unpackArgument);
-    logger_1.dataflowLogger.trace(`processing expression list with ${expressions.length} expressions`);
-    let environment = data.environment;
+    logger_1.dataflowLogger.trace(() => `[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();
     const remainingRead = new Map();
@@ -95,7 +106,7 @@ function processExpressionList(name, args, rootId, data) {
         processedExpressions.push(processed);
         nextGraph.mergeWith(processed.graph);
         defaultReturnExpr = processed;
-        // if the expression contained next or break anywhere before the next loop, the overwrite should be an append because we do not know if the rest is executed
+        // if the expression contained next or break anywhere before the next loop, the "overwrite" should be an "append", because we do not know if the rest is executed
         // update the environments for the next iteration with the previous writes
         if (exitPoints.length > 0) {
             processed.out = (0, environment_1.makeAllMaybe)(processed.out, nextGraph, processed.environment, true);
@@ -106,8 +117,8 @@ function processExpressionList(name, args, rootId, data) {
         out.push(...processed.out);
         logger_1.dataflowLogger.trace(`expression ${expressionCounter} of ${expressions.length} has ${processed.unknownReferences.length} unknown nodes`);
         processNextExpression(processed, environment, listEnvironments, remainingRead, nextGraph);
-        const calledEnvs = (0, linker_1.linkFunctionCalls)(nextGraph, data.completeAst.idMap, processed.graph);
         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);
         // if the called function has global redefinitions, we have to keep them within our environment
         environment = updateSideEffectsForCalledFunctions(calledEnvs, environment, nextGraph);
         for (const { nodeId } of processed.out) {
@@ -132,7 +143,7 @@ function processExpressionList(name, args, rootId, data) {
     const rootNode = data.completeAst.idMap.get(rootId);
     const withGroup = rootNode?.grouping;
     if (withGroup) {
-        ingoing.push({ nodeId: rootId, name: name.content, controlDependencies: data.controlDependencies });
+        ingoing.push({ nodeId: rootId, name: name.content, controlDependencies: data.controlDependencies, type: identifier_1.ReferenceType.Function });
         (0, common_1.patchFunctionCall)({
             nextGraph,
             rootId,
@@ -143,7 +154,7 @@ function processExpressionList(name, args, rootId, data) {
         // process all exit points as potential returns:
         for (const exit of exitPoints) {
             if (exit.type === 1 /* ExitPointType.Return */ || exit.type === 0 /* ExitPointType.Default */) {
-                nextGraph.addEdge(rootId, exit.nodeId, { type: 8 /* EdgeType.Returns */ });
+                nextGraph.addEdge(rootId, exit.nodeId, edge_1.EdgeType.Returns);
             }
         }
     }
@@ -161,5 +172,4 @@ function processExpressionList(name, args, rootId, data) {
             : exitPoints
     };
 }
-exports.processExpressionList = processExpressionList;
 //# sourceMappingURL=built-in-expression-list.js.map

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processForLoop = void 0;
+exports.processForLoop = processForLoop;
 const processor_1 = require("../../../../../processor");
 const info_1 = require("../../../../../info");
 const linker_1 = require("../../../../linker");
@@ -13,6 +13,8 @@ const overwrite_1 = require("../../../../../environments/overwrite");
 const define_1 = require("../../../../../environments/define");
 const append_1 = require("../../../../../environments/append");
 const environment_1 = require("../../../../../environments/environment");
+const edge_1 = require("../../../../../graph/edge");
+const identifier_1 = require("../../../../../environments/identifier");
 function processForLoop(name, args, rootId, data) {
     if (args.length !== 3) {
         logger_1.dataflowLogger.warn(`For-Loop ${name.content} does not have three arguments, skipping`);
@@ -33,7 +35,7 @@ function processForLoop(name, args, rootId, data) {
     const headGraph = variable.graph.mergeWith(vector.graph);
     const writtenVariable = [...variable.unknownReferences, ...variable.in];
     for (const write of writtenVariable) {
-        headEnvironments = (0, define_1.define)({ ...write, definedAt: name.info.id, kind: 'variable' }, false, headEnvironments);
+        headEnvironments = (0, define_1.define)({ ...write, definedAt: name.info.id, type: identifier_1.ReferenceType.Variable }, false, headEnvironments);
     }
     data = { ...data, environment: headEnvironments };
     const body = (0, processor_1.processDataflowFor)(bodyArg, data);
@@ -41,9 +43,9 @@ function processForLoop(name, args, rootId, data) {
     const outEnvironment = (0, append_1.appendEnvironment)(headEnvironments, body.environment);
     // now we have to identify all reads that may be effected by a circular redefinition
     // for this, we search for all reads with a non-local read resolve!
-    const nameIdShares = (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(nextGraph));
+    const nameIdShares = (0, linker_1.produceNameSharedIdMap)((0, linker_1.findNonLocalReads)(nextGraph, writtenVariable));
     for (const write of writtenVariable) {
-        nextGraph.addEdge(write.nodeId, vector.entryPoint, { type: 2 /* EdgeType.DefinedBy */ });
+        nextGraph.addEdge(write.nodeId, vector.entryPoint, edge_1.EdgeType.DefinedBy);
         nextGraph.setDefinitionOfVertex(write);
     }
     const outgoing = [...variable.out, ...writtenVariable, ...(0, environment_1.makeAllMaybe)(body.out, nextGraph, outEnvironment, true)];
@@ -56,14 +58,14 @@ function processForLoop(name, args, rootId, data) {
         argumentProcessResult: [variable, vector, body]
     });
     /* mark the last argument as nse */
-    nextGraph.addEdge(rootId, body.entryPoint, { type: 256 /* EdgeType.NonStandardEvaluation */ });
+    nextGraph.addEdge(rootId, body.entryPoint, edge_1.EdgeType.NonStandardEvaluation);
     // as the for-loop always evaluates its variable and condition
-    nextGraph.addEdge(name.info.id, variable.entryPoint, { type: 1 /* EdgeType.Reads */ });
-    nextGraph.addEdge(name.info.id, vector.entryPoint, { type: 1 /* EdgeType.Reads */ });
+    nextGraph.addEdge(name.info.id, variable.entryPoint, edge_1.EdgeType.Reads);
+    nextGraph.addEdge(name.info.id, vector.entryPoint, edge_1.EdgeType.Reads);
     return {
         unknownReferences: [],
         // we only want those not bound by a local variable
-        in: [{ nodeId: rootId, name: name.content, controlDependencies: originalDependency }, ...variable.in, ...vector.in, ...vector.unknownReferences, ...[...nameIdShares.values()].flat()],
+        in: [{ nodeId: rootId, name: name.content, controlDependencies: originalDependency, type: identifier_1.ReferenceType.Function }, ...vector.unknownReferences, ...[...nameIdShares.values()].flat()],
         out: outgoing,
         graph: nextGraph,
         entryPoint: name.info.id,
@@ -71,5 +73,4 @@ function processForLoop(name, args, rootId, data) {
         environment: outEnvironment
     };
 }
-exports.processForLoop = processForLoop;
 //# sourceMappingURL=built-in-for-loop.js.map

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processFunctionDefinition = void 0;
+exports.processFunctionDefinition = processFunctionDefinition;
 const processor_1 = require("../../../../../processor");
 const linker_1 = require("../../../../linker");
 const known_call_handling_1 = require("../known-call-handling");
@@ -10,9 +10,11 @@ const logger_1 = require("../../../../../logger");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const graph_1 = require("../../../../../graph/graph");
 const overwrite_1 = require("../../../../../environments/overwrite");
+const vertex_1 = require("../../../../../graph/vertex");
 const scoping_1 = require("../../../../../environments/scoping");
 const environment_1 = require("../../../../../environments/environment");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
+const edge_1 = require("../../../../../graph/edge");
 const log_1 = require("../../../../../../util/log");
 function processFunctionDefinition(name, args, rootId, data) {
     if (args.length < 1) {
@@ -60,7 +62,7 @@ function processFunctionDefinition(name, args, rootId, data) {
     for (const read of remainingRead) {
         if (read.name) {
             subgraph.addVertex({
-                tag: "use" /* VertexType.Use */,
+                tag: vertex_1.VertexType.Use,
                 id: read.nodeId,
                 environment: undefined,
                 controlDependencies: undefined
@@ -79,7 +81,7 @@ function processFunctionDefinition(name, args, rootId, data) {
     const exitPoints = body.exitPoints;
     const graph = new graph_1.DataflowGraph(data.completeAst.idMap).mergeWith(subgraph, false);
     graph.addVertex({
-        tag: "function-definition" /* VertexType.FunctionDefinition */,
+        tag: vertex_1.VertexType.FunctionDefinition,
         id: name.info.id,
         environment: (0, scoping_1.popLocalEnvironment)(outEnvironment),
         controlDependencies: data.controlDependencies,
@@ -97,25 +99,24 @@ function processFunctionDefinition(name, args, rootId, data) {
         environment: originalEnvironment
     };
 }
-exports.processFunctionDefinition = processFunctionDefinition;
 function updateNestedFunctionClosures(subgraph, outEnvironment, name) {
     // track *all* function definitions - including those nested within the current graph,
     // try to resolve their 'in' by only using the lowest scope which will be popped after this definition
     for (const [id, { subflow, tag }] of subgraph.vertices(true)) {
-        if (tag !== "function-definition" /* VertexType.FunctionDefinition */) {
+        if (tag !== vertex_1.VertexType.FunctionDefinition) {
             continue;
         }
         const ingoingRefs = subflow.in;
         const remainingIn = [];
         for (const ingoing of ingoingRefs) {
-            const resolved = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, outEnvironment) : undefined;
+            const resolved = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, outEnvironment, ingoing.type) : undefined;
             if (resolved === undefined) {
                 remainingIn.push(ingoing);
                 continue;
             }
             (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Found ${resolved.length} references to open ref ${id} in closure of function definition ${name.info.id}`);
             for (const ref of resolved) {
-                subgraph.addEdge(ingoing, ref, { type: 1 /* EdgeType.Reads */ });
+                subgraph.addEdge(ingoing, ref, edge_1.EdgeType.Reads);
             }
         }
         (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Keeping ${remainingIn.length} references to open ref ${id} in closure of function definition ${name.info.id}`);
@@ -142,10 +143,10 @@ function findPromiseLinkagesForParameters(parameters, readInParameters, paramete
     // first, we try to bind again within parameters - if we have it, fine
     const remainingRead = [];
     for (const read of readInParameters) {
-        const resolved = read.name ? (0, resolve_by_name_1.resolveByName)(read.name, parameterEnvs) : undefined;
+        const resolved = read.name ? (0, resolve_by_name_1.resolveByName)(read.name, parameterEnvs, read.type) : undefined;
         if (resolved !== undefined) {
             for (const ref of resolved) {
-                parameters.addEdge(read, ref, { type: 1 /* EdgeType.Reads */ });
+                parameters.addEdge(read, ref, edge_1.EdgeType.Reads);
             }
             continue;
         }
@@ -158,11 +159,11 @@ function findPromiseLinkagesForParameters(parameters, readInParameters, paramete
             continue;
         }
         if (writingOuts[0].controlDependencies === undefined) {
-            parameters.addEdge(read, writingOuts[0], { type: 1 /* EdgeType.Reads */ });
+            parameters.addEdge(read, writingOuts[0], edge_1.EdgeType.Reads);
             continue;
         }
         for (const out of writingOuts) {
-            parameters.addEdge(read, out, { type: 1 /* EdgeType.Reads */ });
+            parameters.addEdge(read, out, edge_1.EdgeType.Reads);
         }
     }
     return remainingRead;

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

@@ -1,23 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processGet = void 0;
+exports.processGet = processGet;
 const known_call_handling_1 = require("../known-call-handling");
 const unpack_argument_1 = require("../argument/unpack-argument");
 const make_argument_1 = require("../argument/make-argument");
 const logger_1 = require("../../../../../logger");
 const retriever_1 = require("../../../../../../r-bridge/retriever");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const edge_1 = require("../../../../../graph/edge");
 function processGet(name, args, rootId, data) {
     if (args.length !== 1) {
         logger_1.dataflowLogger.warn(`symbol access with ${name.content} has not 1 argument, skipping`);
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
     }
     const retrieve = (0, unpack_argument_1.unpackArgument)(args[0]);
-    if (retrieve === undefined || retrieve.type !== "RString" /* RType.String */) {
+    if (retrieve === undefined || retrieve.type !== type_1.RType.String) {
         logger_1.dataflowLogger.warn(`symbol access with ${name.content} has not 1 argument, skipping`);
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
     }
     const treatTargetAsSymbol = {
-        type: "RSymbol" /* RType.Symbol */,
+        type: type_1.RType.Symbol,
         info: retrieve.info,
         content: (0, retriever_1.removeRQuotes)(retrieve.lexeme),
         lexeme: retrieve.lexeme,
@@ -33,9 +35,8 @@ function processGet(name, args, rootId, data) {
     const firstArg = processedArguments[0];
     if (firstArg) {
         // get 'reads' its first argument
-        information.graph.addEdge(rootId, firstArg.entryPoint, { type: 1 /* EdgeType.Reads */ });
+        information.graph.addEdge(rootId, firstArg.entryPoint, edge_1.EdgeType.Reads);
     }
     return information;
 }
-exports.processGet = processGet;
 //# sourceMappingURL=built-in-get.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-if-then-else.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processIfThenElse = void 0;
+exports.processIfThenElse = processIfThenElse;
 const processor_1 = require("../../../../../processor");
 const info_1 = require("../../../../../info");
 const known_call_handling_1 = require("../known-call-handling");
@@ -8,7 +8,9 @@ const common_1 = require("../common");
 const unpack_argument_1 = require("../argument/unpack-argument");
 const logger_1 = require("../../../../../logger");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
+const edge_1 = require("../../../../../graph/edge");
 const append_1 = require("../../../../../environments/append");
+const identifier_1 = require("../../../../../environments/identifier");
 const environment_1 = require("../../../../../environments/environment");
 function processIfThenElse(name, args, rootId, data) {
     if (args.length !== 2 && args.length !== 3) {
@@ -36,7 +38,7 @@ function processIfThenElse(name, args, rootId, data) {
     if (conditionIsFalse !== 0 /* Ternary.Always */) {
         then = (0, processor_1.processDataflowFor)(thenArg, data);
         if (then.entryPoint) {
-            then.graph.addEdge(name.info.id, then.entryPoint, { type: 8 /* EdgeType.Returns */ });
+            then.graph.addEdge(name.info.id, then.entryPoint, edge_1.EdgeType.Returns);
         }
         if (conditionIsTrue !== 0 /* Ternary.Always */) {
             makeThenMaybe = true;
@@ -47,7 +49,7 @@ function processIfThenElse(name, args, rootId, data) {
     if (otherwiseArg !== undefined && conditionIsTrue !== 0 /* Ternary.Always */) {
         otherwise = (0, processor_1.processDataflowFor)(otherwiseArg, data);
         if (otherwise.entryPoint) {
-            otherwise.graph.addEdge(name.info.id, otherwise.entryPoint, { type: 8 /* EdgeType.Returns */ });
+            otherwise.graph.addEdge(name.info.id, otherwise.entryPoint, edge_1.EdgeType.Returns);
         }
         if (conditionIsFalse !== 0 /* Ternary.Always */) {
             makeOtherwiseMaybe = true;
@@ -83,14 +85,14 @@ function processIfThenElse(name, args, rootId, data) {
         argumentProcessResult: [cond, then, otherwise]
     });
     // as an if always evaluates its condition, we add a 'reads'-edge
-    nextGraph.addEdge(name.info.id, cond.entryPoint, { type: 1 /* EdgeType.Reads */ });
+    nextGraph.addEdge(name.info.id, cond.entryPoint, edge_1.EdgeType.Reads);
     const exitPoints = [
         ...(then?.exitPoints ?? []).map(e => ({ ...e, controlDependencies: makeThenMaybe ? [...data.controlDependencies ?? [], { id: rootId, when: true }] : e.controlDependencies })),
         ...(otherwise?.exitPoints ?? []).map(e => ({ ...e, controlDependencies: makeOtherwiseMaybe ? [...data.controlDependencies ?? [], { id: rootId, when: false }] : e.controlDependencies }))
     ];
     return {
         unknownReferences: [],
-        in: [{ nodeId: rootId, name: name.content, controlDependencies: originalDependency }, ...ingoing],
+        in: [{ nodeId: rootId, name: name.content, controlDependencies: originalDependency, type: identifier_1.ReferenceType.Function }, ...ingoing],
         out: outgoing,
         exitPoints,
         entryPoint: rootId,
@@ -98,5 +100,4 @@ function processIfThenElse(name, args, rootId, data) {
         graph: nextGraph
     };
 }
-exports.processIfThenElse = processIfThenElse;
 //# sourceMappingURL=built-in-if-then-else.js.map

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

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processLibrary = void 0;
+exports.processLibrary = processLibrary;
 const known_call_handling_1 = require("../known-call-handling");
 const logger_1 = require("../../../../../logger");
 const unpack_argument_1 = require("../argument/unpack-argument");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const make_argument_1 = require("../argument/make-argument");
 function processLibrary(name, args, rootId, data) {
     /* we do not really know what loading the library does and what side effects it causes, hence we mark it as an unknown side effect */
@@ -12,13 +13,13 @@ function processLibrary(name, args, rootId, data) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, hasUnknownSideEffect: true }).information;
     }
     const nameToLoad = (0, unpack_argument_1.unpackArgument)(args[0]);
-    if (nameToLoad === undefined || nameToLoad.type !== "RSymbol" /* RType.Symbol */) {
+    if (nameToLoad === undefined || nameToLoad.type !== type_1.RType.Symbol) {
         logger_1.dataflowLogger.warn('No library name provided, skipping');
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, hasUnknownSideEffect: true }).information;
     }
     // treat as a function call but convert the first argument to a string
     const newArg = {
-        type: "RString" /* RType.String */,
+        type: type_1.RType.String,
         info: nameToLoad.info,
         lexeme: nameToLoad.lexeme,
         location: nameToLoad.location,
@@ -32,5 +33,4 @@ function processLibrary(name, args, rootId, data) {
         hasUnknownSideEffect: true
     }).information;
 }
-exports.processLibrary = processLibrary;
 //# sourceMappingURL=built-in-library.js.map