Additional tests

src/dataflow/environments/diff.ts

@@ -45,7 +45,7 @@
 				info.report.addComment(`${info.position}Different ids for ${key}. ${info.leftname}: ${aVal.nodeId} vs. ${info.rightname}: ${bVal.nodeId}`)
 			}
 			if(!arrayEqual(aVal.controlDependencies, bVal.controlDependencies)) {
-				info.report.addComment(`${info.position}Different controlDependency for ${key} (${aVal.nodeId}). ${info.leftname}: ${JSON.stringify(aVal.controlDependencies)} vs. ${info.rightname}: ${JSON.stringify(bVal.controlDependencies)}`)
+				info.report.addComment(`${info.position}Different controlDependencies for ${key} (${aVal.nodeId}). ${info.leftname}: ${JSON.stringify(aVal.controlDependencies)} vs. ${info.rightname}: ${JSON.stringify(bVal.controlDependencies)}`)
 			}
 			if(aVal.definedAt !== bVal.definedAt) {
 				info.report.addComment(`${info.position}Different definition ids (definedAt) for ${key} (${aVal.nodeId}). ${info.leftname}: ${aVal.definedAt} vs. ${info.rightname}: ${bVal.definedAt}`)

src/dataflow/graph/diff.ts

@@ -226,7 +226,7 @@ export function diffVertices(ctx: DataflowDiffContext): void {
 		}
 		if(!arrayEqual(lInfo.controlDependencies, rInfo.controlDependencies)) {
 			ctx.report.addComment(
-				`Vertex ${id} differs in controlDependency. ${ctx.leftname}: ${JSON.stringify(lInfo.controlDependencies)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.controlDependencies)}`,
+				`Vertex ${id} differs in controlDependencies. ${ctx.leftname}: ${JSON.stringify(lInfo.controlDependencies)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.controlDependencies)}`,
 				{ tag: 'vertex', id }
 			)
 		}

test/functionality/_helper/dataflow/dataflow-builder-printer.ts

@@ -127,13 +127,13 @@ class DataflowBuilderPrinter {
 		if(arg === undefined || arg === EmptyArgument) {
 			return 'EmptyArgument'
 		} else if(isPositionalArgument(arg)) {
-			const suffix = this.getControlDependencySuffix(this.controlDependencyForArgument(arg.nodeId), ', { ') ?? ''
+			const suffix = this.getControlDependencySuffix(this.controlDependenciesForArgument(arg.nodeId), ', { ') ?? ''
 			this.handleArgumentArgLinkage(fn, arg.nodeId)
 			return `argumentInCall('${arg.nodeId}'${suffix})`
 		} else {
 			this.coveredVertices.add(arg.nodeId)
 			this.handleArgumentArgLinkage(fn, arg.nodeId)
-			const suffix = this.getControlDependencySuffix(this.controlDependencyForArgument(arg.nodeId), ', ', '') ?? ''
+			const suffix = this.getControlDependencySuffix(this.controlDependenciesForArgument(arg.nodeId), ', ', '') ?? ''
 			return `argumentInCall('${arg.nodeId}', { name: '${arg.name}'${suffix} } )`
 		}
 	}
@@ -153,7 +153,7 @@ class DataflowBuilderPrinter {
 		}
 	}
 
