Feat: Follow up on source calls

src/dataflow/extractor.ts

@@ -49,7 +49,14 @@ const processors: DataflowProcessors<any> = {
 }
 
 export function produceDataFlowGraph<OtherInfo>(ast: NormalizedAst<OtherInfo & ParentInformation>, initialScope: DataflowScopeName = LocalScope): DataflowInformation {
-	return processDataflowFor<OtherInfo>(ast.ast, { completeAst: ast, activeScope: initialScope, environments: initializeCleanEnvironments(), processors: processors as DataflowProcessors<OtherInfo & ParentInformation> })
+	return processDataflowFor<OtherInfo>(ast.ast, {
+		completeAst:      ast,
+		activeScope:      initialScope,
+		environments:     initializeCleanEnvironments(),
+		processors:       processors as DataflowProcessors<OtherInfo & ParentInformation>,
+		currentPath:      'initial',
+		sourceReferences: new Map<string, string[]>()
+	})
 }
 
 export function processBinaryOp<OtherInfo>(node: RBinaryOp<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>) {

src/dataflow/internal/process/functions/source.ts

@@ -1,5 +1,5 @@
 import type {RArgument, RParseRequestProvider} from '../../../../r-bridge'
-import { requestProviderFromFile} from '../../../../r-bridge'
+import {requestProviderFromFile} from '../../../../r-bridge'
 import {fileNameDeterministicCountingIdGenerator, type NormalizedAst, type ParentInformation, removeTokenMapQuotationMarks, type RFunctionCall, RType} from '../../../../r-bridge'
 import {RShellExecutor} from '../../../../r-bridge/shell-executor'
 import {executeSingleSubStep} from '../../../../core'
@@ -28,6 +28,12 @@ export function processSourceCall<OtherInfo>(functionCall: RFunctionCall<OtherIn
 		const path = removeTokenMapQuotationMarks(sourceFile.lexeme)
 		const request = sourceProvider.createRequest(path)
 
+		// check if the sourced file has already been dataflow analyzed, and if so, skip it
+		if(data.sourceReferences.has(path)) {
+			dataflowLogger.info(`Sourced file ${path} was already dataflow analyzed, skipping`)
+			return information
+		}
+
 		// parse, normalize and dataflow the sourced file
 		let parsed: string
 		try {
@@ -36,11 +42,15 @@ export function processSourceCall<OtherInfo>(functionCall: RFunctionCall<OtherIn
 			dataflowLogger.warn(`Failed to parse sourced file ${path}, ignoring: ${(e as Error).message}`)
 			return information
 		}
+
+		// make the currently analyzed file remember that it already referenced the path
+		data.sourceReferences.set(data.currentPath, [...(data.sourceReferences.get(data.currentPath) ?? []), path])
+
 		const normalized = executeSingleSubStep('normalize', parsed, executor.getTokenMap(), undefined, fileNameDeterministicCountingIdGenerator(path)) as NormalizedAst<OtherInfo & ParentInformation>
-		const dataflow = processDataflowFor(normalized.ast, {...data, environments: information.environments})
+		const dataflow = processDataflowFor(normalized.ast, {...data, currentPath: path, environments: information.environments})
 
 		// update our graph with the sourced file's information
-	    const newInformation = {...information}
+		const newInformation = {...information}
 		newInformation.environments = overwriteEnvironments(information.environments, dataflow.environments)
 		newInformation.graph.mergeWith(dataflow.graph)
 		// this can be improved, see issue #628

src/dataflow/processor.ts

@@ -13,20 +13,23 @@ export interface DataflowProcessorInformation<OtherInfo> {
 	/**
    * Initial and frozen ast-information
    */
-	readonly completeAst:  NormalizedAst<OtherInfo>
+	readonly completeAst:      NormalizedAst<OtherInfo>
 	/**
    * Correctly contains pushed local scopes introduced by `function` scopes.
    * Will by default *not* contain any symbol-bindings introduces along the way, they have to be decorated when moving up the tree.
    */
-	readonly environments: REnvironmentInformation
+	readonly environments:     REnvironmentInformation
 	/**
    * Name of the currently active scope, (hopefully) always {@link LocalScope | Local}
    */
-	readonly activeScope:  DataflowScopeName
+	readonly activeScope:      DataflowScopeName
 	/**
    * Other processors to be called by the given functions
    */
-	readonly processors:   DataflowProcessors<OtherInfo>
+	readonly processors:       DataflowProcessors<OtherInfo>
+	// TODO using "initial" as the default path doesn't allow us to skip re-sourcing the initial file - how do we find out the initial file's name/path?
+	readonly currentPath:      string | 'initial'
+	readonly sourceReferences: Map<string, string[]>
 }
 
 export type DataflowProcessor<OtherInfo, NodeType extends RNodeWithParent<OtherInfo>> = (node: NodeType, data: DataflowProcessorInformation<OtherInfo>) => DataflowInformation
@@ -55,6 +58,3 @@ export type DataflowProcessors<OtherInfo> = {
 export function processDataflowFor<OtherInfo>(current: RNodeWithParent<OtherInfo>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation {
 	return data.processors[current.type](current as never, data)
 }
-
-
-