Additional tests

src/dataflow/graph/diff.ts

@@ -220,7 +220,7 @@ export function diffVertices(ctx: DataflowDiffContext): void {
 				})
 			}
 		}
-		diffControlDependencies(lInfo.controlDependencies, rInfo.controlDependencies, { ...ctx, position: `Vertex ${id} differs in controlDependency. ` })
+		diffControlDependencies(lInfo.controlDependencies, rInfo.controlDependencies, { ...ctx, position: `Vertex ${id} differs in controlDependencies. ` })
 
 		diffEnvironmentInformation(lInfo.environment, rInfo.environment, { ...ctx, position: `${ctx.position}Vertex ${id} differs in environment. ` })
 

src/r-bridge/data/data.ts

@@ -463,7 +463,7 @@ export const flowrCapabilities = {
 									name:        'Sequencing',
 									id:          'built-in-sequencing',
 									supported:   'not',
-									description: '_Handle `:`, `seq`, ... as they are used often._'
+									description: '_Handle `:`, `seq`, ... by gathering value information using abstract interpretation._'
 								},
 								{
 									name:        'Internal and Primitive Functions',

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

@@ -73,7 +73,7 @@ export const OperatorDatabase: Record<StringUsedInRCode, OperatorInformationValu
   '=':    { name: 'equal assignment',             stringUsedInRAst: RawRType.EqualAssign, stringUsedInternally: '=',    writtenAs: 'infix',  arity:  OperatorArity.Binary, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-equal-assignment', 'function-calls']  },
   /* others */
   /* maybe introduce custom in-r-ast flavor for these? we consider it arithmetic, as it works on numbers => if we change this we have to create custom tests! (with arithmetic, there is the automatic test set) */
-  ':':    { name: 'sequence operator',            stringUsedInRAst: RawRType.Colon,       stringUsedInternally: ':',    writtenAs: 'infix',  arity:  OperatorArity.Binary, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls', 'built-in-sequencing'] },
+  ':':    { name: 'sequence operator',            stringUsedInRAst: RawRType.Colon,       stringUsedInternally: ':',    writtenAs: 'infix',  arity:  OperatorArity.Binary, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
   '?':    { name: 'question',                     stringUsedInRAst: RawRType.Question,    stringUsedInternally: '?',    writtenAs: 'prefix', arity:  OperatorArity.Unary,  usedAs: 'operation', capabilities: ['unary-operator', 'built-in-help'] }
 }
 /* eslint-enable */

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

@@ -6,7 +6,7 @@
 import { assertUnreachable, isNotUndefined } from '../../../../src/util/assert'
 import { DefaultMap } from '../../../../src/util/defaultmap'
 import { EnvironmentBuilderPrinter } from './environment-builder-printer'
-import { wrap, wrapControlDependency, wrapReference } from './printer'
+import { wrap, wrapControlDependencies, wrapReference } from './printer'
 import { EdgeType, splitEdgeTypes } from '../../../../src/dataflow/graph/edge'
 import type { DataflowGraph, FunctionArgument } from '../../../../src/dataflow/graph/graph'
 import { isPositionalArgument } from '../../../../src/dataflow/graph/graph'
@@ -128,13 +128,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} } )`
 		}
 	}
@@ -154,7 +154,7 @@ class DataflowBuilderPrinter {
 		}
 	}
 
-	private controlDependencyForArgument(id: NodeId): ControlDependency[] | undefined {
+	private controlDependenciesForArgument(id: NodeId): ControlDependency[] | 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
@@ -248,7 +248,7 @@ class DataflowBuilderPrinter {
 
 	private getControlDependencySuffix(arg: ControlDependency[] | undefined, prefix: string = '{ ', suffix: string = ' }'): string | undefined {
 		if(arg !== undefined) {
-			return `${prefix}controlDependency: ${wrapControlDependency(arg)}${suffix}`
+			return `${prefix}controlDependencies: ${wrapControlDependencies(arg)}${suffix}`
 		}
 		return undefined
 	}

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

@@ -41,7 +41,7 @@ export class DataflowGraphBuilder extends DataflowGraph {
 	 */
 	public defineFunction(id: NodeId,
 		exitPoints: readonly NodeId[], subflow: DataflowFunctionFlowInformation,
-		info?: { environment?: REnvironmentInformation, controlDependency?: ControlDependency[] },
+		info?: { environment?: REnvironmentInformation, controlDependencies?: ControlDependency[] },
 		asRoot: boolean = true) {
 		return this.addVertex({
 			tag:     VertexType.FunctionDefinition,
@@ -55,7 +55,7 @@ export class DataflowGraphBuilder extends DataflowGraph {
 				unknownReferences: subflow.unknownReferences.map(o => ({ ...o, nodeId: normalizeIdToNumberIfPossible(o.nodeId), controlDependencies: o.controlDependencies?.map(c => ({ ...c, id: normalizeIdToNumberIfPossible(c.id) })) }))
 			} as DataflowFunctionFlowInformation,
 			exitPoints:          exitPoints.map(normalizeIdToNumberIfPossible),
-			controlDependencies: info?.controlDependency?.map(c => ({ ...c, id: normalizeIdToNumberIfPossible(c.id) })),
+			controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: normalizeIdToNumberIfPossible(c.id) })),
 			environment:         info?.environment
 		}, asRoot)
 	}
@@ -72,21 +72,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?: ControlDependency[]
+			returns?:             readonly NodeId[],
+			reads?:               readonly NodeId[],
+			onlyBuiltIn?:         boolean,
+			environment?:         REnvironmentInformation,
+			controlDependencies?: ControlDependency[]
 		},
 		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(c => ({ ...c, id: normalizeIdToNumberIfPossible(c.id) })),
+			controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: normalizeIdToNumberIfPossible(c.id) })),
 			onlyBuiltin:         info?.onlyBuiltIn ?? onlyBuiltInAuto ?? false
 		}, asRoot)
 		this.addArgumentLinks(id, args)
@@ -132,12 +132,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?: ControlDependency[], definedBy?: NodeId[]}, asRoot: boolean = true) {
+		info?: { controlDependencies?: ControlDependency[], definedBy?: NodeId[]}, asRoot: boolean = true) {
 		this.addVertex({
 			tag:                 VertexType.VariableDefinition,
 			id:                  normalizeIdToNumberIfPossible(id),
 			name,
-			controlDependencies: info?.controlDependency?.map(c => ({ ...c, id: normalizeIdToNumberIfPossible(c.id) })),
+			controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: normalizeIdToNumberIfPossible(c.id) })),
 		}, asRoot)
 		if(info?.definedBy) {
 			for(const def of info.definedBy) {
@@ -178,11 +178,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?: ControlDependency[] }, asRoot: boolean = true) {
+	public constant(id: NodeId, options?: { controlDependencies?: ControlDependency[] }, asRoot: boolean = true) {
 		return this.addVertex({
 			tag:                 VertexType.Value,
 			id:                  normalizeIdToNumberIfPossible(id),
-			controlDependencies: options?.controlDependency?.map(c => ({ ...c, id: normalizeIdToNumberIfPossible(c.id) })),
+			controlDependencies: options?.controlDependencies?.map(c => ({ ...c, id: normalizeIdToNumberIfPossible(c.id) })),
 			environment:         undefined
 		}, asRoot)
 	}

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

@@ -1,5 +1,5 @@
 import { assertUnreachable, isNotUndefined } from '../../../../src/util/assert'
-import { wrap, wrapControlDependency } from './printer'
+import { wrap, wrapControlDependencies } from './printer'
 import type { IEnvironment, REnvironmentInformation } from '../../../../src/dataflow/environments/environment'
 import { BuiltInEnvironment } from '../../../../src/dataflow/environments/environment'
 import type { IdentifierDefinition } from '../../../../src/dataflow/environments/identifier'
@@ -77,7 +77,7 @@ export class EnvironmentBuilderPrinter {
 	}
 
 	private getControlDependencyArgument(def: IdentifierDefinition) {
-		return def.controlDependencies ? wrapControlDependency(def.controlDependencies) : undefined
+		return def.controlDependencies ? wrapControlDependencies(def.controlDependencies) : undefined
 	}
 
 	private push() {

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

@@ -18,8 +18,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?: ControlDependency[] }): FunctionArgument {
-	return { nodeId: normalizeIdToNumberIfPossible(nodeId), name: options?.name, controlDependencies: options?.controlDependency?.map(c => ({ ...c, id: normalizeIdToNumberIfPossible(c.id) })) }
+export function argumentInCall(nodeId: NodeId, options?: { name?: string, controlDependencies?: ControlDependency[] }): FunctionArgument {
+	return { nodeId: normalizeIdToNumberIfPossible(nodeId), name: options?.name, controlDependencies: options?.controlDependencies?.map(c => ({ ...c, id: normalizeIdToNumberIfPossible(c.id) })) }
 }
 /**
  * The constant global environment with all pre-defined functions.

test/functionality/_helper/dataflow/printer.ts

@@ -21,15 +21,15 @@ export function wrap(id: string | NodeId | undefined): string {
 	}
 }
 
-export function wrapControlDependency(controlDependency: ControlDependency[] | undefined): string {
-	if(controlDependency === undefined) {
+export function wrapControlDependencies(controlDependencies: ControlDependency[] | undefined): string {
+	if(controlDependencies === undefined) {
 		return 'undefined'
 	} else {
-		return `[${controlDependency.map(c =>
+		return `[${controlDependencies.map(c =>
 			`{ id: ${wrap(c.id)}, when: ${c.when} }`	
 		).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)} }`
 }

test/functionality/_helper/shell.ts

@@ -293,6 +293,8 @@ export function assertSliced(name: string | TestLabel, shell: RShell, input: str
 	const fullname = decorateLabelContext(name, ['slice'])
 
 	const t = it(`${JSON.stringify(criteria)} ${fullname}`, async function() {
+		await ensureConfig(shell, this, userConfig)
+
 		const result = await new PipelineExecutor(DEFAULT_RECONSTRUCT_PIPELINE,{
 			getId,
 			request:   requestFromInput(input),