-	private controlDependencyForArgument(id: NodeId): NodeId[] | undefined {
+	private controlDependenciesForArgument(id: NodeId): NodeId[] | undefined {
 		// we ignore the control dependency of the argument in the call as it is usually separate, and the auto creation
 		// will respect the corresponding node!
 		return this.graph.getVertex(id, true)?.controlDependencies
@@ -247,7 +247,7 @@ class DataflowBuilderPrinter {
 
 	private getControlDependencySuffix(arg: NodeId[] | undefined, prefix: string = '{ ', suffix: string = ' }'): string | undefined {
 		if(arg !== undefined) {
-			return `${prefix}controlDependency: [${arg.map(id => wrap(id)).join(', ')}]${suffix}`
+			return `${prefix}controlDependencies: [${arg.map(id => wrap(id)).join(', ')}]${suffix}`
 		}
 		return undefined
 	}

test/functionality/_helper/dataflow/dataflowgraph-builder.ts

@@ -40,7 +40,7 @@ export class DataflowGraphBuilder extends DataflowGraph {
 	 */
 	public defineFunction(id: NodeId,
 		exitPoints: readonly NodeId[], subflow: DataflowFunctionFlowInformation,
-		info?: { environment?: REnvironmentInformation, controlDependency?: NodeId[] },
+		info?: { environment?: REnvironmentInformation, controlDependencies?: NodeId[] },
 		asRoot: boolean = true) {
 		return this.addVertex({
 			tag:     VertexType.FunctionDefinition,
@@ -54,7 +54,7 @@ export class DataflowGraphBuilder extends DataflowGraph {
 				unknownReferences: subflow.unknownReferences.map(o => ({ ...o, nodeId: normalizeIdToNumberIfPossible(o.nodeId), controlDependencies: o.controlDependencies?.map(normalizeIdToNumberIfPossible) }))
 			} as DataflowFunctionFlowInformation,
 			exitPoints:          exitPoints.map(normalizeIdToNumberIfPossible),
-			controlDependencies: info?.controlDependency?.map(normalizeIdToNumberIfPossible),
+			controlDependencies: info?.controlDependencies?.map(normalizeIdToNumberIfPossible),
 			environment:         info?.environment
 		}, asRoot)
 	}
@@ -71,21 +71,21 @@ export class DataflowGraphBuilder extends DataflowGraph {
 	 */
 	public call(id: NodeId, name: string, args: FunctionArgument[],
 		info?: {
-			returns?:           readonly NodeId[],
-			reads?:             readonly NodeId[],
-			onlyBuiltIn?:       boolean,
-			environment?:       REnvironmentInformation,
-			controlDependency?: NodeId[]
+			returns?:             readonly NodeId[],
+			reads?:               readonly NodeId[],
+			onlyBuiltIn?:         boolean,
+			environment?:         REnvironmentInformation,
+			controlDependencies?: NodeId[]
 		},
 		asRoot: boolean = true) {
 		const onlyBuiltInAuto = info?.reads?.length === 1 && info?.reads[0] === BuiltIn
 		this.addVertex({
 			tag:                 VertexType.FunctionCall,
 			id:                  normalizeIdToNumberIfPossible(id),
 			name,
-			args:                args.map(a => a === EmptyArgument ? EmptyArgument : { ...a, nodeId: normalizeIdToNumberIfPossible(a.nodeId), controlDependency: undefined }),
+			args:                args.map(a => a === EmptyArgument ? EmptyArgument : { ...a, nodeId: normalizeIdToNumberIfPossible(a.nodeId), controlDependencies: undefined }),
 			environment:         info?.environment ?? initializeCleanEnvironments(),
-			controlDependencies: info?.controlDependency?.map(normalizeIdToNumberIfPossible),
+			controlDependencies: info?.controlDependencies?.map(normalizeIdToNumberIfPossible),
 			onlyBuiltin:         info?.onlyBuiltIn ?? onlyBuiltInAuto ?? false
 		}, asRoot)
 		this.addArgumentLinks(id, args)
@@ -131,12 +131,12 @@ export class DataflowGraphBuilder extends DataflowGraph {
 	 * (i.e., be a valid entry point), or is it nested (e.g., as part of a function definition)
 	 */
 	public defineVariable(id: NodeId, name: string,
-		info?: { controlDependency?: NodeId[], definedBy?: NodeId[]}, asRoot: boolean = true) {
+		info?: { controlDependencies?: NodeId[], definedBy?: NodeId[]}, asRoot: boolean = true) {
 		this.addVertex({
 			tag:                 VertexType.VariableDefinition,
 			id:                  normalizeIdToNumberIfPossible(id),
 			name,
-			controlDependencies: info?.controlDependency?.map(normalizeIdToNumberIfPossible),
+			controlDependencies: info?.controlDependencies?.map(normalizeIdToNumberIfPossible),
 		}, asRoot)
 		if(info?.definedBy) {
 			for(const def of info.definedBy) {
@@ -177,11 +177,11 @@ export class DataflowGraphBuilder extends DataflowGraph {
 	 * @param asRoot - should the vertex be part of the root vertex set of the graph
 	 * (i.e., be a valid entry point), or is it nested (e.g., as part of a function definition)
 	 */
-	public constant(id: NodeId, options?: { controlDependency?: NodeId[] }, asRoot: boolean = true) {
+	public constant(id: NodeId, options?: { controlDependencies?: NodeId[] }, asRoot: boolean = true) {
 		return this.addVertex({
 			tag:                 VertexType.Value,
 			id:                  normalizeIdToNumberIfPossible(id),
-			controlDependencies: options?.controlDependency?.map(normalizeIdToNumberIfPossible),
+			controlDependencies: options?.controlDependencies?.map(normalizeIdToNumberIfPossible),
 			environment:         undefined
 		}, asRoot)
 	}

test/functionality/_helper/dataflow/environment-builder.ts

@@ -17,8 +17,8 @@ export function variable(name: string, definedAt: NodeId): IdentifierDefinition
  * @param nodeId - AST Node ID
  * @param options - optional allows to give further options
  */
-export function argumentInCall(nodeId: NodeId, options?: { name?: string, controlDependency?: NodeId[] }): FunctionArgument {
-	return { nodeId: normalizeIdToNumberIfPossible(nodeId), name: options?.name, controlDependencies: options?.controlDependency?.map(normalizeIdToNumberIfPossible) }
+export function argumentInCall(nodeId: NodeId, options?: { name?: string, controlDependencies?: NodeId[] }): FunctionArgument {
+	return { nodeId: normalizeIdToNumberIfPossible(nodeId), name: options?.name, controlDependencies: options?.controlDependencies?.map(normalizeIdToNumberIfPossible) }
 }
 /**
  * The constant global environment with all pre-defined functions.

test/functionality/_helper/dataflow/printer.ts

@@ -20,13 +20,13 @@ export function wrap(id: string | NodeId | undefined): string {
 	}
 }
 
-function wrapControlDependency(controlDependency: NodeId[] | undefined): string {
-	if(controlDependency === undefined) {
+function wrapControlDependencies(controlDependencies: NodeId[] | undefined): string {
+	if(controlDependencies === undefined) {
 		return 'undefined'
 	} else {
-		return `[${controlDependency.map(wrap).join(', ')}]`
+		return `[${controlDependencies.map(wrap).join(', ')}]`
 	}
 }
 export function wrapReference(ref: IdentifierReference): string {
-	return `{ nodeId: ${wrap(ref.nodeId)}, name: ${wrap(ref.name)}, controlDependencies: ${wrapControlDependency(ref.controlDependencies)} }`
+	return `{ nodeId: ${wrap(ref.nodeId)}, name: ${wrap(ref.name)}, controlDependencies: ${wrapControlDependencies(ref.controlDependencies)} }`
 }