[Dataflow] Big improve for linked fns resolve (#2278)

EagleoutIce · web-flow · commit 1d91b9574307 · 2026-01-29T10:01:29.000+01:00
* dep: fix sec-vuln

* feat: return track for fdef resolve

also perf+ for `addEdge`

* test: improve explicit tests for call retrieval
diff --git a/package-lock.json b/package-lock.json
diff --git a/src/dataflow/graph/graph.ts b/src/dataflow/graph/graph.ts
@@ -326,15 +326,7 @@ export class DataflowGraph<
 		return this;
 	}
 
-	/** {@inheritDoc} */
-	public addEdge(from: NodeId, to: NodeId, type: EdgeType | number): this
-	/** {@inheritDoc} */
-	public addEdge(from: { nodeId: NodeId }, to: { nodeId: NodeId }, type: EdgeType | number): this
-	/** {@inheritDoc} */
-	public addEdge(from: NodeId | { nodeId: NodeId }, to: NodeId | { nodeId: NodeId }, type: EdgeType | number): this
-	public addEdge(from: NodeId | { nodeId: NodeId }, to: NodeId | { nodeId: NodeId }, type: EdgeType | number): this {
-		const [fromId, toId] = extractEdgeIds(from, to);
-
+	public addEdge(fromId: NodeId, toId: NodeId, type: EdgeType | number): this {
 		if(fromId === toId) {
 			return this;
 		}
@@ -512,15 +504,6 @@ function mergeNodeInfos<Vertex extends DataflowGraphVertexInfo>(current: Vertex,
 	return current;
 }
 
-/**
- * Returns the ids of the dataflow vertices referenced.
- */
-function extractEdgeIds(from: NodeId | { nodeId: NodeId }, to: NodeId | { nodeId: NodeId }): [fromId: NodeId, toId: NodeId] {
-	const fromId = typeof from === 'object' ? from.nodeId : from;
-	const toId = typeof to === 'object' ? to.nodeId : to;
-	return [fromId, toId];
-}
-
 export interface IEnvironmentJson {
     readonly id: number;
     parent:      IEnvironmentJson;
diff --git a/src/dataflow/internal/linker.ts b/src/dataflow/internal/linker.ts
@@ -254,10 +254,10 @@ export function linkFunctionCallWithSingleTarget(
 			if(defs === undefined) {
 				continue;
 			}
-			for(const def of defs) {
-				if(!isBuiltIn(def.nodeId)) {
-					graph.addEdge(ingoing, def, EdgeType.DefinedByOnCall);
-					graph.addEdge(id, def, EdgeType.DefinesOnCall);
+			for(const { nodeId } of defs) {
+				if(!isBuiltIn(nodeId)) {
+					graph.addEdge(ingoing.nodeId, nodeId, EdgeType.DefinedByOnCall);
+					graph.addEdge(id, nodeId, EdgeType.DefinesOnCall);
 				}
 			}
 		}
@@ -319,6 +319,7 @@ function linkFunctionCall(
 	}
 
 	const [functionDefs] = getAllLinkedFunctionDefinitions(new Set(functionDefinitionReadIds), graph);
+
 	const propagateExitPoints: ExitPoint[] = [];
 	for(const def of functionDefs.values()) {
 		// we can skip this if we already linked it
@@ -395,6 +396,18 @@ const LinkedFnFollowBits = EdgeType.Reads | EdgeType.DefinedBy | EdgeType.Define
 
 /**
  * Finds all linked function definitions starting from the given set of read ids.
+ * This is a complicated function, please only call it if you know what you are doing.
+ * For example, if you are interested in the called functions of a function call, use {@link getAllFunctionCallTargets} instead.
+ * This function here expects you to handle the accessed objects yourself (e.g,. already resolve the first layer of reads/returns/calls/... or resolve the identifier by name)
+ * and then pass in the relevant read ids.
+ * @example
+ * Consider a scenario like this:
+ * ```R
+ * x <- function() 3
+ * x()
+ * ```
+ * To resolve the call `x` in the second line, use {@link getAllFunctionCallTargets}!
+ * To know what fdefs the definition of `x` in the first line links to, you can use {@link getAllLinkedFunctionDefinitions|this function}.
  */
 export function getAllLinkedFunctionDefinitions(
 	functionDefinitionReadIds: ReadonlySet<NodeId>,
@@ -411,15 +424,16 @@ export function getAllLinkedFunctionDefinitions(
 	const visited = new Set<NodeId>();
 
 	while(potential.length !== 0) {
-		const currentId = potential.pop() as NodeId;
-		visited.add(currentId);
+		const cid = potential.pop() as NodeId;
+		// console.log(`visiting ${recoverName(cid, dataflowGraph.idMap)} ${cid}`);
+		visited.add(cid);
 
-		if(isBuiltIn(currentId)) {
-			builtIns.add(currentId);
+		if(isBuiltIn(cid)) {
+			builtIns.add(cid);
 			continue;
 		}
 
-		const currentInfo = dataflowGraph.get(currentId, true);
+		const currentInfo = dataflowGraph.get(cid, true);
 		if(currentInfo === undefined) {
 			continue;
 		}
@@ -442,7 +456,7 @@ export function getAllLinkedFunctionDefinitions(
 			}
 		}
 
-		if(hasReturnEdge) {
+		if(vertex.tag === VertexType.FunctionCall || hasReturnEdge) {
 			continue;
 		}
 
@@ -478,7 +492,7 @@ export function linkInputs(referencesToLinkAgainstEnvironment: readonly Identifi
 			let allBuiltIn = true;
 			for(const target of probableTarget) {
 				// we can stick with maybe even if readId.attribute is always
-				graph.addEdge(bodyInput, target, EdgeType.Reads);
+				graph.addEdge(bodyInput.nodeId, target.nodeId, EdgeType.Reads);
 				if(!isReferenceType(target.type, ReferenceType.BuiltInConstant | ReferenceType.BuiltInFunction)) {
 					allBuiltIn = false;
 				}
diff --git a/src/dataflow/internal/process/functions/call/built-in/built-in-apply.ts b/src/dataflow/internal/process/functions/call/built-in/built-in-apply.ts
@@ -176,10 +176,11 @@ export function processApply<OtherInfo>(
 				}
 				expensiveTrace(dataflowLogger, () => `Found ${resolved.length} references to open ref ${ingoing.nodeId} in closure of function definition ${rootId}`);
 				let allBuiltIn = true;
-				for(const ref of resolved) {
-					information.graph.addEdge(ingoing, ref, EdgeType.Reads);
-					information.graph.addEdge(rootId, ref, EdgeType.Reads); // because the def. is the anonymous call
-					if(!isReferenceType(ref.type, ReferenceType.BuiltInConstant | ReferenceType.BuiltInFunction)) {
+				const inId = ingoing.nodeId;
+				for(const { nodeId, type } of resolved) {
+					information.graph.addEdge(inId, nodeId, EdgeType.Reads);
+					information.graph.addEdge(rootId, nodeId, EdgeType.Reads); // because the def. is the anonymous call
+					if(!isReferenceType(type, ReferenceType.BuiltInConstant | ReferenceType.BuiltInFunction)) {
 						allBuiltIn = false;
 					}
 				}
diff --git a/src/dataflow/internal/process/functions/call/built-in/built-in-assignment.ts b/src/dataflow/internal/process/functions/call/built-in/built-in-assignment.ts
@@ -434,12 +434,13 @@ export function markAsAssignment<OtherInfo>(
 
 	information.environment = define(nodeToDefine, assignmentConfig?.superAssignment, information.environment, data.ctx.config);
 	information.graph.setDefinitionOfVertex(nodeToDefine);
+	const nid = nodeToDefine.nodeId;
 	if(!assignmentConfig?.quoteSource) {
 		for(const sourceId of sourceIds) {
-			information.graph.addEdge(nodeToDefine, sourceId, EdgeType.DefinedBy);
+			information.graph.addEdge(nid, sourceId, EdgeType.DefinedBy);
 		}
 	}
-	information.graph.addEdge(nodeToDefine, rootIdOfAssignment, EdgeType.DefinedBy);
+	information.graph.addEdge(nid, rootIdOfAssignment, 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 ?? [])) {
diff --git a/src/dataflow/internal/process/functions/call/built-in/built-in-expression-list.ts b/src/dataflow/internal/process/functions/call/built-in/built-in-expression-list.ts
@@ -53,11 +53,13 @@ function linkReadNameToWriteIfPossible(read: IdentifierReference, environments:
 		return;
 	}
 
+	const rid = read.nodeId;
 	for(const target of probableTarget) {
-		// we can stick with maybe even if readId.attribute is always
-		nextGraph.addEdge(read, target, EdgeType.Reads);
+		const tid = target.nodeId;
 		if((read.type === ReferenceType.Function || read.type === ReferenceType.BuiltInFunction) && (isBuiltIn(target.definedAt))) {
-			nextGraph.addEdge(read, target, EdgeType.Calls);
+			nextGraph.addEdge(rid, tid, EdgeType.Reads | EdgeType.Calls);
+		} else {
+			nextGraph.addEdge(rid, tid, EdgeType.Reads);
 		}
 	}
 }
diff --git a/src/dataflow/internal/process/functions/call/built-in/built-in-function-definition.ts b/src/dataflow/internal/process/functions/call/built-in/built-in-function-definition.ts
@@ -1,5 +1,9 @@
 import { type DataflowProcessorInformation, processDataflowFor } from '../../../../../processor';
-import { type DataflowInformation, ExitPointType, overwriteExitPoints } from '../../../../../info';
+import {
+	type DataflowInformation,
+	ExitPointType,
+	overwriteExitPoints
+} from '../../../../../info';
 import {
 	getAllFunctionCallTargets,
 	linkArgumentsOnCall,
@@ -246,10 +250,11 @@ function updateNestedFunctionClosures(
 				remainingIn.push(ingoing);
 				continue;
 			}
+			const inId = ingoing.nodeId;
 			expensiveTrace(dataflowLogger, () => `Found ${resolved.length} references to open ref ${id} in closure of function definition ${fnId}`);
 			let allBuiltIn = true;
 			for(const ref of resolved) {
-				graph.addEdge(ingoing, ref, EdgeType.Reads);
+				graph.addEdge(inId, ref.nodeId, EdgeType.Reads);
 				if(!isReferenceType(ref.type, ReferenceType.BuiltInConstant | ReferenceType.BuiltInFunction)) {
 					allBuiltIn = false;
 				}
@@ -307,6 +312,9 @@ export function updateNestedFunctionCalls(
 				continue;
 			}
 			graph.addEdge(id, target, EdgeType.Calls);
+			for(const exitPoint of targetVertex.exitPoints) {
+				graph.addEdge(id, exitPoint.nodeId, EdgeType.Returns);
+			}
 			const ingoingRefs = targetVertex.subflow.in;
 			const remainingIn: IdentifierReference[] = [];
 			for(const ingoing of ingoingRefs) {
@@ -315,11 +323,12 @@ export function updateNestedFunctionCalls(
 					remainingIn.push(ingoing);
 					continue;
 				}
+				const inId = ingoing.nodeId;
 				expensiveTrace(dataflowLogger, () => `Found ${resolved.length} references to open ref ${id} in closure of function definition ${id}`);
-				for(const def of resolved) {
-					if(!isBuiltIn(def.nodeId)) {
-						graph.addEdge(ingoing, def, EdgeType.DefinedByOnCall);
-						graph.addEdge(id, def, EdgeType.DefinesOnCall);
+				for(const { nodeId } of resolved) {
+					if(!isBuiltIn(nodeId)) {
+						graph.addEdge(inId, nodeId, EdgeType.DefinedByOnCall);
+						graph.addEdge(id, nodeId, EdgeType.DefinesOnCall);
 					}
 				}
 			}
@@ -355,9 +364,10 @@ function findPromiseLinkagesForParameters(parameters: DataflowGraph, readInParam
 	const remainingRead: IdentifierReference[] = [];
 	for(const read of readInParameters) {
 		const resolved = read.name ? resolveByName(read.name, parameterEnvs, read.type) : undefined;
+		const rid = read.nodeId;
 		if(resolved !== undefined) {
-			for(const ref of resolved) {
-				parameters.addEdge(read, ref, EdgeType.Reads);
+			for(const { nodeId } of resolved) {
+				parameters.addEdge(rid, nodeId, EdgeType.Reads);
 			}
 			continue;
 		}
@@ -370,11 +380,11 @@ function findPromiseLinkagesForParameters(parameters: DataflowGraph, readInParam
 			continue;
 		}
 		if(writingOuts[0].cds === undefined) {
-			parameters.addEdge(read, writingOuts[0], EdgeType.Reads);
+			parameters.addEdge(rid, writingOuts[0].nodeId, EdgeType.Reads);
 			continue;
 		}
-		for(const out of writingOuts) {
-			parameters.addEdge(read, out, EdgeType.Reads);
+		for(const { nodeId } of writingOuts) {
+			parameters.addEdge(rid, nodeId, EdgeType.Reads);
 		}
 	}
 	return remainingRead;
diff --git a/src/dataflow/internal/process/functions/call/built-in/built-in-get.ts b/src/dataflow/internal/process/functions/call/built-in/built-in-get.ts
@@ -53,7 +53,7 @@ export function processGet<OtherInfo>(
 	const firstArg = processedArguments[0];
 	if(firstArg) {
 		// get 'reads' its first argument
-		information.graph.addEdge(rootId, firstArg.entryPoint, EdgeType.Reads);
+		information.graph.addEdge(rootId, firstArg.entryPoint, EdgeType.Returns | EdgeType.Reads);
 	}
 
 	return information;
diff --git a/src/dataflow/internal/process/functions/call/built-in/built-in-try-catch.ts b/src/dataflow/internal/process/functions/call/built-in/built-in-try-catch.ts
@@ -155,8 +155,9 @@ function promoteCallToFunction<OtherInfo>(call: NodeId, arg: NodeId, info: Dataf
 				expensiveTrace(dataflowLogger, () => `Found ${resolved.length} references to open ref ${ingoing.nodeId} in closure of function definition ${call}`);
 				let allBuiltIn = true;
 				for(const ref of resolved) {
-					info.graph.addEdge(ingoing, ref, EdgeType.Reads);
-					info.graph.addEdge(call, ref, EdgeType.Reads); // because the def. is the anonymous call
+					const rid = ref.nodeId;
+					info.graph.addEdge(ingoing.nodeId, rid, EdgeType.Reads);
+					info.graph.addEdge(call, rid, EdgeType.Reads); // because the def. is the anonymous call
 					if(!isReferenceType(ref.type, ReferenceType.BuiltInConstant | ReferenceType.BuiltInFunction)) {
 						allBuiltIn = false;
 					}
diff --git a/src/dataflow/internal/process/functions/process-argument.ts b/src/dataflow/internal/process/functions/process-argument.ts
@@ -17,9 +17,10 @@ export function linkReadsForArgument<OtherInfo>(root: RNode<OtherInfo & ParentIn
 	const allIdsBeforeArguments = new Set(collectAllIds(root, n => n.type === RType.Argument && n.info.id !== root.info.id));
 	const ingoingBeforeArgs = ingoingRefs.filter(r => allIdsBeforeArguments.has(r.nodeId));
 
+	const rid = root.info.id;
 	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, EdgeType.Reads);
+		graph.addEdge(rid, ref.nodeId, EdgeType.Reads);
 	}
 }
 
diff --git a/src/dataflow/internal/process/functions/process-parameter.ts b/src/dataflow/internal/process/functions/process-parameter.ts
@@ -25,17 +25,18 @@ export function processFunctionParameter<OtherInfo>(parameter: RParameter<OtherI
 
 	let environment = name.environment;
 	for(const writtenNode of writtenNodes) {
-		expensiveTrace(log, () => `parameter ${writtenNode.name} (${writtenNode.nodeId}) is defined at id ${writtenNode.definedAt} with ${defaultValue === undefined ? 'no default value' : ' a default value'}`);
+		const wid = writtenNode.nodeId;
+		expensiveTrace(log, () => `parameter ${writtenNode.name} (${wid}) is defined at id ${writtenNode.definedAt} with ${defaultValue === undefined ? 'no default value' : ' a default value'}`);
 		graph.setDefinitionOfVertex(writtenNode);
 		environment = define(writtenNode, false, environment, data.ctx.config);
 
 		if(defaultValue !== undefined) {
 			if(parameter.defaultValue?.type === RType.FunctionDefinition) {
-				graph.addEdge(writtenNode, parameter.defaultValue.info.id, EdgeType.DefinedBy);
+				graph.addEdge(wid, parameter.defaultValue.info.id, EdgeType.DefinedBy);
 			} else {
 				const definedBy = defaultValue.in.concat(defaultValue.unknownReferences);
 				for(const node of definedBy) {
-					graph.addEdge(writtenNode, node, EdgeType.DefinedBy);
+					graph.addEdge(wid, node.nodeId, EdgeType.DefinedBy);
 				}
 			}
 		}
diff --git a/test/functionality/dataflow/linker/linked-function-definitions.test.ts b/test/functionality/dataflow/linker/linked-function-definitions.test.ts
@@ -0,0 +1,61 @@
+import { assert, describe, it } from 'vitest';
+import { withTreeSitter } from '../../_helper/shell';
+import { FlowrAnalyzerBuilder } from '../../../../src/project/flowr-analyzer-builder';
+import { requestFromInput } from '../../../../src/r-bridge/retriever';
+import { tryResolveSliceCriterionToId } from '../../../../src/slicing/criterion/parse';
+import { graphToMermaidUrl } from '../../../../src/util/mermaid/dfg';
+import { getAllLinkedFunctionDefinitions } from '../../../../src/dataflow/internal/linker';
+import { builtInId } from '../../../../src/dataflow/environments/built-in';
+import { label } from '../../_helper/label';
+
+describe('Linked Function Definitions', withTreeSitter(ts => {
+	function expectLinkedFns(lab: string, code: string, expect: Record<string, { fns?: string[], bi?: string[] }>) {
+		it(label(lab, [], ['dataflow']), async() => {
+			const a = await new FlowrAnalyzerBuilder().setParser(ts).build();
+			a.addRequest(requestFromInput(code));
+			const df = await a.dataflow();
+			const idMap = (await a.normalize()).idMap;
+			try {
+				for(const [call, { fns, bi }] of Object.entries(expect)) {
+					const callId = tryResolveSliceCriterionToId(call, idMap) ?? call;
+					const [lfns, lbi] = getAllLinkedFunctionDefinitions(new Set([callId]), df.graph);
+
+					assert.deepStrictEqual(Array.from(lbi).sort(), (bi ?? []).sort(), `linked bi for call ${call}`);
+					// decode linked function names
+					const expected = (fns ?? []).map(n => tryResolveSliceCriterionToId(n, idMap) ?? n).sort();
+					assert.deepStrictEqual(Array.from(lfns, l => l.id).sort(), expected, `linked fns for call ${call}`);
+				}
+			} catch(e) {
+				console.log(e);
+				console.log('Code:\n' + code);
+				console.log(graphToMermaidUrl(df.graph));
+				throw e;
+			}
+		});
+	}
+
+	expectLinkedFns('one definition', 'x <- function(a) { a + 1 }', {
+		'1@x': { fns: ['1@function'] }
+	});
+	expectLinkedFns('alias bi', 'x <- c', {
+		'1@x': { bi: [builtInId('c')] }
+	});
+	expectLinkedFns('alias bi with sconst', 'if(u) c <- 3\nx <- c', {
+		'2@x': { bi: [builtInId('c')] }
+	});
+	expectLinkedFns('one definition ho', 'x <- function(a) { a + 1 }\ny <- function() { x } \nh <- y()', {
+		'3@h': { fns: ['1@function'] }
+	});
+	expectLinkedFns('hidden with get', 'x <- function(a) { a + 1 }\ny <- function() { get("x") } \nh <- y()', {
+		'3@h': { fns: ['1@function'] }
+	});
+	expectLinkedFns('hidden with side-effect', 'y <- function() {\nx <<- function(a) { a + 1 } }\ny()\nh <- x', {
+		'4@h': { fns: ['2@function'] }
+	});
+	expectLinkedFns('unreturned fn', 'y <- function() {\nfunction(); 2 }\nh <- y()', {
+		'4@h': { fns: [] }
+	});
+	expectLinkedFns('multiple defs', 'x <- function(a) { a + 1 }\nk <- function() function() 2\ny <- function() { if(u) { x } else { k() } } \nh <- y()', {
+		'4@h': { fns: ['1@function', '2@function'] }
+	});
+}));
diff --git a/test/functionality/dataflow/processing-of-elements/atomic/dataflow-atomic.test.ts b/test/functionality/dataflow/processing-of-elements/atomic/dataflow-atomic.test.ts
@@ -895,7 +895,7 @@ describe.sequential('Atomic (dataflow information)', withShell(shell => {
 				.call(4, '<-', [argumentInCall(0), argumentInCall(3)],{ returns: [0], reads: [builtInId('<-'), 3], onlyBuiltIn: true })
 				.calls(4, builtInId('<-'))
 				.calls(9, 3)
-				.call(8, 'get', [argumentInCall(6)], { reads: [6, builtInId('get')], onlyBuiltIn: true, environment: defaultEnv().defineFunction('a', 0, 4) })
+				.call(8, 'get', [argumentInCall(6)], { returns: [6], reads: [6, builtInId('get')], onlyBuiltIn: true, environment: defaultEnv().defineFunction('a', 0, 4) })
 				.calls(8, builtInId('get'))
 				.defineFunction(3, [1], {
 					entryPoint:        0,
diff --git a/test/functionality/dataflow/processing-of-elements/expression-lists/dataflow-if-then.test.ts b/test/functionality/dataflow/processing-of-elements/expression-lists/dataflow-if-then.test.ts

Original file line number	Diff line number	Diff line change
`@@ -176,10 +176,11 @@ export function processApply<OtherInfo>(`
`176`	`176`	`}`
`177`	`177`	expensiveTrace(dataflowLogger, () => `Found ${resolved.length} references to open ref ${ingoing.nodeId} in closure of function definition ${rootId}`);
`178`	`178`	`let allBuiltIn = true;`
`179`		`- for(const ref of resolved) {`
`180`		`- information.graph.addEdge(ingoing, ref, EdgeType.Reads);`
`181`		`- information.graph.addEdge(rootId, ref, EdgeType.Reads); // because the def. is the anonymous call`
`182`		`- if(!isReferenceType(ref.type, ReferenceType.BuiltInConstant \| ReferenceType.BuiltInFunction)) {`
	`179`	`+ const inId = ingoing.nodeId;`
	`180`	`+ for(const { nodeId, type } of resolved) {`
	`181`	`+ information.graph.addEdge(inId, nodeId, EdgeType.Reads);`
	`182`	`+ information.graph.addEdge(rootId, nodeId, EdgeType.Reads); // because the def. is the anonymous call`
	`183`	`+ if(!isReferenceType(type, ReferenceType.BuiltInConstant \| ReferenceType.BuiltInFunction)) {`
`183`	`184`	`allBuiltIn = false;`
`184`	`185`	`}`
`185`	`186`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,11 +53,13 @@ function linkReadNameToWriteIfPossible(read: IdentifierReference, environments:`
`53`	`53`	`return;`
`54`	`54`	`}`
`55`	`55`
	`56`	`+ const rid = read.nodeId;`
`56`	`57`	`for(const target of probableTarget) {`
`57`		`- // we can stick with maybe even if readId.attribute is always`
`58`		`- nextGraph.addEdge(read, target, EdgeType.Reads);`
	`58`	`+ const tid = target.nodeId;`
`59`	`59`	`if((read.type === ReferenceType.Function \|\| read.type === ReferenceType.BuiltInFunction) && (isBuiltIn(target.definedAt))) {`
`60`		`- nextGraph.addEdge(read, target, EdgeType.Calls);`
	`60`	`+ nextGraph.addEdge(rid, tid, EdgeType.Reads \| EdgeType.Calls);`
	`61`	`+ } else {`
	`62`	`+ nextGraph.addEdge(rid, tid, EdgeType.Reads);`
`61`	`63`	`}`
`62`	`64`	`}`
`63`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ export function processGet<OtherInfo>(`
`53`	`53`	`const firstArg = processedArguments[0];`
`54`	`54`	`if(firstArg) {`
`55`	`55`	`// get 'reads' its first argument`
`56`		`- information.graph.addEdge(rootId, firstArg.entryPoint, EdgeType.Reads);`
	`56`	`+ information.graph.addEdge(rootId, firstArg.entryPoint, EdgeType.Returns \| EdgeType.Reads);`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`return information;`
Original file line number	Diff line number	Diff line change
`@@ -17,9 +17,10 @@ export function linkReadsForArgument<OtherInfo>(root: RNode<OtherInfo & ParentIn`
`17`	`17`	`const allIdsBeforeArguments = new Set(collectAllIds(root, n => n.type === RType.Argument && n.info.id !== root.info.id));`
`18`	`18`	`const ingoingBeforeArgs = ingoingRefs.filter(r => allIdsBeforeArguments.has(r.nodeId));`
`19`	`19`
	`20`	`+ const rid = root.info.id;`
`20`	`21`	`for(const ref of ingoingBeforeArgs) {`
`21`	`22`	`// link against the root reference currently I do not know how to deal with nested function calls otherwise`
`22`		`- graph.addEdge(root.info.id, ref, EdgeType.Reads);`
	`23`	`+ graph.addEdge(rid, ref.nodeId, EdgeType.Reads);`
`23`	`24`	`}`
`24`	`25`	`}`
`25`	`26`