refactor: robustify with parameters

Author: EagleoutIce

src/dataflow/eval/resolve/alias-tracking.ts

@@ -10,7 +10,7 @@ import type { BuiltInIdentifierConstant } from '../../environments/built-in';
 import { type IEnvironment, type REnvironmentInformation } from '../../environments/environment';
 import { Identifier, ReferenceType } from '../../environments/identifier';
 import { resolveByName, resolveByNameAnyType } from '../../environments/resolve-by-name';
-import { EdgeType } from '../../graph/edge';
+import { DfEdge, EdgeType } from '../../graph/edge';
 import type { DataflowGraph } from '../../graph/graph';
 import { onReplacementOperator, type ReplacementOperatorHandlerArgs } from '../../graph/unknown-replacement';
 import { onUnknownSideEffect } from '../../graph/unknown-side-effect';
@@ -21,7 +21,7 @@ import { setFrom } from '../values/sets/set-constants';
 import { resolveNode } from './resolve';
 import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
 import type { RSymbol } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
-import { RLoopConstructs } from '../../../r-bridge/lang-4.x/ast/model/model';
+import { RLoopConstructs, RNode } from '../../../r-bridge/lang-4.x/ast/model/model';
 import { RoleInParent } from '../../../r-bridge/lang-4.x/ast/model/processing/role';
 
 export type ResolveResult = Lift<ValueSet<Value[]>>;
@@ -294,21 +294,7 @@ onReplacementOperator((args: ReplacementOperatorHandlerArgs) => {
 });
 
 function isNestedInLoop(node: RNodeWithParent | undefined, ast: AstIdMap): boolean {
-	const parent = node?.info.parent;
-	if(node === undefined || !parent) {
-		return false;
-	}
-
-	const parentNode = ast.get(parent);
-	if(parentNode === undefined) {
-		return false;
-	}
-
-	if(parentNode.type === RType.WhileLoop || parentNode.type === RType.RepeatLoop || parentNode.type === RType.ForLoop) {
-		return true;
-	}
-
-	return isNestedInLoop(parentNode, ast);
+	return RNode.iterateParents(node, ast).some(RLoopConstructs.is);
 }
 
 /**
@@ -368,19 +354,24 @@ export function trackAliasesInGraph(id: NodeId, graph: DataflowGraph, ctx: ReadO
 
 		const isFn = t === VertexType.FunctionCall;
 		const outgoingEdges = graph.outgoingEdges(id) ?? [];
+		let foundRetuns = false;
 		// travel all read and defined-by edges
 		for(const [targetId, { types }] of outgoingEdges) {
 			if(isFn) {
 				if(types === EdgeType.Returns || types === EdgeType.DefinedByOnCall || types ===  EdgeType.DefinedBy) {
 					queue.add(targetId, baseEnvironment, cleanFingerprint, false);
 				}
+				foundRetuns ||= DfEdge.includesType({ types }, EdgeType.Returns);
 				continue;
 			}
 			// currently, they have to be exact!
 			if(types === EdgeType.Reads || types ===  EdgeType.DefinedBy || types === EdgeType.DefinedByOnCall) {
 				queue.add(targetId, baseEnvironment, cleanFingerprint, false);
 			}
 		}
+		if(isFn && !foundRetuns) {
+			return Top;
+		}
 	}
 
 	if(forceTop || resultIds.length === 0) {
@@ -391,7 +382,7 @@ export function trackAliasesInGraph(id: NodeId, graph: DataflowGraph, ctx: ReadO
 	for(const id of resultIds) {
 		const node = idMap.get(id);
 		if(node !== undefined) {
-			if(node.info.role === RoleInParent.ParameterDefaultValue) {
+			if(node.info.role === RoleInParent.ParameterDefaultValue || RNode.iterateParents(node, idMap).some(p => p.info.role === RoleInParent.ParameterDefaultValue)) {
 				return Top;
 			}
 			values.add(valueFromRNodeConstant(node));

src/r-bridge/lang-4.x/ast/model/model.ts

@@ -344,19 +344,32 @@ export const RNode = {
 	 * Returns the direct parent of a node.
 	 * Usually, only root nodes do not have a parent, and you can assume that there is a
 	 * linear chain of parents leading to the root node.
+	 * @see {@link iterateParents} - to get all parents of a node
 	 */
-	directParent<OtherInfo>(this: void, node: RNode<OtherInfo & ParentInformation>, idMap: Map<NodeId, RNode<OtherInfo>>): RNode<OtherInfo> | undefined {
+	directParent<OtherInfo>(this: void, node: RNode<OtherInfo & ParentInformation>, idMap: Map<NodeId, RNode<OtherInfo & ParentInformation>>): RNode<OtherInfo & ParentInformation> | undefined {
 		const parentId = node.info.parent;
 		if(parentId === undefined) {
 			return undefined;
 		}
 		return idMap.get(parentId);
 	},
+	/**
+	 * Returns an iterable of all parents of a node, starting with the direct parent and ending with the root node.
+	 */
+	*iterateParents<OtherInfo>(this: void, node: RNode<OtherInfo & ParentInformation> | undefined, idMap: Map<NodeId, RNode<OtherInfo & ParentInformation>>): Generator<RNode<OtherInfo & ParentInformation>> {
+		let currentNode: RNode<OtherInfo & ParentInformation> | undefined = node;
+		while(currentNode) {
+			currentNode = RNode.directParent(currentNode, idMap);
+			if(currentNode) {
+				yield currentNode;
+			}
+		}
+	},
 	/**
 	 * In contrast to the nesting stored in the {@link RNode} structure,
 	 * this function calculates the depth of a node by counting the number of parents until the root node is reached.
 	 */
-	depth(this: void, node: RNode, idMap: Map<NodeId, RNode>): number {
+	depth(this: void, node: RNode<ParentInformation>, idMap: Map<NodeId, RNode<ParentInformation>>): number {
 		let depth = 0;
 		let currentNode: RNode | undefined = node;
 		while(currentNode) {

test/functionality/dataflow/query/resolve-value-query.test.ts

@@ -57,6 +57,7 @@ describe('Resolve Value Query', withTreeSitter( parser => {
 		testQuery('No call-sites with parameter', 'f <- function(x=42) { \nprint(x)}', ['2@x'], [[Top]]);
 		testQuery('No call-sites with calculated parameter', 'f <- function(x=42+1) { \nprint(x)}', ['2@x'], [[Top]]);
 		testQuery('No call-sites with maybe parameter', 'f <- function(x=42) { if(u) x <- 2\nprint(x)}', ['2@x'], [[Top]]);
+		testQuery('No call-sites with maybe parameter and calc', 'f <- function(x=42+1) { if(u) x <- 2\nprint(x)}', ['2@x'], [[Top]]);
 	});
 
 	describe('For now suboptimal', () =>  {